lower-subreg.c (find_decomposable_subregs): Turn from being a for_each_rtx…

lower-subreg.c (find_decomposable_subregs): Turn from being a for_each_rtx callback to being a function that examines each...

gcc/
	* lower-subreg.c (find_decomposable_subregs): Turn from being
	a for_each_rtx callback to being a function that examines each
	subrtx itself.  Remove handling of null rtxes.
	(decompose_multiword_subregs): Update accordingly.

From-SVN: r214649

gcc/ChangeLog

 2014-08-28  Richard Sandiford  <rdsandiford@googlemail.com>
 
+	* lower-subreg.c (find_decomposable_subregs): Turn from being
+	a for_each_rtx callback to being a function that examines each
+	subrtx itself.  Remove handling of null rtxes.
+	(decompose_multiword_subregs): Update accordingly.
+
+2014-08-28  Richard Sandiford  <rdsandiford@googlemail.com>
+
 	* lower-subreg.c (adjust_decomposed_uses): Delete.
 	(resolve_debug): Use FOR_EACH_SUBRTX_PTR rather than for_each_rtx.
 	Remove handling of null rtxes.

gcc/lower-subreg.c

@@ -443,7 +443,7 @@ propagate_pseudo_copies (void)
 }
 
 /* A pointer to one of these values is passed to
-   find_decomposable_subregs via for_each_rtx.  */
+   find_decomposable_subregs.  */
 
 enum classify_move_insn
 {
@@ -455,33 +455,33 @@ enum classify_move_insn
   SIMPLE_MOVE
 };
 
-/* This is called via for_each_rtx.  If we find a SUBREG which we
-   could use to decompose a pseudo-register, set a bit in
-   DECOMPOSABLE_CONTEXT.  If we find an unadorned register which is
-   not a simple pseudo-register copy, DATA will point at the type of
-   move, and we set a bit in DECOMPOSABLE_CONTEXT or
-   NON_DECOMPOSABLE_CONTEXT as appropriate.  */
+/* If we find a SUBREG in *LOC which we could use to decompose a
+   pseudo-register, set a bit in DECOMPOSABLE_CONTEXT.  If we find an
+   unadorned register which is not a simple pseudo-register copy,
+   DATA will point at the type of move, and we set a bit in
+   DECOMPOSABLE_CONTEXT or NON_DECOMPOSABLE_CONTEXT as appropriate.  */
 
-static int
-find_decomposable_subregs (rtx *px, void *data)
+static void
+find_decomposable_subregs (rtx *loc, enum classify_move_insn *pcmi)
 {
-  enum classify_move_insn *pcmi = (enum classify_move_insn *) data;
-  rtx x = *px;
-
-  if (x == NULL_RTX)
-    return 0;
-
+  subrtx_var_iterator::array_type array;
+  FOR_EACH_SUBRTX_VAR (iter, array, *loc, NONCONST)
+    {
+      rtx x = *iter;
       if (GET_CODE (x) == SUBREG)
 	{
 	  rtx inner = SUBREG_REG (x);
 	  unsigned int regno, outer_size, inner_size, outer_words, inner_words;
 
 	  if (!REG_P (inner))
-	return 0;
+	    continue;
 
 	  regno = REGNO (inner);
 	  if (HARD_REGISTER_NUM_P (regno))
-	return -1;
+	    {
+	      iter.skip_subrtxes ();
+	      continue;
+	    }
 
 	  outer_size = GET_MODE_SIZE (GET_MODE (x));
 	  inner_size = GET_MODE_SIZE (GET_MODE (inner));
@@ -501,7 +501,8 @@ find_decomposable_subregs (rtx *px, void *data)
 	  if (outer_words == 1 && inner_words > 1)
 	    {
 	      bitmap_set_bit (decomposable_context, regno);
-	  return -1;
+	      iter.skip_subrtxes ();
+	      continue;
 	    }
 
 	  /* If this is a cast from one mode to another, where the modes
@@ -514,7 +515,8 @@ find_decomposable_subregs (rtx *px, void *data)
 	    {
 	      bitmap_set_bit (non_decomposable_context, regno);
 	      bitmap_set_bit (subreg_context, regno);
-	  return -1;
+	      iter.skip_subrtxes ();
+	      continue;
 	    }
 	}
       else if (REG_P (x))
@@ -564,11 +566,10 @@ find_decomposable_subregs (rtx *px, void *data)
 	  /* Any registers used in a MEM do not participate in a
 	     SIMPLE_MOVE or DECOMPOSABLE_SIMPLE_MOVE.  Do our own recursion
 	     here, and return -1 to block the parent's recursion.  */
-      for_each_rtx (&XEXP (x, 0), find_decomposable_subregs, &cmi_mem);
-      return -1;
+	  find_decomposable_subregs (&XEXP (x, 0), &cmi_mem);
+	  iter.skip_subrtxes ();
+	}
     }
-
-  return 0;
 }
 
 /* Decompose REGNO into word-sized components.  We smash the REG node
@@ -1496,9 +1497,7 @@ decompose_multiword_subregs (bool decompose_copies)
 	  n = recog_data.n_operands;
 	  for (i = 0; i < n; ++i)
 	    {
-	      for_each_rtx (&recog_data.operand[i],
-			    find_decomposable_subregs,
-			    &cmi);
+	      find_decomposable_subregs (&recog_data.operand[i], &cmi);
 
 	      /* We handle ASM_OPERANDS as a special case to support
 		 things like x86 rdtsc which returns a DImode value.