From 1a43c33f9c8ada90741eb276c988da2c1a6fd884 Mon Sep 17 00:00:00 2001 From: Richard Kenner Date: Mon, 10 Apr 2000 11:23:17 +0000 Subject: [PATCH] regrename.c: Minor cleanups, including changing some variables to unsigned int. * regrename.c: Minor cleanups, including changing some variables to unsigned int. From-SVN: r33053 --- gcc/ChangeLog | 5 + gcc/regrename.c | 475 +++++++++++++++++++++++++----------------------- 2 files changed, 254 insertions(+), 226 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index be455f9777b..21985c5a85a 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,8 @@ +Mon Apr 10 07:21:13 2000 Richard Kenner + + * regrename.c: Minor cleanups, including chang some variables + to unsigned int. + 2000-04-10 Neil Booth * cpplex.c (skip_block_comment): Use pointer arithmetic rather diff --git a/gcc/regrename.c b/gcc/regrename.c index a83c46c9c06..26129496f14 100644 --- a/gcc/regrename.c +++ b/gcc/regrename.c @@ -75,24 +75,28 @@ ext_basic_blocks; #define DESTINATION 1 #define SOURCE 2 -static void build_def_use PARAMS ((int, ext_basic_blocks *, HARD_REG_SET *, - def_uses *, sbitmap *)); -static int replace_reg_in_block - PARAMS ((def_uses *, varray_type *, int, rtx, int)); -static int consider_def PARAMS ((rtx, int, def_uses *, int)); -static int consider_available PARAMS ((rtx, int, HARD_REG_SET *, int, def_uses *, int)); -static rtx rr_replace_reg PARAMS ((rtx, rtx, rtx, int, rtx, int *)); -static int consider_use PARAMS ((rtx, int, int, int)); -static int condmove_p PARAMS ((rtx)); -static void dump_def_use_chain PARAMS ((HARD_REG_SET *, def_uses *, - varray_type *)); -static void dump_ext_bb_info PARAMS ((int, ext_basic_blocks *)); -static void find_ext_basic_blocks PARAMS ((ext_basic_blocks *)); -static void find_one_ext_basic_block PARAMS ((int, basic_block, sbitmap *, - ext_basic_blocks *)); -static enum reg_class get_reg_class PARAMS ((rtx, rtx, int, enum reg_class)); -static rtx regno_first_use_in PARAMS ((int, rtx)); - +static void build_def_use PARAMS ((int, ext_basic_blocks *, + HARD_REG_SET *, def_uses *, + sbitmap *)); +static int replace_reg_in_block PARAMS ((def_uses *, varray_type *, + int, rtx, unsigned int)); +static int consider_def PARAMS ((rtx, int, def_uses *, int)); +static int consider_available PARAMS ((rtx, int, HARD_REG_SET *, + int, def_uses *, int)); +static rtx rr_replace_reg PARAMS ((rtx, rtx, rtx, int, rtx, + int *)); +static int consider_use PARAMS ((rtx, int, int, int)); +static int condmove_p PARAMS ((rtx)); +static void dump_def_use_chain PARAMS ((HARD_REG_SET *, def_uses *, + varray_type *)); +static void dump_ext_bb_info PARAMS ((int, ext_basic_blocks *)); +static void find_ext_basic_blocks PARAMS ((ext_basic_blocks *)); +static void find_one_ext_basic_block PARAMS ((int, basic_block, sbitmap *, + ext_basic_blocks *)); +static enum reg_class get_reg_class PARAMS ((rtx, rtx, int, + enum reg_class)); +static rtx regno_first_use_in PARAMS ((unsigned int, rtx)); + void regrename_optimize () { @@ -101,7 +105,6 @@ regrename_optimize () def_uses du; ext_basic_blocks ebb; - /* Registers used in a given class */ HARD_REG_SET class_regs; @@ -133,11 +136,11 @@ regrename_optimize () VARRAY_RTX_INIT (uid_ruid, UID_RUID_HIGH_BOUND + 1, "uid_ruid"); VARRAY_LONG_INIT (uid_rbid, UID_RUID_HIGH_BOUND + 1, "uid_rbid"); - ebb.basic_block = - sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks); + ebb.basic_block + = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks); sbitmap_vector_zero (ebb.basic_block, n_basic_blocks); - ebb.exit = - sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks); + ebb.exit + = sbitmap_vector_alloc (n_basic_blocks, n_basic_blocks); sbitmap_vector_zero (ebb.exit, n_basic_blocks); find_ext_basic_blocks (&ebb); @@ -149,26 +152,27 @@ regrename_optimize () if (TEST_BIT (ebb.basic_block[b], b)) { for (eb = du.high_bound = 0; eb < n_basic_blocks; eb++) - { - if (TEST_BIT (ebb.basic_block[b], eb)) - { - basic_block bb = BASIC_BLOCK (eb); - /* Calculate high bound for uid_ruid and allocate if necessary */ - for (insn = bb->head; - insn != NEXT_INSN (bb->end); - du.high_bound++, insn = NEXT_INSN (insn)) - { - int uid_ruid_high_bound = VARRAY_SIZE (uid_ruid); - if (du.high_bound + 4 >= uid_ruid_high_bound) - { - VARRAY_GROW (uid_ruid, uid_ruid_high_bound * 2); - VARRAY_GROW (uid_rbid, uid_ruid_high_bound * 2); - } - VARRAY_RTX (uid_ruid, du.high_bound) = insn; - VARRAY_LONG (uid_rbid, du.high_bound) = eb; - } - } - } + if (TEST_BIT (ebb.basic_block[b], eb)) + { + basic_block bb = BASIC_BLOCK (eb); + + /* Calculate high bound for uid_ruid and allocate if necessary */ + for (insn = bb->head; + insn != NEXT_INSN (bb->end); + du.high_bound++, insn = NEXT_INSN (insn)) + { + int uid_ruid_high_bound = VARRAY_SIZE (uid_ruid); + + if (du.high_bound + 4 >= uid_ruid_high_bound) + { + VARRAY_GROW (uid_ruid, uid_ruid_high_bound * 2); + VARRAY_GROW (uid_rbid, uid_ruid_high_bound * 2); + } + + VARRAY_RTX (uid_ruid, du.high_bound) = insn; + VARRAY_LONG (uid_rbid, du.high_bound) = eb; + } + } CLEAR_HARD_REG_SET (null_bitmap); CLEAR_HARD_REG_SET (class_regs); @@ -177,27 +181,28 @@ regrename_optimize () CLEAR_HARD_REG_SET (tmp_bitmap); CLEAR_HARD_REG_SET (renamed_regs); - du.defs = - sbitmap_vector_alloc (FIRST_PSEUDO_REGISTER, du.high_bound + 1); + du.defs + = sbitmap_vector_alloc (FIRST_PSEUDO_REGISTER, du.high_bound + 1); sbitmap_vector_zero (du.defs, FIRST_PSEUDO_REGISTER); - du.uses = - sbitmap_vector_alloc (FIRST_PSEUDO_REGISTER, du.high_bound + 1); + du.uses + = sbitmap_vector_alloc (FIRST_PSEUDO_REGISTER, du.high_bound + 1); sbitmap_vector_zero (du.uses, FIRST_PSEUDO_REGISTER); du.require_call_save_reg = sbitmap_alloc (du.high_bound + 1); sbitmap_zero (du.require_call_save_reg); defs_live_exit = sbitmap_alloc (du.high_bound + 1); sbitmap_zero (defs_live_exit); - du.def_class = xrealloc - (du.def_class, - sizeof (enum reg_class) * FIRST_PSEUDO_REGISTER * du.high_bound); + du.def_class + = xrealloc (du.def_class, + (sizeof (enum reg_class) * FIRST_PSEUDO_REGISTER + * du.high_bound)); - du.use_class = xrealloc - (du.use_class, - sizeof (enum reg_class) * FIRST_PSEUDO_REGISTER * du.high_bound); + du.use_class + = xrealloc (du.use_class, + (sizeof (enum reg_class) * FIRST_PSEUDO_REGISTER + * du.high_bound)); - build_def_use (b, &ebb, ®s_used, &du, - &defs_live_exit); + build_def_use (b, &ebb, ®s_used, &du, &defs_live_exit); if (rtl_dump_file) { @@ -211,17 +216,18 @@ regrename_optimize () as it just treats them as a big basic block. */ COPY_HARD_REG_SET (tmp_bitmap, regs_used); - REG_SET_TO_HARD_REG_SET (global_live_at_start, BASIC_BLOCK (b)->global_live_at_start); + REG_SET_TO_HARD_REG_SET (global_live_at_start, + BASIC_BLOCK (b)->global_live_at_start); IOR_HARD_REG_SET (tmp_bitmap, global_live_at_start); for (eb = 0; eb < n_basic_blocks; eb++) - { - if (TEST_BIT (ebb.basic_block[b], eb)) - { - basic_block bb = BASIC_BLOCK (eb); - REG_SET_TO_HARD_REG_SET (global_live_at_end, bb->global_live_at_end); - IOR_HARD_REG_SET (tmp_bitmap, global_live_at_end); - } - } + if (TEST_BIT (ebb.basic_block[b], eb)) + { + basic_block bb = BASIC_BLOCK (eb); + + REG_SET_TO_HARD_REG_SET (global_live_at_end, + bb->global_live_at_end); + IOR_HARD_REG_SET (tmp_bitmap, global_live_at_end); + } def_idx = xcalloc (du.high_bound, sizeof (int)); @@ -239,56 +245,53 @@ regrename_optimize () /* Find def_idx[N] where hbound of N is the number of definitions of this register in this block. and def_idx is the ordinal position of this insn in the block. */ - for (i = 0, def_idx[def_cnt] = 0; - i < du.high_bound; - i++) - { - if (TEST_BIT (du.defs[r], i) - && consider_def (VARRAY_RTX (uid_ruid, i), r, - &du, i)) - { - int first_use = 1; - def_idx[def_cnt] = i; + for (i = 0, def_idx[def_cnt] = 0; i < du.high_bound; i++) + if (TEST_BIT (du.defs[r], i) + && consider_def (VARRAY_RTX (uid_ruid, i), r, &du, i)) + { + int first_use = 1; + def_idx[def_cnt] = i; - /* Only consider definitions that have a use. */ - for (use_idx = i + 1; use_idx < du.high_bound; - use_idx++) - { - if (TEST_BIT (du.uses[r], use_idx)) - { - if (consider_use (VARRAY_RTX (uid_ruid, use_idx), r, - VARRAY_LONG (uid_rbid, i), - VARRAY_LONG (uid_rbid, use_idx))) - { - if (first_use) - { - first_use = 0; - def_cnt++; - } - } - else - { - /* Don't consider def if we don't want this use */ - if (!first_use) - def_cnt--; - break; - } - } - if (TEST_BIT (du.defs[r], use_idx)) - break; - } - /* Scan until the next def to avoid renaming - parameter registers. */ - /* ??? consider using CALL_INSN_FUNCTION_USAGE */ - for (call_idx = i; call_idx <= use_idx; call_idx++) - if (VARRAY_RTX (uid_ruid, call_idx) - && GET_CODE (VARRAY_RTX (uid_ruid, call_idx)) - == CALL_INSN) + /* Only consider definitions that have a use. */ + for (use_idx = i + 1; use_idx < du.high_bound; use_idx++) + { + if (TEST_BIT (du.uses[r], use_idx)) { - SET_BIT (du.require_call_save_reg, i); + if (consider_use (VARRAY_RTX (uid_ruid, use_idx), r, + VARRAY_LONG (uid_rbid, i), + VARRAY_LONG (uid_rbid, use_idx))) + { + if (first_use) + { + first_use = 0; + def_cnt++; + } + } + else + { + /* Don't consider def if we don't want this + use. */ + if (!first_use) + def_cnt--; + + break; + } } - } - } + + if (TEST_BIT (du.defs[r], use_idx)) + break; + } + + /* Scan until the next def to avoid renaming + parameter registers. */ + /* ??? consider using CALL_INSN_FUNCTION_USAGE */ + for (call_idx = i; call_idx <= use_idx; call_idx++) + if (VARRAY_RTX (uid_ruid, call_idx) + && (GET_CODE (VARRAY_RTX (uid_ruid, call_idx)) + == CALL_INSN)) + SET_BIT (du.require_call_save_reg, i); + } + if (def_cnt < 2) continue; @@ -303,8 +306,9 @@ regrename_optimize () (GET_CODE (VARRAY_RTX (uid_ruid, def_idx[def]))) == 'i')) { - rtx reg_use = regno_first_use_in - (r, PATTERN (VARRAY_RTX (uid_ruid, def_idx[def]))); + rtx reg_use + = regno_first_use_in + (r, PATTERN (VARRAY_RTX (uid_ruid, def_idx[def]))); if (!reg_use) break; @@ -314,7 +318,7 @@ regrename_optimize () break; #endif rc = (int) DU_REG_CLASS (du.def_class, - r, du.high_bound, def_idx[def]); + r, du.high_bound, def_idx[def]); COPY_HARD_REG_SET (avail_regs, reg_class_contents[(enum reg_class) rc]); AND_COMPL_HARD_REG_SET (avail_regs, tmp_bitmap); @@ -323,25 +327,26 @@ regrename_optimize () /* No available registers in this class */ GO_IF_HARD_REG_EQUAL (avail_regs, null_bitmap, no_available_regs); + for (ar_idx = 0; ar_idx < FIRST_PSEUDO_REGISTER && TEST_HARD_REG_BIT (avail_regs, ar_idx); ar_idx++) ; + if (ar_idx == FIRST_PSEUDO_REGISTER) goto no_available_regs; /* Only try register renaming if there is an available register in this class. */ - for (ar_idx = 0; - ar_idx < FIRST_PSEUDO_REGISTER; - ar_idx++) + for (ar_idx = 0; ar_idx < FIRST_PSEUDO_REGISTER; ar_idx++) { #ifdef REG_ALLOC_ORDER avail_reg = reg_alloc_order[ar_idx]; #else avail_reg = ar_idx; #endif - if (consider_available (reg_use, avail_reg, &avail_regs, - rc, &du, def_idx[def])) + if (consider_available (reg_use, avail_reg, + &avail_regs, rc, &du, + def_idx[def])) break; } @@ -360,8 +365,11 @@ regrename_optimize () if (TEST_BIT (du.require_call_save_reg, def_idx[def])) fprintf (rtl_dump_file, " crosses a call"); - fprintf (rtl_dump_file, ". No available registers\n"); + + fprintf (rtl_dump_file, + ". No available registers\n"); } + goto try_next_def; } @@ -371,35 +379,51 @@ regrename_optimize () /* Replace in destination. Replace in source for remainder of block until new register is defined again */ - replace_ok = replace_reg_in_block - (&du, &uid_ruid, def_idx[def], reg_use, avail_reg); + replace_ok + = replace_reg_in_block (&du, &uid_ruid, def_idx[def], + reg_use, avail_reg); + /* Replace failed, so restore previous register */ if (!replace_ok) { replace_reg_in_block (&du, &uid_ruid, def_idx[def], - gen_rtx_REG (GET_MODE (reg_use), - avail_reg), + gen_rtx_REG (GET_MODE (reg_use), + avail_reg), REGNO (reg_use)); + if (rtl_dump_file) - fprintf (rtl_dump_file, - "Register %s in class %s Renaming as %s would not satisfy constraints\n", - reg_names[r], reg_class_names[rc], - reg_names[avail_reg]); + { + fprintf (rtl_dump_file, + "Register %s in class %s Renaming as %s ", + reg_names[r], reg_class_names[rc], + reg_names[avail_reg]); + fprintf (rtl_dump_file, + "would not satisfy constraints\n"); + } } + else if (rtl_dump_file) - fprintf (rtl_dump_file, - "Register %s in class %s Renamed as %s at insn %d\n", - reg_names[r], reg_class_names[rc], - reg_names[avail_reg], - INSN_UID (VARRAY_RTX (uid_ruid, def_idx[def]))); + { + fprintf (rtl_dump_file, + "Register %s in class %s Renamed as %s ", + reg_names[r], reg_class_names[rc], + reg_names[avail_reg]); + fprintf (rtl_dump_file, "at insn %d\n", + INSN_UID (VARRAY_RTX (uid_ruid, + def_idx[def]))); + } } + try_next_def: continue; } + sbitmap_zero (du.defs[r]); + no_available_regs: continue; } + free (def_idx); sbitmap_vector_free (du.defs); sbitmap_vector_free (du.uses); @@ -429,7 +453,8 @@ build_def_use (b, ebb, regs_used, du, defs_live_exit) sbitmap *defs_live_exit; { rtx insn; - int eb, inum, r; + int eb, inum; + unsigned int r; inum = 0; for (eb = 0; eb < n_basic_blocks; eb++) @@ -452,9 +477,7 @@ build_def_use (b, ebb, regs_used, du, defs_live_exit) CLEAR_RESOURCE (&insn_sets); mark_set_resources (insn, &insn_sets, 0, MARK_DEST); - for (r = 0; - r < FIRST_PSEUDO_REGISTER; - r++) + for (r = 0; r < FIRST_PSEUDO_REGISTER; r++) { if (!TEST_HARD_REG_BIT (insn_sets.regs, r)) continue; @@ -462,31 +485,32 @@ build_def_use (b, ebb, regs_used, du, defs_live_exit) SET_HARD_REG_BIT (*regs_used, r); if (REGNO_REG_SET_P (bb->global_live_at_end, r)) SET_BIT (*defs_live_exit, inum); + if (!insn_sets.memory) SET_BIT (du->defs[r], inum); - DU_REG_CLASS (du->def_class, r, du->high_bound, inum) = get_reg_class - (insn, regno_first_use_in (r, PATTERN (insn)), - DESTINATION, NO_REGS); + + DU_REG_CLASS (du->def_class, r, du->high_bound, inum) + = get_reg_class (insn, regno_first_use_in (r, PATTERN (insn)), + DESTINATION, NO_REGS); } CLEAR_RESOURCE (&insn_res); mark_referenced_resources (insn, &insn_res, 0); - for (r = 0; - r < FIRST_PSEUDO_REGISTER; - r++) + for (r = 0; r < FIRST_PSEUDO_REGISTER; r++) { if (!TEST_HARD_REG_BIT (insn_res.regs, r)) continue; SET_HARD_REG_BIT (*regs_used, r); SET_BIT (du->uses[r], inum); - DU_REG_CLASS (du->use_class, r, du->high_bound, inum) = get_reg_class - (insn, regno_use_in (r, PATTERN (insn)), - SOURCE, NO_REGS); + DU_REG_CLASS (du->use_class, r, du->high_bound, inum) + = get_reg_class (insn, regno_use_in (r, PATTERN (insn)), + SOURCE, NO_REGS); } } } + free_resource_info (); } @@ -499,23 +523,24 @@ replace_reg_in_block (du, uid_ruid, def, reg_def, avail_reg) varray_type *uid_ruid; int def; rtx reg_def; - int avail_reg; + unsigned int avail_reg; { int du_idx, status = 1; - int r = REGNO (reg_def); + unsigned int r = REGNO (reg_def); rtx death_note; rtx new_reg = gen_rtx_REG (GET_MODE (reg_def), avail_reg); + rr_replace_reg (PATTERN (VARRAY_RTX (*uid_ruid, def)), reg_def, new_reg, + DESTINATION, VARRAY_RTX (*uid_ruid, def), &status); - rr_replace_reg (PATTERN (VARRAY_RTX (*uid_ruid, def)), reg_def, - new_reg, DESTINATION, VARRAY_RTX (*uid_ruid, def), - &status); if (!status) return status; death_note = find_reg_note (VARRAY_RTX (*uid_ruid, def), REG_DEAD, reg_def); if (!death_note) - death_note = find_reg_note (VARRAY_RTX (*uid_ruid, def), REG_UNUSED, reg_def); + death_note = find_reg_note (VARRAY_RTX (*uid_ruid, def), REG_UNUSED, + reg_def); + if (death_note) rr_replace_reg (death_note, reg_def, new_reg, 0, VARRAY_RTX (*uid_ruid, def), &status); @@ -524,10 +549,11 @@ replace_reg_in_block (du, uid_ruid, def, reg_def, avail_reg) { rtx reg_use; rtx new_reg; + if (GET_RTX_CLASS (GET_CODE (VARRAY_RTX (*uid_ruid, du_idx))) != 'i') continue; - reg_use = regno_use_in (r, PATTERN (VARRAY_RTX (*uid_ruid, du_idx))); + reg_use = regno_use_in (r, PATTERN (VARRAY_RTX (*uid_ruid, du_idx))); if (reg_use && TEST_BIT (du->uses[r], du_idx)) { new_reg = gen_rtx_REG (GET_MODE (reg_use), avail_reg); @@ -542,14 +568,17 @@ replace_reg_in_block (du, uid_ruid, def, reg_def, avail_reg) if (death_note) rr_replace_reg (death_note, reg_use, new_reg, 0, VARRAY_RTX (*uid_ruid, def), &status); + SET_BIT (du->uses[avail_reg], du_idx); RESET_BIT (du->uses[r], du_idx); if (!status) return status; } + if (TEST_BIT (du->defs[r], du_idx)) break; } + return status; } @@ -584,6 +613,7 @@ rr_replace_reg (x, reg_use, reg_sub, replace_type, insn, status) else return gen_rtx_REG (GET_MODE (x), REGNO (reg_use)); } + return x; case SET: @@ -592,15 +622,15 @@ rr_replace_reg (x, reg_use, reg_sub, replace_type, insn, status) replace_type, insn, status); else if (replace_type == SOURCE) { - int dest_subregno; + unsigned int dest_subregno; + int had_subreg = GET_CODE (SET_DEST (x)) == SUBREG; - if (GET_CODE (SET_DEST (x)) == SUBREG) + if (had_subreg) dest_subregno = REGNO (XEXP (SET_DEST (x), 0)); - else - dest_subregno = 0; SET_SRC (x) = rr_replace_reg (SET_SRC (x), reg_use, reg_sub, replace_type, insn, status); + /* If the replacement register is not part of the source then it may be part of a source mem operand. */ if (GET_CODE (SET_DEST (x)) == MEM @@ -609,9 +639,8 @@ rr_replace_reg (x, reg_use, reg_sub, replace_type, insn, status) || GET_CODE (SET_DEST (x)) == STRICT_LOW_PART) SET_DEST (x) = rr_replace_reg (SET_DEST (x), reg_use, reg_sub, replace_type, insn, status); - /* shared rtl sanity check */ - if (dest_subregno - && dest_subregno != REGNO (XEXP (SET_DEST (x), 0))) + /* Shared rtl sanity check. */ + if (had_subreg && dest_subregno != REGNO (XEXP (SET_DEST (x), 0))) { *status = 0; return x; @@ -622,16 +651,18 @@ rr_replace_reg (x, reg_use, reg_sub, replace_type, insn, status) if (n >= 0) { int id; + extract_insn (insn); /* Any MATCH_DUP's which are REGs must still match */ for (id = insn_data[n].n_dups - 1; id >= 0; id--) { int opno = recog_data.dup_num[id]; + if (GET_CODE (*recog_data.dup_loc[id]) == REG && GET_CODE (*recog_data.operand_loc[opno]) == REG - && (REGNO (*recog_data.dup_loc[id]) != - REGNO (*recog_data.operand_loc[opno]))) + && (REGNO (*recog_data.dup_loc[id]) + != REGNO (*recog_data.operand_loc[opno]))) *status = 0; } @@ -659,6 +690,7 @@ rr_replace_reg (x, reg_use, reg_sub, replace_type, insn, status) if (fmt[i] == 'E') { register int xv; + for (xv = 0; xv < XVECLEN (x, i); xv++) { XVECEXP (x, i, xv) = rr_replace_reg (XVECEXP (x, i, xv), reg_use, @@ -679,6 +711,7 @@ rr_replace_reg (x, reg_use, reg_sub, replace_type, insn, status) } } } + return x; } @@ -689,8 +722,8 @@ static int consider_def (insn, regno, du, inum) rtx insn; int regno; - def_uses *du; - int inum; + def_uses *du ATTRIBUTE_UNUSED; + int inum ATTRIBUTE_UNUSED; { /* Don't rename windowed registers across a call */ #ifdef INCOMING_REGNO @@ -733,12 +766,11 @@ consider_use (insn, regno, def_block, use_block) then insure another predecessor does not also define this register */ if (def_block != use_block) for (e = ub->pred; e; e = e->pred_next) - { - if (e->src->index != def_block - && e->src->index != -1 - && REGNO_REG_SET_P (BASIC_BLOCK (e->src->index)->global_live_at_end, regno)) - return 0; - } + if (e->src->index != def_block + && e->src->index != -1 + && REGNO_REG_SET_P (BASIC_BLOCK (e->src->index)->global_live_at_end, + regno)) + return 0; /* Don't consider conditional moves. Predicate architectures may use two complementary conditional moves and the regno shouldn't change */ @@ -755,11 +787,8 @@ consider_use (insn, regno, def_block, use_block) return 0; /* Don't consider register if the only use is in a USE */ - if (reg_mentioned_p (gen_rtx_USE (VOIDmode, reg_use), - PATTERN (insn))) - return 0; - else - return 1; + return ! reg_mentioned_p (gen_rtx_USE (VOIDmode, reg_use), + PATTERN (insn)); } else return 0; @@ -810,17 +839,13 @@ consider_available (reg_use, avail_reg, avail_regs, rc, du, inum) #endif ) || (TEST_BIT (du->require_call_save_reg, inum) - && (call_used_regs[avail_reg] || call_used_regs[REGNO (reg_use)] - ))) + && (call_used_regs[avail_reg] || call_used_regs[REGNO (reg_use)]))) return 0; /* If register is a callee-saved register it must be saved in the frame. call saved registers can not be added to regs_ever_live after reload, as it would invalidate most elimination offsets */ - if (regs_ever_live[avail_reg] || call_used_regs[avail_reg]) - return 1; - - return 0; + return regs_ever_live[avail_reg] || call_used_regs[avail_reg]; } /* Return 1 if INSN is a conditional move */ @@ -829,11 +854,9 @@ static int condmove_p (insn) rtx insn; { - if (GET_CODE (insn) == INSN - && GET_CODE (PATTERN (insn)) == SET - && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE) - return 1; - return 0; + return (GET_CODE (insn) == INSN + && GET_CODE (PATTERN (insn)) == SET + && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE); } /* Searches X for the first reference to REGNO, returning the rtx of the @@ -841,7 +864,7 @@ condmove_p (insn) static rtx regno_first_use_in (regno, x) - int regno; + unsigned int regno; rtx x; { register const char *fmt; @@ -859,13 +882,14 @@ regno_first_use_in (regno, x) if ((tem = regno_first_use_in (regno, XEXP (x, i)))) return tem; } + else if (fmt[i] == 'E') for (j = XVECLEN (x, i) - 1; j >= 0; j--) if ((tem = regno_first_use_in (regno, XVECEXP (x, i, j)))) return tem; } - return NULL_RTX; + return 0; } /* Dump def/use chain DU to RTL_DUMP_FILE, given insns in UID_RUID and @@ -877,14 +901,14 @@ dump_def_use_chain (global_live_at_end, du, uid_ruid) def_uses *du; varray_type *uid_ruid; { - int r, inum; - + unsigned int r; + int inum; + for (r = 0; r < FIRST_PSEUDO_REGISTER; r++) { int set = 0; - for (inum = 0; - inum <= du->high_bound; - inum++) + + for (inum = 0; inum <= du->high_bound; inum++) { rtx insn = VARRAY_RTX (*uid_ruid, inum); #if 0 @@ -892,6 +916,7 @@ dump_def_use_chain (global_live_at_end, du, uid_ruid) || GET_RTX_CLASS (GET_CODE (insn)) != 'i') continue; + reg_use = regno_first_use_in (r, PATTERN (insn)); if (!reg_use) continue; @@ -908,11 +933,13 @@ dump_def_use_chain (global_live_at_end, du, uid_ruid) fprintf (rtl_dump_file, "Live at Exit "); set = 1; } + if (TEST_BIT (du->defs[r], inum)) fprintf (rtl_dump_file, "=%d ", INSN_UID (insn)); if (TEST_BIT (du->uses[r], inum)) fprintf (rtl_dump_file, "%d ", INSN_UID (insn)); } + if (set) fprintf (rtl_dump_file, "\n"); } @@ -926,30 +953,30 @@ dump_ext_bb_info (eb, ebb) ext_basic_blocks *ebb; { int b; + int have_ebb = 0; - { - int have_ebb = 0; - for (b = 0; b < n_basic_blocks; b++) - { - if (TEST_BIT (ebb->basic_block[eb], b)) - { - if (!have_ebb) - { + for (b = 0; b < n_basic_blocks; b++) + { + if (TEST_BIT (ebb->basic_block[eb], b)) + { + if (!have_ebb) + { #ifndef RENAME_EXTENDED_BLOCKS - fprintf (rtl_dump_file, "\nBasic block %d: ", b); + fprintf (rtl_dump_file, "\nBasic block %d: ", b); #else - fprintf (rtl_dump_file, "\nExtended basic block %d: ", b); + fprintf (rtl_dump_file, "\nExtended basic block %d: ", b); #endif - have_ebb = 1; - } - fprintf (rtl_dump_file, "%d ", b); - } - if (TEST_BIT (ebb->exit[eb], b)) - fprintf (rtl_dump_file, "(exit) "); - } - if (have_ebb) - fprintf (rtl_dump_file, "\n"); - } + have_ebb = 1; + } + fprintf (rtl_dump_file, "%d ", b); + } + + if (TEST_BIT (ebb->exit[eb], b)) + fprintf (rtl_dump_file, "(exit) "); + } + + if (have_ebb) + fprintf (rtl_dump_file, "\n"); } /* Initialize EBB with extended basic block info if RENAME_EXTENDED_BLOCKS is @@ -974,6 +1001,7 @@ find_ext_basic_blocks (ebb) #else for (b = 0; b < n_basic_blocks; b++) { + basic_block bb = BASIC_BLOCK (b); if (!TEST_BIT (bb_processed, b)) { @@ -1007,13 +1035,9 @@ find_one_ext_basic_block (entry, bb, bb_processed, ebb) { if (!e->dest->pred->pred_next && (!TEST_BIT (*bb_processed, e->dest->index))) - { - find_one_ext_basic_block (entry, e->dest, bb_processed, ebb); - } + find_one_ext_basic_block (entry, e->dest, bb_processed, ebb); else - { - SET_BIT (ebb->exit[entry], bb->index); - } + SET_BIT (ebb->exit[entry], bb->index); } } @@ -1036,17 +1060,16 @@ get_reg_class (insn, reg_use, type, default_class) preprocess_constraints (); if (type == DESTINATION) - for (id = 0; id < recog_data.n_operands; id++) - { + { + for (id = 0; id < recog_data.n_operands; id++) if (rtx_equal_p (recog_data.operand[id], reg_use)) break; - } + } + else if (type == SOURCE) for (id = recog_data.n_operands - 1; id >= 0; id--) - { - if (rtx_equal_p (recog_data.operand[id], reg_use)) - break; - } + if (rtx_equal_p (recog_data.operand[id], reg_use)) + break; if (id == -1 || id == recog_data.n_operands) return default_class; -- 2.30.2