combine.c (record_dead_and_set_regs): Iterate over hard register set with a hard_reg_...

	* 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

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index b56c773ebc93a1866f675387ab0a545673ade3d2..52ef5324cbe004d6cc2dac2f9c5d764d5624fb19 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+2012-10-16  Steven Bosscher  <steven@gcc.gnu.org>
+
+       * 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  <eraman@google.com>
 
        * optabs.c (emit_cmp_and_jump_insn_1): Add a new parameter to

diff --git a/gcc/combine.c b/gcc/combine.c
index c13d00408ad8b7fdae55ef8a6b49e4e229942e40..bf06d4c118f846285bed89ba1378254e23a0b830 100644 (file)
--- 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;
-
-           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;
-         }
+      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;
+       }
 
       last_call_luid = mem_last_set = DF_INSN_LUID (insn);
 

diff --git a/gcc/cse.c b/gcc/cse.c
index 16255988fc538a25216ca48c9411626ddda6d110..b5631f363dab78d21dc897c55e9667bb307c1b64 100644 (file)
--- 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 a066b36c642abb3bab1a7e7bbae72f533334fb76..138150b198e55b1996a2b6155faa9a363a63a096 100644 (file)
--- 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 4619c626b7b249a91572370414695be4d0db779d..43d3c4e3ede075580839510fc3674f0f814ee2e9 100644 (file)
--- 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 b464d1fdc3fcc7cdb608748ed094c103a51dc60b..ab4f851b75677bea91c30e085ed2de305b202f70 100644 (file)
--- 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 744878d8e63c8fadc6a14b062865ea4da3654b18..3cda1a7c24e9b7cfb8d398353a8a0cc655c446bf 100644 (file)
--- 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 6a6cd420a0c945aba3d285a09f29246847e1b12f..7e6bee3e1300e106ca4a213a53832aff27b839b5 100644 (file)
--- 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)
     {