* graphite.c (print_global_statistics): Use EDGE_COUNT instead
	of VEC_length.
	(print_graphite_scop_statistics): Likewise.
	* graphite-scop-detection.c (get_bb_type): Use single_succ_p.
	(print_graphite_scop_statistics): Use EDGE_COUNT, not VEC_length.
	(canonicalize_loop_closed_ssa): Use single_pred_p.

	* alias.c (reg_seen): Make this an sbitmap.
	(record_set, init_alias_analysis): Update.

Index: graphite.c
===================================================================
--- graphite.c	(revision 190967)
+++ graphite.c	(working copy)
@@ -97,7 +97,7 @@ print_global_statistics (FILE* file)
 	  n_p_loops += bb->count;
 	}
 
-      if (VEC_length (edge, bb->succs) > 1)
+      if (EDGE_COUNT (bb->succs) > 1)
 	{
 	  n_conditions++;
 	  n_p_conditions += bb->count;
@@ -149,7 +149,7 @@ print_graphite_scop_statistics (FILE* file, scop_p
       n_bbs++;
       n_p_bbs += bb->count;
 
-      if (VEC_length (edge, bb->succs) > 1)
+      if (EDGE_COUNT (bb->succs) > 1)
 	{
 	  n_conditions++;
 	  n_p_conditions += bb->count;
Index: graphite-scop-detection.c
===================================================================
--- graphite-scop-detection.c	(revision 190967)
+++ graphite-scop-detection.c	(working copy)
@@ -67,7 +67,7 @@ static gbb_type
 get_bb_type (basic_block bb, struct loop *last_loop)
 {
   VEC (basic_block, heap) *dom;
-  int nb_dom, nb_suc;
+  int nb_dom;
   struct loop *loop = bb->loop_father;
 
   /* Check, if we entry into a new loop. */
@@ -88,9 +88,7 @@ get_bb_type (basic_block bb, struct loop *last_loo
   if (nb_dom == 0)
     return GBB_LAST;
 
-  nb_suc = VEC_length (edge, bb->succs);
-
-  if (nb_dom == 1 && nb_suc == 1)
+  if (nb_dom == 1 && single_succ_p (bb))
     return GBB_SIMPLE;
 
   return GBB_COND_HEADER;
@@ -1114,7 +1112,7 @@ print_graphite_scop_statistics (FILE* file, scop_p
       n_bbs++;
       n_p_bbs += bb->count;
 
-      if (VEC_length (edge, bb->succs) > 1)
+      if (EDGE_COUNT (bb->succs) > 1)
 	{
 	  n_conditions++;
 	  n_p_conditions += bb->count;
@@ -1299,7 +1297,7 @@ canonicalize_loop_closed_ssa (loop_p loop)
 
   bb = e->dest;
 
-  if (VEC_length (edge, bb->preds) == 1)
+  if (single_pred_p (bb))
     {
       e = split_block_after_labels (bb);
       make_close_phi_nodes_unique (e->src);
Index: alias.c
===================================================================
--- alias.c	(revision 190967)
+++ alias.c	(working copy)
@@ -1220,7 +1220,7 @@ find_base_value (rtx src)
 
 /* While scanning insns to find base values, reg_seen[N] is nonzero if
    register N has been set in this function.  */
-static char *reg_seen;
+static sbitmap reg_seen;
 
 static void
 record_set (rtx dest, const_rtx set, void *data ATTRIBUTE_UNUSED)
@@ -1246,7 +1246,7 @@ record_set (rtx dest, const_rtx set, void *data AT
     {
       while (--n >= 0)
 	{
-	  reg_seen[regno + n] = 1;
+	  SET_BIT (reg_seen, regno + n);
 	  new_reg_base_value[regno + n] = 0;
 	}
       return;
@@ -1267,12 +1267,12 @@ record_set (rtx dest, const_rtx set, void *data AT
   else
     {
       /* There's a REG_NOALIAS note against DEST.  */
-      if (reg_seen[regno])
+      if (TEST_BIT (reg_seen, regno))
 	{
 	  new_reg_base_value[regno] = 0;
 	  return;
 	}
-      reg_seen[regno] = 1;
+      SET_BIT (reg_seen, regno);
       new_reg_base_value[regno] = unique_base_value (unique_id++);
       return;
     }
@@ -1328,10 +1328,10 @@ record_set (rtx dest, const_rtx set, void *data AT
       }
   /* If this is the first set of a register, record the value.  */
   else if ((regno >= FIRST_PSEUDO_REGISTER || ! fixed_regs[regno])
-	   && ! reg_seen[regno] && new_reg_base_value[regno] == 0)
+	   && ! TEST_BIT (reg_seen, regno) && new_reg_base_value[regno] == 0)
     new_reg_base_value[regno] = find_base_value (src);
 
-  reg_seen[regno] = 1;
+  SET_BIT (reg_seen, regno);
 }
 
 /* Return REG_BASE_VALUE for REGNO.  Selective scheduler uses this to avoid
@@ -2789,7 +2789,7 @@ init_alias_analysis (void)
   VEC_safe_grow_cleared (rtx, gc, reg_base_value, maxreg);
 
   new_reg_base_value = XNEWVEC (rtx, maxreg);
-  reg_seen = XNEWVEC (char, maxreg);
+  reg_seen = sbitmap_alloc (maxreg);
 
   /* The basic idea is that each pass through this loop will use the
      "constant" information from the previous pass to propagate alias
@@ -2834,7 +2834,7 @@ init_alias_analysis (void)
       memset (new_reg_base_value, 0, maxreg * sizeof (rtx));
 
       /* Wipe the reg_seen array clean.  */
-      memset (reg_seen, 0, maxreg);
+      sbitmap_zero (reg_seen);
 
       /* Mark all hard registers which may contain an address.
 	 The stack, frame and argument pointers may contain an address.
@@ -2957,7 +2957,7 @@ init_alias_analysis (void)
   /* Clean up.  */
   free (new_reg_base_value);
   new_reg_base_value = 0;
-  free (reg_seen);
+  sbitmap_free (reg_seen);
   reg_seen = 0;
   timevar_pop (TV_ALIAS_ANALYSIS);
 }