From c7fb4c7aaed8a053dd0a6f2bca0c5f54fa34f155 Mon Sep 17 00:00:00 2001 From: Steven Bosscher Date: Tue, 16 Oct 2012 07:46:11 +0000 Subject: [PATCH] combine.c (record_dead_and_set_regs): Iterate over hard register set with a hard_reg_set_iterator. * combine.c (record_dead_and_set_regs): Iterate over hard register set with a hard_reg_set_iterator. * cse.c (invalidate_for_call): Likewise. * gcse.c (compute_hash_table_work): Likewise. * loop-iv.c (simplify_using_initial_values): Likewise. * postreload-gcse.c (record_opr_changes): Likewise. * regcprop.c (copyprop_hardreg_forward_1): Likewise. * var-tracking.c (dataflow_set_clear_at_call): Likewise. From-SVN: r192490 --- gcc/ChangeLog | 11 +++++++++++ gcc/combine.c | 28 ++++++++++++++-------------- gcc/cse.c | 24 +++++++++++------------- gcc/gcse.c | 7 ++++--- gcc/loop-iv.c | 10 +++++----- gcc/postreload-gcse.c | 7 +++---- gcc/regcprop.c | 15 +++++++++------ gcc/var-tracking.c | 8 ++++---- 8 files changed, 61 insertions(+), 49 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index b56c773ebc9..52ef5324cbe 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,14 @@ +2012-10-16 Steven Bosscher + + * combine.c (record_dead_and_set_regs): Iterate over hard register set + with a hard_reg_set_iterator. + * cse.c (invalidate_for_call): Likewise. + * gcse.c (compute_hash_table_work): Likewise. + * loop-iv.c (simplify_using_initial_values): Likewise. + * postreload-gcse.c (record_opr_changes): Likewise. + * regcprop.c (copyprop_hardreg_forward_1): Likewise. + * var-tracking.c (dataflow_set_clear_at_call): Likewise. + 2012-10-15 Easwaran Raman * optabs.c (emit_cmp_and_jump_insn_1): Add a new parameter to diff --git a/gcc/combine.c b/gcc/combine.c index c13d00408ad..bf06d4c118f 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -12317,21 +12317,21 @@ record_dead_and_set_regs (rtx insn) if (CALL_P (insn)) { - for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i)) - { - reg_stat_type *rsp; + hard_reg_set_iterator hrsi; + EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, i, hrsi) + { + reg_stat_type *rsp; - rsp = &VEC_index (reg_stat_type, reg_stat, i); - rsp->last_set_invalid = 1; - rsp->last_set = insn; - rsp->last_set_value = 0; - rsp->last_set_mode = VOIDmode; - rsp->last_set_nonzero_bits = 0; - rsp->last_set_sign_bit_copies = 0; - rsp->last_death = 0; - rsp->truncated_to_mode = VOIDmode; - } + rsp = &VEC_index (reg_stat_type, reg_stat, i); + rsp->last_set_invalid = 1; + rsp->last_set = insn; + rsp->last_set_value = 0; + rsp->last_set_mode = VOIDmode; + rsp->last_set_nonzero_bits = 0; + rsp->last_set_sign_bit_copies = 0; + rsp->last_death = 0; + rsp->truncated_to_mode = VOIDmode; + } last_call_luid = mem_last_set = DF_INSN_LUID (insn); diff --git a/gcc/cse.c b/gcc/cse.c index 16255988fc5..b5631f363da 100644 --- a/gcc/cse.c +++ b/gcc/cse.c @@ -2096,24 +2096,22 @@ invalidate_for_call (void) unsigned hash; struct table_elt *p, *next; int in_table = 0; + hard_reg_set_iterator hrsi; /* Go through all the hard registers. For each that is clobbered in a CALL_INSN, remove the register from quantity chains and update reg_tick if defined. Also see if any of these registers is currently in the table. */ - - for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) - if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)) - { - delete_reg_equiv (regno); - if (REG_TICK (regno) >= 0) - { - REG_TICK (regno)++; - SUBREG_TICKED (regno) = -1; - } - - in_table |= (TEST_HARD_REG_BIT (hard_regs_in_table, regno) != 0); - } + EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, regno, hrsi) + { + delete_reg_equiv (regno); + if (REG_TICK (regno) >= 0) + { + REG_TICK (regno)++; + SUBREG_TICKED (regno) = -1; + } + in_table |= (TEST_HARD_REG_BIT (hard_regs_in_table, regno) != 0); + } /* In the case where we have no call-clobbered hard registers in the table, we are done. Otherwise, scan the table and remove any diff --git a/gcc/gcse.c b/gcc/gcse.c index a066b36c642..138150b198e 100644 --- a/gcc/gcse.c +++ b/gcc/gcse.c @@ -1519,9 +1519,10 @@ compute_hash_table_work (struct hash_table_d *table) if (CALL_P (insn)) { - for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) - if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)) - record_last_reg_set_info (insn, regno); + hard_reg_set_iterator hrsi; + EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, + 0, regno, hrsi) + record_last_reg_set_info (insn, regno); if (! RTL_CONST_OR_PURE_CALL_P (insn)) record_last_mem_set_info (insn); diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c index 4619c626b7b..43d3c4e3ede 100644 --- a/gcc/loop-iv.c +++ b/gcc/loop-iv.c @@ -1964,12 +1964,12 @@ simplify_using_initial_values (struct loop *loop, enum rtx_code op, rtx *expr) note_stores (PATTERN (insn), mark_altered, this_altered); if (CALL_P (insn)) { - int i; - /* Kill all call clobbered registers. */ - for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i)) - SET_REGNO_REG_SET (this_altered, i); + unsigned int i; + hard_reg_set_iterator hrsi; + EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, + 0, i, hrsi) + SET_REGNO_REG_SET (this_altered, i); } if (suitable_set_for_replacement (insn, &dest, &src)) diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c index b464d1fdc3f..ab4f851b756 100644 --- a/gcc/postreload-gcse.c +++ b/gcc/postreload-gcse.c @@ -736,10 +736,9 @@ record_opr_changes (rtx insn) { unsigned int regno; rtx link, x; - - for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) - if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)) - record_last_reg_set_info_regno (insn, regno); + hard_reg_set_iterator hrsi; + EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, regno, hrsi) + record_last_reg_set_info_regno (insn, regno); for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1)) if (GET_CODE (XEXP (link, 0)) == CLOBBER) diff --git a/gcc/regcprop.c b/gcc/regcprop.c index 744878d8e63..3cda1a7c24e 100644 --- a/gcc/regcprop.c +++ b/gcc/regcprop.c @@ -990,9 +990,12 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) /* Clobber call-clobbered registers. */ if (CALL_P (insn)) { - int set_regno = INVALID_REGNUM; - int set_nregs = 0; + unsigned int set_regno = INVALID_REGNUM; + unsigned int set_nregs = 0; + unsigned int regno; rtx exp; + hard_reg_set_iterator hrsi; + for (exp = CALL_INSN_FUNCTION_USAGE (insn); exp; exp = XEXP (exp, 1)) { rtx x = XEXP (exp, 0); @@ -1009,10 +1012,10 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd) break; } } - for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i) - && (i < set_regno || i >= set_regno + set_nregs)) - kill_value_regno (i, 1, vd); + + EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, regno, hrsi) + if (regno < set_regno || regno >= set_regno + set_nregs) + kill_value_regno (regno, 1, vd); } /* Notice stores. */ diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c index 6a6cd420a0c..7e6bee3e130 100644 --- a/gcc/var-tracking.c +++ b/gcc/var-tracking.c @@ -4680,11 +4680,11 @@ dataflow_set_remove_mem_locs (void **slot, void *data) static void dataflow_set_clear_at_call (dataflow_set *set) { - int r; + unsigned int r; + hard_reg_set_iterator hrsi; - for (r = 0; r < FIRST_PSEUDO_REGISTER; r++) - if (TEST_HARD_REG_BIT (regs_invalidated_by_call, r)) - var_regno_delete (set, r); + EXECUTE_IF_SET_IN_HARD_REG_SET (regs_invalidated_by_call, 0, r, hrsi) + var_regno_delete (set, r); if (MAY_HAVE_DEBUG_INSNS) {