* basic-block.h (reg_set_iterator): New.

	(EXECUTE_IF_SET_IN_REG_SET): Make it iterator style.
	(EXECUTE_IF_AND_COMPL_IN_REG_SET): Likewise.
	(EXECUTE_IF_AND_IN_REG_SET): Likewise.
	* caller-save.c (save_call_clobbered_regs): Adjust to the new
	style.
	* cfgcleanup.c (thread_jump): Likewise.
	* cfgrtl.c (safe_insert_insn_on_edge): Likewise.
	* conflict.c (conflict_graph_compute): Likewise.
	* flow.c (verify_local_live_at_start, update_life_info,
	initialize_uninitialized_subregs, propagate_one_insn,
	init_propagate_block_info, free_propagate_block_info,
	propagate_block, dump_regset): Likewise.
	* global.c (global_conflicts): Likewise.
	* graph.c (start_bb): Likewise.
	* local-alloc.c (update_equiv_regs): Likewise.
	* loop.c (load_mems): Likewise.
	* reload1.c (compute_use_by_pseudos, order_regs_for_reload,
	find_reg, finish_spills): Likewise.
	* resource.c (mark_target_live_regs): Likewise.
	* sched-deps.c (sched_analyze_insn): Likewise.
	* sched-rgn.c (sched-rgn.c): Likewise.
	* config/frv/frv.c (frv_ifcvt_modify_tests): Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@89226 138bc75d-0d04-0410-961f-82ee72b054a4

16 files changed, 285 insertions, 248 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 8d7553efbd2..78896f6d38f 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,29 @@
+2004-10-18  Kazu Hirata  <kazu@cs.umass.edu>
+
+	* basic-block.h (reg_set_iterator): New.
+	(EXECUTE_IF_SET_IN_REG_SET): Make it iterator style.
+	(EXECUTE_IF_AND_COMPL_IN_REG_SET): Likewise.
+	(EXECUTE_IF_AND_IN_REG_SET): Likewise.
+	* caller-save.c (save_call_clobbered_regs): Adjust to the new
+	style.
+	* cfgcleanup.c (thread_jump): Likewise.
+	* cfgrtl.c (safe_insert_insn_on_edge): Likewise.
+	* conflict.c (conflict_graph_compute): Likewise.
+	* flow.c (verify_local_live_at_start, update_life_info,
+	initialize_uninitialized_subregs, propagate_one_insn,
+	init_propagate_block_info, free_propagate_block_info,
+	propagate_block, dump_regset): Likewise.
+	* global.c (global_conflicts): Likewise.
+	* graph.c (start_bb): Likewise.
+	* local-alloc.c (update_equiv_regs): Likewise.
+	* loop.c (load_mems): Likewise.
+	* reload1.c (compute_use_by_pseudos, order_regs_for_reload,
+	find_reg, finish_spills): Likewise.
+	* resource.c (mark_target_live_regs): Likewise.
+	* sched-deps.c (sched_analyze_insn): Likewise.
+	* sched-rgn.c (sched-rgn.c): Likewise.
+	* config/frv/frv.c (frv_ifcvt_modify_tests): Likewise.
+
 2004-10-18  Jakub Jelinek  <jakub@redhat.com>
 
 	* config/i386/i386.md (addqi_1_slp): Test for incdec_operand
diff --git a/gcc/basic-block.h b/gcc/basic-block.h
index 534fd10364e..d9204964eeb 100644
--- a/gcc/basic-block.h
+++ b/gcc/basic-block.h
@@ -83,46 +83,24 @@ do {									\
   reg_set_to_hard_reg_set (&TO, FROM);					\
 } while (0)
 
+typedef bitmap_iterator reg_set_iterator;
+
 /* Loop over all registers in REGSET, starting with MIN, setting REGNUM to the
    register number and executing CODE for all registers that are set.  */
-#define EXECUTE_IF_SET_IN_REG_SET(REGSET, MIN, REGNUM, CODE)		\
-  do									\
-    {									\
-      bitmap_iterator bi;						\
-									\
-      EXECUTE_IF_SET_IN_BITMAP (REGSET, MIN, REGNUM, bi)		\
-	{								\
-	  CODE;								\
-        }								\
-    } while (0)
+#define EXECUTE_IF_SET_IN_REG_SET(REGSET, MIN, REGNUM, RSI)	\
+  EXECUTE_IF_SET_IN_BITMAP (REGSET, MIN, REGNUM, RSI)
 
 /* Loop over all registers in REGSET1 and REGSET2, starting with MIN, setting
    REGNUM to the register number and executing CODE for all registers that are
    set in the first regset and not set in the second.  */
-#define EXECUTE_IF_AND_COMPL_IN_REG_SET(REGSET1, REGSET2, MIN, REGNUM, CODE) \
-  do									\
-    {									\
-      bitmap_iterator bi;						\
-									\
-      EXECUTE_IF_AND_COMPL_IN_BITMAP (REGSET1, REGSET2, MIN, REGNUM, bi) \
-	{								\
-	  CODE;								\
-        }								\
-    } while (0)
+#define EXECUTE_IF_AND_COMPL_IN_REG_SET(REGSET, MIN, REGNUM, RSI)	\
+  EXECUTE_IF_AND_COMPL_IN_BITMAP (REGSET, MIN, REGNUM, RSI)
 
 /* Loop over all registers in REGSET1 and REGSET2, starting with MIN, setting
    REGNUM to the register number and executing CODE for all registers that are
    set in both regsets.  */
-#define EXECUTE_IF_AND_IN_REG_SET(REGSET1, REGSET2, MIN, REGNUM, CODE) \
-  do									\
-    {									\
-      bitmap_iterator bi;						\
-									\
-      EXECUTE_IF_AND_IN_BITMAP (REGSET1, REGSET2, MIN, REGNUM, bi)	\
-	{								\
-	  CODE;								\
-        }								\
-    } while (0)
+#define EXECUTE_IF_AND_IN_REG_SET(REGSET1, REGSET2, MIN, REGNUM, RSI) \
+  EXECUTE_IF_AND_IN_BITMAP (REGSET1, REGSET2, MIN, REGNUM, RSI)	\
 
 /* Allocate a register set with oballoc.  */
 #define OBSTACK_ALLOC_REG_SET(OBSTACK) BITMAP_OBSTACK_ALLOC (OBSTACK)
diff --git a/gcc/caller-save.c b/gcc/caller-save.c
index 53446f38ec3..55a825efe4e 100644
--- a/gcc/caller-save.c
+++ b/gcc/caller-save.c
@@ -410,6 +410,7 @@ save_call_clobbered_regs (void)
 	    {
 	      int regno;
 	      HARD_REG_SET hard_regs_to_save;
+	      reg_set_iterator rsi;
 
 	      /* Use the register life information in CHAIN to compute which
 		 regs are live during the call.  */
@@ -425,22 +426,22 @@ save_call_clobbered_regs (void)
 	      /* Look through all live pseudos, mark their hard registers
 		 and choose proper mode for saving.  */
 	      EXECUTE_IF_SET_IN_REG_SET
-		(&chain->live_throughout, FIRST_PSEUDO_REGISTER, regno,
-		 {
-		   int r = reg_renumber[regno];
-		   int nregs;
-		   enum machine_mode mode;
-
-		   gcc_assert (r >= 0);
-		   nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
-		   mode = HARD_REGNO_CALLER_SAVE_MODE
-		     (r, nregs, PSEUDO_REGNO_MODE (regno));
-		   if (GET_MODE_BITSIZE (mode)
-		       > GET_MODE_BITSIZE (save_mode[r]))
-		     save_mode[r] = mode;
-		   while (nregs-- > 0)
-		     SET_HARD_REG_BIT (hard_regs_to_save, r + nregs);
-		 });
+		(&chain->live_throughout, FIRST_PSEUDO_REGISTER, regno, rsi)
+		{
+		  int r = reg_renumber[regno];
+		  int nregs;
+		  enum machine_mode mode;
+
+		  gcc_assert (r >= 0);
+		  nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
+		  mode = HARD_REGNO_CALLER_SAVE_MODE
+		    (r, nregs, PSEUDO_REGNO_MODE (regno));
+		  if (GET_MODE_BITSIZE (mode)
+		      > GET_MODE_BITSIZE (save_mode[r]))
+		    save_mode[r] = mode;
+		  while (nregs-- > 0)
+		    SET_HARD_REG_BIT (hard_regs_to_save, r + nregs);
+		}
 
 	      /* Record all registers set in this call insn.  These don't need
 		 to be saved.  N.B. the call insn might set a subreg of a
diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index 089c3303445..8ac3405242f 100644
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -282,6 +282,7 @@ thread_jump (int mode, edge e, basic_block b)
   int i;
   regset nonequal;
   bool failed = false;
+  reg_set_iterator rsi;
 
   if (BB_FLAGS (b) & BB_NONTHREADABLE_BLOCK)
     return NULL;
@@ -396,7 +397,8 @@ thread_jump (int mode, edge e, basic_block b)
   if (mode & CLEANUP_UPDATE_LIFE)
     AND_REG_SET (nonequal, b->global_live_at_end);
 
-  EXECUTE_IF_SET_IN_REG_SET (nonequal, 0, i, goto failed_exit;);
+  EXECUTE_IF_SET_IN_REG_SET (nonequal, 0, i, rsi)
+    goto failed_exit;
 
   BITMAP_XFREE (nonequal);
   cselib_finish ();
diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index ee0b468385e..5361cd9a75f 100644
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -1465,6 +1465,7 @@ safe_insert_insn_on_edge (rtx insn, edge e)
   rtx save_regs = NULL_RTX;
   int regno, noccmode;
   enum machine_mode mode;
+  reg_set_iterator rsi;
 
 #ifdef AVOID_CCMODE_COPIES
   noccmode = true;
@@ -1478,7 +1479,7 @@ safe_insert_insn_on_edge (rtx insn, edge e)
   bitmap_operation (killed, killed, e->dest->global_live_at_start,
 		    BITMAP_AND);
 
-  EXECUTE_IF_SET_IN_REG_SET (killed, 0, regno,
+  EXECUTE_IF_SET_IN_REG_SET (killed, 0, regno, rsi)
     {
       mode = regno < FIRST_PSEUDO_REGISTER
 	      ? reg_raw_mode[regno]
@@ -1494,7 +1495,7 @@ safe_insert_insn_on_edge (rtx insn, edge e)
 						    gen_reg_rtx (mode),
 						    gen_raw_REG (mode, regno)),
 				   save_regs);
-    });
+    }
 
   if (save_regs)
     {
diff --git a/gcc/config/frv/frv.c b/gcc/config/frv/frv.c
index b8d69615d88..0347c16f1e8 100644
--- a/gcc/config/frv/frv.c
+++ b/gcc/config/frv/frv.c
@@ -6679,6 +6679,7 @@ frv_ifcvt_modify_tests (ce_if_block_t *ce_info, rtx *p_true, rtx *p_false)
   enum reg_class cr_class;
   int cc_first;
   int cc_last;
+  reg_set_iterator rsi;
 
   /* Make sure we are only dealing with hard registers.  Also honor the
      -mno-cond-exec switch, and -mno-nested-cond-exec switches if
@@ -6735,11 +6736,11 @@ frv_ifcvt_modify_tests (ce_if_block_t *ce_info, rtx *p_true, rtx *p_false)
 
       /* Remove anything live at the beginning of the join block from being
          available for allocation.  */
-      EXECUTE_IF_SET_IN_REG_SET (join_bb->global_live_at_start, 0, regno,
-				 {
-				   if (regno < FIRST_PSEUDO_REGISTER)
-				     CLEAR_HARD_REG_BIT (tmp_reg->regs, regno);
-				 });
+      EXECUTE_IF_SET_IN_REG_SET (join_bb->global_live_at_start, 0, regno, rsi)
+	{
+	  if (regno < FIRST_PSEUDO_REGISTER)
+	    CLEAR_HARD_REG_BIT (tmp_reg->regs, regno);
+	}
     }
 
   /* Add in all of the blocks in multiple &&/|| blocks to be scanned.  */
@@ -6779,11 +6780,11 @@ frv_ifcvt_modify_tests (ce_if_block_t *ce_info, rtx *p_true, rtx *p_false)
 
       /* Anything live at the beginning of the block is obviously unavailable
          for allocation.  */
-      EXECUTE_IF_SET_IN_REG_SET (bb[j]->global_live_at_start, 0, regno,
-				 {
-				   if (regno < FIRST_PSEUDO_REGISTER)
-				     CLEAR_HARD_REG_BIT (tmp_reg->regs, regno);
-				 });
+      EXECUTE_IF_SET_IN_REG_SET (bb[j]->global_live_at_start, 0, regno, rsi)
+	{
+	  if (regno < FIRST_PSEUDO_REGISTER)
+	    CLEAR_HARD_REG_BIT (tmp_reg->regs, regno);
+	}
 
       /* Loop through the insns in the block.  */
       for (;;)
diff --git a/gcc/conflict.c b/gcc/conflict.c
index 00be29401ba..ca9dd95eb2b 100644
--- a/gcc/conflict.c
+++ b/gcc/conflict.c
@@ -446,6 +446,8 @@ conflict_graph_compute (regset regs, partition p)
 	  /* Are we interested in this insn? */
 	  if (INSN_P (insn))
 	    {
+	      reg_set_iterator rsi;
+
 	      /* Determine which regs are set in this insn.  Since
   	         we're in SSA form, if a reg is set here it isn't set
   	         anywhere else, so this insn is where the reg is born.  */
@@ -459,20 +461,22 @@ conflict_graph_compute (regset regs, partition p)
 	      /* For every reg born here, add a conflict with every other
   	         reg live coming into this insn.  */
 	      EXECUTE_IF_SET_IN_REG_SET
-		(born, FIRST_PSEUDO_REGISTER, born_reg,
-		 {
-		   EXECUTE_IF_SET_IN_REG_SET
-		     (live, FIRST_PSEUDO_REGISTER, live_reg,
-		      {
-			/* Build the conflict graph in terms of canonical
-			   regnos.  */
-			int b = partition_find (p, born_reg);
-			int l = partition_find (p, live_reg);
-
-			if (b != l)
-			  conflict_graph_add (graph, b, l);
-		      });
-		 });
+		(born, FIRST_PSEUDO_REGISTER, born_reg, rsi)
+		{
+		  reg_set_iterator rsj;
+
+		  EXECUTE_IF_SET_IN_REG_SET
+		    (live, FIRST_PSEUDO_REGISTER, live_reg, rsj)
+		    {
+		      /* Build the conflict graph in terms of canonical
+			 regnos.  */
+		      int b = partition_find (p, born_reg);
+		      int l = partition_find (p, live_reg);
+
+		      if (b != l)
+			conflict_graph_add (graph, b, l);
+		    }
+		}
 
 	      /* Morgan's algorithm checks the operands of the insn
 	         and adds them to the set of live regs.  Instead, we
diff --git a/gcc/flow.c b/gcc/flow.c
index 4914d72a4a0..4ea30a79d3d 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -521,11 +521,12 @@ verify_local_live_at_start (regset new_live_at_start, basic_block bb)
   else
     {
       int i;
+      reg_set_iterator rsi;
 
       /* Find the set of changed registers.  */
       XOR_REG_SET (new_live_at_start, bb->global_live_at_start);
 
-      EXECUTE_IF_SET_IN_REG_SET (new_live_at_start, 0, i,
+      EXECUTE_IF_SET_IN_REG_SET (new_live_at_start, 0, i, rsi)
 	{
 	  /* No registers should die.  */
 	  if (REGNO_REG_SET_P (bb->global_live_at_start, i))
@@ -540,7 +541,7 @@ verify_local_live_at_start (regset new_live_at_start, basic_block bb)
 	    }
 	  /* Verify that the now-live register is wider than word_mode.  */
 	  verify_wide_reg (i, bb);
-	});
+	}
     }
 }
 
@@ -680,13 +681,15 @@ update_life_info (sbitmap blocks, enum update_life_extent extent, int prop_flags
 
   if (prop_flags & PROP_REG_INFO)
     {
+      reg_set_iterator rsi;
+
       /* The only pseudos that are live at the beginning of the function
 	 are those that were not set anywhere in the function.  local-alloc
 	 doesn't know how to handle these correctly, so mark them as not
 	 local to any one basic block.  */
       EXECUTE_IF_SET_IN_REG_SET (ENTRY_BLOCK_PTR->global_live_at_end,
-				 FIRST_PSEUDO_REGISTER, i,
-				 { REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL; });
+				 FIRST_PSEUDO_REGISTER, i, rsi)
+	REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL;
 
       /* We have a problem with any pseudoreg that lives across the setjmp.
 	 ANSI says that if a user variable does not change in value between
@@ -697,14 +700,14 @@ update_life_info (sbitmap blocks, enum update_life_extent extent, int prop_flags
 	 that hard reg where this pseudo is dead, thus clobbering the pseudo.
 	 Conclusion: such a pseudo must not go in a hard reg.  */
       EXECUTE_IF_SET_IN_REG_SET (regs_live_at_setjmp,
-				 FIRST_PSEUDO_REGISTER, i,
-				 {
-				   if (regno_reg_rtx[i] != 0)
-				     {
-				       REG_LIVE_LENGTH (i) = -1;
-				       REG_BASIC_BLOCK (i) = REG_BLOCK_UNKNOWN;
-				     }
-				 });
+				 FIRST_PSEUDO_REGISTER, i, rsi)
+	{
+	  if (regno_reg_rtx[i] != 0)
+	    {
+	      REG_LIVE_LENGTH (i) = -1;
+	      REG_BASIC_BLOCK (i) = REG_BLOCK_UNKNOWN;
+	    }
+	}
     }
   if (reg_deaths)
     {
@@ -1369,8 +1372,9 @@ initialize_uninitialized_subregs (void)
     {
       basic_block bb = e->dest;
       regset map = bb->global_live_at_start;
-      EXECUTE_IF_SET_IN_REG_SET (map,
-				 FIRST_PSEUDO_REGISTER, reg,
+      reg_set_iterator rsi;
+
+      EXECUTE_IF_SET_IN_REG_SET (map, FIRST_PSEUDO_REGISTER, reg, rsi)
 	{
 	  int uid = REGNO_FIRST_UID (reg);
 	  rtx i;
@@ -1398,7 +1402,7 @@ initialize_uninitialized_subregs (void)
 		  did_something = 1;
 		}
 	    }
-	});
+	}
     }
 
   if (did_something)
@@ -1671,8 +1675,11 @@ propagate_one_insn (struct propagate_block_info *pbi, rtx insn)
 	 record this for them.  */
 
       if (CALL_P (insn) && (flags & PROP_REG_INFO))
-	EXECUTE_IF_SET_IN_REG_SET (pbi->reg_live, 0, i,
-				   { REG_N_CALLS_CROSSED (i)++; });
+	{
+	  reg_set_iterator rsi;
+	  EXECUTE_IF_SET_IN_REG_SET (pbi->reg_live, 0, i, rsi)
+	    REG_N_CALLS_CROSSED (i)++;
+	}
 
       /* Record sets.  Do this even for dead instructions, since they
 	 would have killed the values if they hadn't been deleted.  */
@@ -1878,6 +1885,8 @@ init_propagate_block_info (basic_block bb, regset live, regset local_set,
 		= gen_rtx_fmt_ee (inv_cond,
 				  GET_MODE (cond_true), XEXP (cond_true, 0),
 				  XEXP (cond_true, 1));
+	      reg_set_iterator rsi;
+
 	      if (GET_CODE (XEXP (set_src, 1)) == PC)
 		{
 		  rtx t = cond_false;
@@ -1888,25 +1897,24 @@ init_propagate_block_info (basic_block bb, regset live, regset local_set,
 	      SET_REGNO_REG_SET (pbi->reg_cond_reg, REGNO (reg));
 
 	      /* For each such register, mark it conditionally dead.  */
-	      EXECUTE_IF_SET_IN_REG_SET
-		(diff, 0, i,
-		 {
-		   struct reg_cond_life_info *rcli;
-		   rtx cond;
-
-		   rcli = xmalloc (sizeof (*rcli));
-
-		   if (REGNO_REG_SET_P (bb_true->global_live_at_start, i))
-		     cond = cond_false;
-		   else
-		     cond = cond_true;
-		   rcli->condition = cond;
-		   rcli->stores = const0_rtx;
-		   rcli->orig_condition = cond;
-
-		   splay_tree_insert (pbi->reg_cond_dead, i,
-				      (splay_tree_value) rcli);
-		 });
+	      EXECUTE_IF_SET_IN_REG_SET (diff, 0, i, rsi)
+		{
+		  struct reg_cond_life_info *rcli;
+		  rtx cond;
+
+		  rcli = xmalloc (sizeof (*rcli));
+
+		  if (REGNO_REG_SET_P (bb_true->global_live_at_start, i))
+		    cond = cond_false;
+		  else
+		    cond = cond_true;
+		  rcli->condition = cond;
+		  rcli->stores = const0_rtx;
+		  rcli->orig_condition = cond;
+
+		  splay_tree_insert (pbi->reg_cond_dead, i,
+				     (splay_tree_value) rcli);
+		}
 	    }
 	}
 
@@ -1966,11 +1974,13 @@ free_propagate_block_info (struct propagate_block_info *pbi)
     {
       int num = pbi->insn_num;
       int i;
+      reg_set_iterator rsi;
 
-      EXECUTE_IF_SET_IN_REG_SET (pbi->reg_live, 0, i,
-	 { REG_LIVE_LENGTH (i) += num - reg_deaths[i];
-	   reg_deaths[i] = 0;
-         });
+      EXECUTE_IF_SET_IN_REG_SET (pbi->reg_live, 0, i, rsi)
+	{
+	  REG_LIVE_LENGTH (i) += num - reg_deaths[i];
+	  reg_deaths[i] = 0;
+	}
     }
   if (pbi->reg_next_use)
     free (pbi->reg_next_use);
@@ -2009,11 +2019,12 @@ propagate_block (basic_block bb, regset live, regset local_set,
   if (flags & PROP_REG_INFO)
     {
       int i;
+      reg_set_iterator rsi;
 
       /* Process the regs live at the end of the block.
 	 Mark them as not local to any one basic block.  */
-      EXECUTE_IF_SET_IN_REG_SET (live, 0, i,
-				 { REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL; });
+      EXECUTE_IF_SET_IN_REG_SET (live, 0, i, rsi)
+	REG_BASIC_BLOCK (i) = REG_BLOCK_GLOBAL;
     }
 
   /* Scan the block an insn at a time from end to beginning.  */
@@ -4135,19 +4146,21 @@ void
 dump_regset (regset r, FILE *outf)
 {
   int i;
+  reg_set_iterator rsi;
+
   if (r == NULL)
     {
       fputs (" (nil)", outf);
       return;
     }
 
-  EXECUTE_IF_SET_IN_REG_SET (r, 0, i,
+  EXECUTE_IF_SET_IN_REG_SET (r, 0, i, rsi)
     {
       fprintf (outf, " %d", i);
       if (i < FIRST_PSEUDO_REGISTER)
 	fprintf (outf, " [%s]",
 		 reg_names[i]);
-    });
+    }
 }
 
 /* Print a human-readable representation of R on the standard error
diff --git a/gcc/global.c b/gcc/global.c
index 424bdad73f5..6892fdc3c6c 100644
--- a/gcc/global.c
+++ b/gcc/global.c
@@ -700,20 +700,20 @@ global_conflicts (void)
       {
 	regset old = b->global_live_at_start;
 	int ax = 0;
+	reg_set_iterator rsi;
 
 	REG_SET_TO_HARD_REG_SET (hard_regs_live, old);
-	EXECUTE_IF_SET_IN_REG_SET (old, FIRST_PSEUDO_REGISTER, i,
-				   {
-				     int a = reg_allocno[i];
-				     if (a >= 0)
-				       {
-					 SET_ALLOCNO_LIVE (a);
-					 block_start_allocnos[ax++] = a;
-				       }
-				     else if ((a = reg_renumber[i]) >= 0)
-				       mark_reg_live_nc
-					 (a, PSEUDO_REGNO_MODE (i));
-				   });
+	EXECUTE_IF_SET_IN_REG_SET (old, FIRST_PSEUDO_REGISTER, i, rsi)
+	  {
+	    int a = reg_allocno[i];
+	    if (a >= 0)
+	      {
+		SET_ALLOCNO_LIVE (a);
+		block_start_allocnos[ax++] = a;
+	      }
+	    else if ((a = reg_renumber[i]) >= 0)
+	      mark_reg_live_nc (a, PSEUDO_REGNO_MODE (i));
+	  }
 
 	/* Record that each allocno now live conflicts with each hard reg
 	   now live.
diff --git a/gcc/graph.c b/gcc/graph.c
index cd232db985a..e60e2f6799b 100644
--- a/gcc/graph.c
+++ b/gcc/graph.c
@@ -66,6 +66,10 @@ graph: { title: \"%s\"\nfolding: 1\nhidden: 2\nnode: { title: \"%s.0\" }\n",
 static void
 start_bb (FILE *fp, int bb)
 {
+#if 0
+  reg_set_iterator rsi;
+#endif
+
   switch (graph_dump_format)
     {
     case vcg:
@@ -83,13 +87,12 @@ label: \"basic block %d",
 
   /* Print the live-at-start register list.  */
   fputc ('\n', fp);
-  EXECUTE_IF_SET_IN_REG_SET (basic_block_live_at_start[bb], 0, i,
-			     {
-			       fprintf (fp, " %d", i);
-			       if (i < FIRST_PSEUDO_REGISTER)
-				 fprintf (fp, " [%s]",
-					  reg_names[i]);
-			     });
+  EXECUTE_IF_SET_IN_REG_SET (basic_block_live_at_start[bb], 0, i, rsi)
+    {
+      fprintf (fp, " %d", i);
+      if (i < FIRST_PSEUDO_REGISTER)
+	fprintf (fp, " [%s]", reg_names[i]);
+    }
 #endif
 
   switch (graph_dump_format)
diff --git a/gcc/local-alloc.c b/gcc/local-alloc.c
index 64db8c4258f..ebda9dd8840 100644
--- a/gcc/local-alloc.c
+++ b/gcc/local-alloc.c
@@ -1128,14 +1128,17 @@ update_equiv_regs (void)
 	    }
 	}
       else
-	EXECUTE_IF_SET_IN_REG_SET (&cleared_regs, 0, j,
-	  {
-	    FOR_EACH_BB (bb)
-	      {
-	        CLEAR_REGNO_REG_SET (bb->global_live_at_start, j);
-	        CLEAR_REGNO_REG_SET (bb->global_live_at_end, j);
-	      }
-	  });
+	{
+	  reg_set_iterator rsi;
+	  EXECUTE_IF_SET_IN_REG_SET (&cleared_regs, 0, j, rsi)
+	    {
+	      FOR_EACH_BB (bb)
+		{
+		  CLEAR_REGNO_REG_SET (bb->global_live_at_start, j);
+		  CLEAR_REGNO_REG_SET (bb->global_live_at_end, j);
+		}
+	    }
+	}
     }
 
   /* Clean up.  */
diff --git a/gcc/loop.c b/gcc/loop.c
index 0f62789cab2..a573616d0e1 100644
--- a/gcc/loop.c
+++ b/gcc/loop.c
@@ -11242,6 +11242,7 @@ load_mems (const struct loop *loop)
 	  rtx best = mem;
 	  int j;
 	  struct elt_loc_list *const_equiv = 0;
+	  reg_set_iterator rsi;
 
 	  if (e)
 	    {
@@ -11320,17 +11321,17 @@ load_mems (const struct loop *loop)
 	     data flow, and enables {basic,general}_induction_var to find
 	     more bivs/givs.  */
 	  EXECUTE_IF_SET_IN_REG_SET
-	    (&load_copies, FIRST_PSEUDO_REGISTER, j,
-	     {
-	       try_copy_prop (loop, reg, j);
-	     });
+	    (&load_copies, FIRST_PSEUDO_REGISTER, j, rsi)
+	    {
+	      try_copy_prop (loop, reg, j);
+	    }
 	  CLEAR_REG_SET (&load_copies);
 
 	  EXECUTE_IF_SET_IN_REG_SET
-	    (&store_copies, FIRST_PSEUDO_REGISTER, j,
-	     {
-	       try_swap_copy_prop (loop, reg, j);
-	     });
+	    (&store_copies, FIRST_PSEUDO_REGISTER, j, rsi)
+	    {
+	      try_swap_copy_prop (loop, reg, j);
+	    }
 	  CLEAR_REG_SET (&store_copies);
 	}
     }
diff --git a/gcc/reload1.c b/gcc/reload1.c
index 7fc23bc9a71..e35f1210c0c 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -523,28 +523,28 @@ void
 compute_use_by_pseudos (HARD_REG_SET *to, regset from)
 {
   unsigned int regno;
+  reg_set_iterator rsi;
 
-  EXECUTE_IF_SET_IN_REG_SET
-    (from, FIRST_PSEUDO_REGISTER, regno,
-     {
-       int r = reg_renumber[regno];
-       int nregs;
-
-       if (r < 0)
-	 {
-	   /* reload_combine uses the information from
-	      BASIC_BLOCK->global_live_at_start, which might still
-	      contain registers that have not actually been allocated
-	      since they have an equivalence.  */
-	   gcc_assert (reload_completed);
-	 }
-       else
-	 {
-	   nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
-	   while (nregs-- > 0)
-	     SET_HARD_REG_BIT (*to, r + nregs);
-	 }
-     });
+  EXECUTE_IF_SET_IN_REG_SET (from, FIRST_PSEUDO_REGISTER, regno, rsi)
+    {
+      int r = reg_renumber[regno];
+      int nregs;
+
+      if (r < 0)
+	{
+	  /* reload_combine uses the information from
+	     BASIC_BLOCK->global_live_at_start, which might still
+	     contain registers that have not actually been allocated
+	     since they have an equivalence.  */
+	  gcc_assert (reload_completed);
+	}
+      else
+	{
+	  nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
+	  while (nregs-- > 0)
+	    SET_HARD_REG_BIT (*to, r + nregs);
+	}
+    }
 }
 
 /* Replace all pseudos found in LOC with their corresponding
@@ -1593,6 +1593,7 @@ order_regs_for_reload (struct insn_chain *chain)
   int i;
   HARD_REG_SET used_by_pseudos;
   HARD_REG_SET used_by_pseudos2;
+  reg_set_iterator rsi;
 
   COPY_HARD_REG_SET (bad_spill_regs, fixed_reg_set);
 
@@ -1613,15 +1614,15 @@ order_regs_for_reload (struct insn_chain *chain)
   CLEAR_REG_SET (&pseudos_counted);
 
   EXECUTE_IF_SET_IN_REG_SET
-    (&chain->live_throughout, FIRST_PSEUDO_REGISTER, i,
-     {
-       count_pseudo (i);
-     });
+    (&chain->live_throughout, FIRST_PSEUDO_REGISTER, i, rsi)
+    {
+      count_pseudo (i);
+    }
   EXECUTE_IF_SET_IN_REG_SET
-    (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, i,
-     {
-       count_pseudo (i);
-     });
+    (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, i, rsi)
+    {
+      count_pseudo (i);
+    }
   CLEAR_REG_SET (&pseudos_counted);
 }
 
@@ -1667,6 +1668,7 @@ find_reg (struct insn_chain *chain, int order)
   int k;
   HARD_REG_SET not_usable;
   HARD_REG_SET used_by_other_reload;
+  reg_set_iterator rsi;
 
   COPY_HARD_REG_SET (not_usable, bad_spill_regs);
   IOR_HARD_REG_SET (not_usable, bad_spill_regs_global);
@@ -1735,16 +1737,16 @@ find_reg (struct insn_chain *chain, int order)
   rl->regno = best_reg;
 
   EXECUTE_IF_SET_IN_REG_SET
-    (&chain->live_throughout, FIRST_PSEUDO_REGISTER, j,
-     {
-       count_spilled_pseudo (best_reg, rl->nregs, j);
-     });
+    (&chain->live_throughout, FIRST_PSEUDO_REGISTER, j, rsi)
+    {
+      count_spilled_pseudo (best_reg, rl->nregs, j);
+    }
 
   EXECUTE_IF_SET_IN_REG_SET
-    (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, j,
-     {
-       count_spilled_pseudo (best_reg, rl->nregs, j);
-     });
+    (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, j, rsi)
+    {
+      count_spilled_pseudo (best_reg, rl->nregs, j);
+    }
 
   for (i = 0; i < rl->nregs; i++)
     {
@@ -3552,6 +3554,7 @@ finish_spills (int global)
   struct insn_chain *chain;
   int something_changed = 0;
   int i;
+  reg_set_iterator rsi;
 
   /* Build the spill_regs array for the function.  */
   /* If there are some registers still to eliminate and one of the spill regs
@@ -3578,20 +3581,19 @@ finish_spills (int global)
     else
       spill_reg_order[i] = -1;
 
-  EXECUTE_IF_SET_IN_REG_SET
-    (&spilled_pseudos, FIRST_PSEUDO_REGISTER, i,
-     {
-       /* Record the current hard register the pseudo is allocated to in
-	  pseudo_previous_regs so we avoid reallocating it to the same
-	  hard reg in a later pass.  */
-       gcc_assert (reg_renumber[i] >= 0);
-
-       SET_HARD_REG_BIT (pseudo_previous_regs[i], reg_renumber[i]);
-       /* Mark it as no longer having a hard register home.  */
-       reg_renumber[i] = -1;
-       /* We will need to scan everything again.  */
-       something_changed = 1;
-     });
+  EXECUTE_IF_SET_IN_REG_SET (&spilled_pseudos, FIRST_PSEUDO_REGISTER, i, rsi)
+    {
+      /* Record the current hard register the pseudo is allocated to in
+	 pseudo_previous_regs so we avoid reallocating it to the same
+	 hard reg in a later pass.  */
+      gcc_assert (reg_renumber[i] >= 0);
+
+      SET_HARD_REG_BIT (pseudo_previous_regs[i], reg_renumber[i]);
+      /* Mark it as no longer having a hard register home.  */
+      reg_renumber[i] = -1;
+      /* We will need to scan everything again.  */
+      something_changed = 1;
+    }
 
   /* Retry global register allocation if possible.  */
   if (global)
@@ -3603,17 +3605,17 @@ finish_spills (int global)
       for (chain = insns_need_reload; chain; chain = chain->next_need_reload)
 	{
 	  EXECUTE_IF_SET_IN_REG_SET
-	    (&chain->live_throughout, FIRST_PSEUDO_REGISTER, i,
-	     {
-	       ior_hard_reg_set (pseudo_forbidden_regs + i,
-				 &chain->used_spill_regs);
-	     });
+	    (&chain->live_throughout, FIRST_PSEUDO_REGISTER, i, rsi)
+	    {
+	      ior_hard_reg_set (pseudo_forbidden_regs + i,
+				&chain->used_spill_regs);
+	    }
 	  EXECUTE_IF_SET_IN_REG_SET
-	    (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, i,
-	     {
-	       ior_hard_reg_set (pseudo_forbidden_regs + i,
-				 &chain->used_spill_regs);
-	     });
+	    (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, i, rsi)
+	    {
+	      ior_hard_reg_set (pseudo_forbidden_regs + i,
+				&chain->used_spill_regs);
+	    }
 	}
 
       /* Retry allocating the spilled pseudos.  For each reg, merge the
diff --git a/gcc/resource.c b/gcc/resource.c
index 7d6bbb759c5..08e940cd01c 100644
--- a/gcc/resource.c
+++ b/gcc/resource.c
@@ -971,6 +971,7 @@ mark_target_live_regs (rtx insns, rtx target, struct resources *res)
       unsigned int j;
       unsigned int regno;
       rtx start_insn, stop_insn;
+      reg_set_iterator rsi;
 
       /* Compute hard regs live at start of block -- this is the real hard regs
 	 marked live, plus live pseudo regs that have been renumbered to
@@ -978,19 +979,17 @@ mark_target_live_regs (rtx insns, rtx target, struct resources *res)
 
       REG_SET_TO_HARD_REG_SET (current_live_regs, regs_live);
 
-      EXECUTE_IF_SET_IN_REG_SET
-	(regs_live, FIRST_PSEUDO_REGISTER, i,
-	 {
-	   if (reg_renumber[i] >= 0)
-	     {
-	       regno = reg_renumber[i];
-	       for (j = regno;
-		    j < regno + hard_regno_nregs[regno]
-						[PSEUDO_REGNO_MODE (i)];
-		    j++)
-		 SET_HARD_REG_BIT (current_live_regs, j);
-	     }
-	 });
+      EXECUTE_IF_SET_IN_REG_SET (regs_live, FIRST_PSEUDO_REGISTER, i, rsi)
+	{
+	  if (reg_renumber[i] >= 0)
+	    {
+	      regno = reg_renumber[i];
+	      for (j = regno;
+		   j < regno + hard_regno_nregs[regno][PSEUDO_REGNO_MODE (i)];
+		   j++)
+		SET_HARD_REG_BIT (current_live_regs, j);
+	    }
+	}
 
       /* Get starting and ending insn, handling the case where each might
 	 be a SEQUENCE.  */
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
index 6e68bde56bd..1df1b47facb 100644
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -822,6 +822,7 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
   RTX_CODE code = GET_CODE (x);
   rtx link;
   int i;
+  reg_set_iterator rsi;
 
   if (code == COND_EXEC)
     {
@@ -895,14 +896,14 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
 	  (*current_sched_info->compute_jump_reg_dependencies)
 	    (insn, &deps->reg_conditional_sets, &tmp_uses, &tmp_sets);
 	  /* Make latency of jump equal to 0 by using anti-dependence.  */
-	  EXECUTE_IF_SET_IN_REG_SET (&tmp_uses, 0, i,
+	  EXECUTE_IF_SET_IN_REG_SET (&tmp_uses, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      add_dependence_list (insn, reg_last->sets, REG_DEP_ANTI);
 	      add_dependence_list (insn, reg_last->clobbers, REG_DEP_ANTI);
 	      reg_last->uses_length++;
 	      reg_last->uses = alloc_INSN_LIST (insn, reg_last->uses);
-	    });
+	    }
 	  IOR_REG_SET (reg_pending_sets, &tmp_sets);
 
 	  CLEAR_REG_SET (&tmp_uses);
@@ -975,7 +976,7 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
          real, so we use anti-dependence here.  */
       if (GET_CODE (PATTERN (insn)) == COND_EXEC)
 	{
-	  EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i,
+	  EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      add_dependence_list (insn, reg_last->uses, REG_DEP_ANTI);
@@ -985,11 +986,11 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
 	      add_dependence_list
 		(insn, reg_last->clobbers,
 		 reg_pending_barrier == TRUE_BARRIER ? 0 : REG_DEP_ANTI);
-	    });
+	    }
 	}
       else
 	{
-	  EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i,
+	  EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      add_dependence_list_and_free (insn, &reg_last->uses,
@@ -1002,7 +1003,7 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
 		 reg_pending_barrier == TRUE_BARRIER ? 0 : REG_DEP_ANTI);
 	      reg_last->uses_length = 0;
 	      reg_last->clobbers_length = 0;
-	    });
+	    }
 	}
 
       for (i = 0; i < deps->max_reg; i++)
@@ -1022,23 +1023,23 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
 	 of the lists.  */
       if (GET_CODE (PATTERN (insn)) == COND_EXEC)
 	{
-	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i,
+	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      add_dependence_list (insn, reg_last->sets, 0);
 	      add_dependence_list (insn, reg_last->clobbers, 0);
 	      reg_last->uses = alloc_INSN_LIST (insn, reg_last->uses);
 	      reg_last->uses_length++;
-	    });
-	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_clobbers, 0, i,
+	    }
+	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_clobbers, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      add_dependence_list (insn, reg_last->sets, REG_DEP_OUTPUT);
 	      add_dependence_list (insn, reg_last->uses, REG_DEP_ANTI);
 	      reg_last->clobbers = alloc_INSN_LIST (insn, reg_last->clobbers);
 	      reg_last->clobbers_length++;
-	    });
-	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_sets, 0, i,
+	    }
+	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_sets, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      add_dependence_list (insn, reg_last->sets, REG_DEP_OUTPUT);
@@ -1046,19 +1047,19 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
 	      add_dependence_list (insn, reg_last->uses, REG_DEP_ANTI);
 	      reg_last->sets = alloc_INSN_LIST (insn, reg_last->sets);
 	      SET_REGNO_REG_SET (&deps->reg_conditional_sets, i);
-	    });
+	    }
 	}
       else
 	{
-	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i,
+	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      add_dependence_list (insn, reg_last->sets, 0);
 	      add_dependence_list (insn, reg_last->clobbers, 0);
 	      reg_last->uses_length++;
 	      reg_last->uses = alloc_INSN_LIST (insn, reg_last->uses);
-	    });
-	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_clobbers, 0, i,
+	    }
+	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_clobbers, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      if (reg_last->uses_length > MAX_PENDING_LIST_LENGTH
@@ -1081,8 +1082,8 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
 		}
 	      reg_last->clobbers_length++;
 	      reg_last->clobbers = alloc_INSN_LIST (insn, reg_last->clobbers);
-	    });
-	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_sets, 0, i,
+	    }
+	  EXECUTE_IF_SET_IN_REG_SET (reg_pending_sets, 0, i, rsi)
 	    {
 	      struct deps_reg *reg_last = &deps->reg_last[i];
 	      add_dependence_list_and_free (insn, &reg_last->sets,
@@ -1095,7 +1096,7 @@ sched_analyze_insn (struct deps *deps, rtx x, rtx insn, rtx loop_notes)
 	      reg_last->uses_length = 0;
 	      reg_last->clobbers_length = 0;
 	      CLEAR_REGNO_REG_SET (&deps->reg_conditional_sets, i);
-	    });
+	    }
 	}
 
       IOR_REG_SET (&deps->reg_last_in_use, reg_pending_uses);
@@ -1461,6 +1462,7 @@ void
 free_deps (struct deps *deps)
 {
   int i;
+  reg_set_iterator rsi;
 
   free_INSN_LIST_list (&deps->pending_read_insns);
   free_EXPR_LIST_list (&deps->pending_read_mems);
@@ -1471,7 +1473,7 @@ free_deps (struct deps *deps)
   /* Without the EXECUTE_IF_SET, this loop is executed max_reg * nr_regions
      times.  For a testcase with 42000 regs and 8000 small basic blocks,
      this loop accounted for nearly 60% (84 sec) of the total -O2 runtime.  */
-  EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i,
+  EXECUTE_IF_SET_IN_REG_SET (&deps->reg_last_in_use, 0, i, rsi)
     {
       struct deps_reg *reg_last = &deps->reg_last[i];
       if (reg_last->uses)
@@ -1480,7 +1482,7 @@ free_deps (struct deps *deps)
 	free_INSN_LIST_list (&reg_last->sets);
       if (reg_last->clobbers)
 	free_INSN_LIST_list (&reg_last->clobbers);
-    });
+    }
   CLEAR_REG_SET (&deps->reg_last_in_use);
   CLEAR_REG_SET (&deps->reg_conditional_sets);
 
diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c
index 50b48c24a0f..be1351980df 100644
--- a/gcc/sched-rgn.c
+++ b/gcc/sched-rgn.c
@@ -1987,6 +1987,7 @@ propagate_deps (int bb, struct deps *pred_deps)
     {
       struct deps *succ_deps;
       int reg;
+      reg_set_iterator rsi;
 
       /* Only bbs "below" bb, in the same region, are interesting.  */
       if (e->dest == EXIT_BLOCK_PTR
@@ -1997,7 +1998,7 @@ propagate_deps (int bb, struct deps *pred_deps)
       succ_deps = bb_deps + BLOCK_TO_BB (e->dest->index);
 
       /* The reg_last lists are inherited by successor.  */
-      EXECUTE_IF_SET_IN_REG_SET (&pred_deps->reg_last_in_use, 0, reg,
+      EXECUTE_IF_SET_IN_REG_SET (&pred_deps->reg_last_in_use, 0, reg, rsi)
 	{
 	  struct deps_reg *pred_rl = &pred_deps->reg_last[reg];
 	  struct deps_reg *succ_rl = &succ_deps->reg_last[reg];
@@ -2008,7 +2009,7 @@ propagate_deps (int bb, struct deps *pred_deps)
 						succ_rl->clobbers);
 	  succ_rl->uses_length += pred_rl->uses_length;
 	  succ_rl->clobbers_length += pred_rl->clobbers_length;
-	});
+	}
       IOR_REG_SET (&succ_deps->reg_last_in_use, &pred_deps->reg_last_in_use);
 
       /* Mem read/write lists are inherited by successor.  */