--- a/gcc/tree-vrp.c	Sun Feb 07 18:28:00 2010 +0900
+++ b/gcc/tree-vrp.c	Fri Feb 12 23:39:51 2010 +0900
@@ -121,7 +121,7 @@
 static VEC (switch_update, heap) *to_update_switch_stmts;
 
 
-/* Return the maximum value for TYPEs base type.  */
+/* Return the maximum value for TYPE.  */
 
 static inline tree
 vrp_val_max (const_tree type)
@@ -129,14 +129,10 @@
   if (!INTEGRAL_TYPE_P (type))
     return NULL_TREE;
 
-  /* For integer sub-types the values for the base type are relevant.  */
-  if (TREE_TYPE (type))
-    type = TREE_TYPE (type);
-
   return TYPE_MAX_VALUE (type);
 }
 
-/* Return the minimum value for TYPEs base type.  */
+/* Return the minimum value for TYPE.  */
 
 static inline tree
 vrp_val_min (const_tree type)
@@ -144,10 +140,6 @@
   if (!INTEGRAL_TYPE_P (type))
     return NULL_TREE;
 
-  /* For integer sub-types the values for the base type are relevant.  */
-  if (TREE_TYPE (type))
-    type = TREE_TYPE (type);
-
   return TYPE_MIN_VALUE (type);
 }
 
@@ -188,11 +180,7 @@
 static inline bool
 needs_overflow_infinity (const_tree type)
 {
-  return (INTEGRAL_TYPE_P (type)
-	  && !TYPE_OVERFLOW_WRAPS (type)
-	  /* Integer sub-types never overflow as they are never
-	     operands of arithmetic operators.  */
-	  && !(TREE_TYPE (type) && TREE_TYPE (type) != type));
+  return INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type);
 }
 
 /* Return whether TYPE can support our overflow infinity
@@ -635,7 +623,7 @@
 }
 
 
-/* Return value range information for VAR.  
+/* Return value range information for VAR.
 
    If we have no values ranges recorded (ie, VRP is not running), then
    return NULL.  Otherwise create an empty range if none existed for VAR.  */
@@ -997,11 +985,11 @@
       || TREE_CODE (expr) == MINUS_EXPR)
     return (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
 	    && TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST);
-  
+
   return is_gimple_min_invariant (expr);
 }
 
-/* Return 
+/* Return
    1 if VAL < VAL2
    0 if !(VAL < VAL2)
    -2 if those are incomparable.  */
@@ -1047,7 +1035,7 @@
 }
 
 /* Compare two values VAL1 and VAL2.  Return
-   
+
    	-2 if VAL1 and VAL2 cannot be compared at compile-time,
    	-1 if VAL1 < VAL2,
    	 0 if VAL1 == VAL2,
@@ -1085,7 +1073,7 @@
     {
       tree n1, c1, n2, c2;
       enum tree_code code1, code2;
-  
+
       /* If VAL1 and VAL2 are of the form 'NAME [+-] CST' or 'NAME',
 	 return -1 or +1 accordingly.  If VAL1 and VAL2 don't use the
 	 same name, return -2.  */
@@ -1221,7 +1209,7 @@
       /* First see if VAL1 and VAL2 are not the same.  */
       if (val1 == val2 || operand_equal_p (val1, val2, 0))
 	return 0;
-      
+
       /* If VAL1 is a lower address than VAL2, return -1.  */
       if (operand_less_p (val1, val2) == 1)
 	return -1;
@@ -1282,7 +1270,7 @@
 	  This also applies to value_ranges_intersect_p and
 	  range_includes_zero_p.  The semantics of VR_RANGE and
 	  VR_ANTI_RANGE should be encoded here, but that also means
-	  adapting the users of these functions to the new semantics.  
+	  adapting the users of these functions to the new semantics.
 
    Benchmark compile/20001226-1.c compilation time after changing this
    function.  */
@@ -1307,8 +1295,8 @@
 
 
 /* Return true if value ranges VR0 and VR1 have a non-empty
-   intersection.  
-   
+   intersection.
+
    Benchmark compile/20001226-1.c compilation time after changing this
    function.
    */
@@ -1368,28 +1356,6 @@
   return false;
 }
 
-/* Return true if T, an SSA_NAME, is known to be nonzero.  Return
-   false otherwise or if no value range information is available.  */
-
-bool
-ssa_name_nonzero_p (const_tree t)
-{
-  value_range_t *vr = get_value_range (t);
-
-  if (!vr)
-    return false;
-
-  /* A VR_RANGE which does not include zero is a nonzero value.  */
-  if (vr->type == VR_RANGE && !symbolic_range_p (vr))
-    return ! range_includes_zero_p (vr);
-
-  /* A VR_ANTI_RANGE which does include zero is a nonzero value.  */
-  if (vr->type == VR_ANTI_RANGE && !symbolic_range_p (vr))
-    return range_includes_zero_p (vr);
-
-  return false;
-}
-
 /* If OP has a value range with a single constant value return that,
    otherwise return NULL_TREE.  This returns OP itself if OP is a
    constant.  */
@@ -1576,7 +1542,7 @@
 
 	 The only situation in which we can build a valid
 	 anti-range is when LIMIT_VR is a single-valued range
-	 (i.e., LIMIT_VR->MIN == LIMIT_VR->MAX).  In that case, 
+	 (i.e., LIMIT_VR->MIN == LIMIT_VR->MAX).  In that case,
 	 build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX].  */
       if (limit_vr
 	  && limit_vr->type == VR_RANGE
@@ -1770,7 +1736,7 @@
 	     there are three cases to consider.
 
 
-	     1. The VR_ANTI_RANGE range is completely within the 
+	     1. The VR_ANTI_RANGE range is completely within the
 		VR_RANGE and the endpoints of the ranges are
 		different.  In that case the resulting range
 		should be whichever range is more precise.
@@ -2270,6 +2236,22 @@
 	 the same end of each range.  */
       min = vrp_int_const_binop (code, vr0.min, vr1.min);
       max = vrp_int_const_binop (code, vr0.max, vr1.max);
+
+      /* If both additions overflowed the range kind is still correct.
+	 This happens regularly with subtracting something in unsigned
+	 arithmetic.
+         ???  See PR30318 for all the cases we do not handle.  */
+      if (code == PLUS_EXPR
+	  && (TREE_OVERFLOW (min) && !is_overflow_infinity (min))
+	  && (TREE_OVERFLOW (max) && !is_overflow_infinity (max)))
+	{
+	  min = build_int_cst_wide (TREE_TYPE (min),
+				    TREE_INT_CST_LOW (min),
+				    TREE_INT_CST_HIGH (min));
+	  max = build_int_cst_wide (TREE_TYPE (max),
+				    TREE_INT_CST_LOW (max),
+				    TREE_INT_CST_HIGH (max));
+	}
     }
   else if (code == MULT_EXPR
 	   || code == TRUNC_DIV_EXPR
@@ -2708,13 +2690,6 @@
       tree inner_type = TREE_TYPE (op0);
       tree outer_type = type;
 
-      /* Always use base-types here.  This is important for the
-	 correct signedness.  */
-      if (TREE_TYPE (inner_type))
-	inner_type = TREE_TYPE (inner_type);
-      if (TREE_TYPE (outer_type))
-	outer_type = TREE_TYPE (outer_type);
-
       /* If VR0 is varying and we increase the type precision, assume
 	 a full range for the following transformation.  */
       if (vr0.type == VR_VARYING
@@ -2848,7 +2823,7 @@
 	  set_value_range_to_varying (vr);
 	  return;
 	}
-	
+
       /* ABS_EXPR may flip the range around, if the original range
 	 included negative values.  */
       if (is_overflow_infinity (vr0.min))
@@ -2887,7 +2862,7 @@
       /* If a VR_ANTI_RANGEs contains zero, then we have
 	 ~[-INF, min(MIN, MAX)].  */
       if (vr0.type == VR_ANTI_RANGE)
-	{ 
+	{
 	  if (range_includes_zero_p (&vr0))
 	    {
 	      /* Take the lower of the two values.  */
@@ -3065,7 +3040,7 @@
 {
   bool sop = false;
   tree val;
-  
+
   val = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, false, &sop,
   						 NULL);
 
@@ -3334,7 +3309,7 @@
 
 
 /* Given two numeric value ranges VR0, VR1 and a comparison code COMP:
-   
+
    - Return BOOLEAN_TRUE_NODE if VR0 COMP VR1 always returns true for
      all the values in the ranges.
 
@@ -3491,7 +3466,7 @@
       /* Otherwise, we don't know.  */
       return NULL_TREE;
     }
-    
+
   gcc_unreachable ();
 }
 
@@ -3751,7 +3726,7 @@
 
   if (COMPARISON_CLASS_P (cond))
     {
-      tree a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond); 
+      tree a = build2 (ASSERT_EXPR, TREE_TYPE (v), v, cond);
       assertion = gimple_build_assign (n, a);
     }
   else if (TREE_CODE (cond) == TRUTH_NOT_EXPR)
@@ -3936,7 +3911,6 @@
 			 gimple_stmt_iterator si)
 {
   assert_locus_t n, loc, last_loc;
-  bool found;
   basic_block dest_bb;
 
 #if defined ENABLE_CHECKING
@@ -3960,11 +3934,11 @@
      registered location for A.  If we are doing an edge insertion,
      assume that A will be inserted at E->DEST.  Note that this is not
      necessarily true.
-     
+
      If E is a critical edge, it will be split.  But even if E is
      split, the new block will dominate the same set of blocks that
      E->DEST dominates.
-     
+
      The reverse, however, is not true, blocks dominated by E->DEST
      will not be dominated by the new block created to split E.  So,
      if the insertion location is on a critical edge, we will not use
@@ -3985,7 +3959,6 @@
      COMP_CODE and VAL could be implemented.  */
   loc = asserts_for[SSA_NAME_VERSION (name)];
   last_loc = loc;
-  found = false;
   while (loc)
     {
       if (loc->comp_code == comp_code
@@ -4247,7 +4220,7 @@
 
 /* OP is an operand of a truth value expression which is known to have
    a particular value.  Register any asserts for OP and for any
-   operands in OP's defining statement. 
+   operands in OP's defining statement.
 
    If CODE is EQ_EXPR, then we want to register OP is zero (false),
    if CODE is NE_EXPR, then we want to register OP is nonzero (true).   */
@@ -4266,7 +4239,7 @@
     return false;
 
   /* We know that OP will have a zero or nonzero value.  If OP is used
-     more than once go ahead and register an assert for OP. 
+     more than once go ahead and register an assert for OP.
 
      The FOUND_IN_SUBGRAPH support is not helpful in this situation as
      it will always be set for OP (because OP is used in a COND_EXPR in
@@ -4327,7 +4300,7 @@
 					    code, e, bsi);
     }
   else if (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (op_def)))
-    { 
+    {
       /* Recurse through the type conversion.  */
       retval |= register_edge_assert_for_1 (gimple_assign_rhs1 (op_def),
 					    code, e, bsi);
@@ -4582,7 +4555,7 @@
    If a statement produces a useful assertion A for name N_i, then the
    list of assertions already generated for N_i is scanned to
    determine if A is actually needed.
-   
+
    If N_i already had the assertion A at a location dominating the
    current location, then nothing needs to be done.  Otherwise, the
    new location for A is recorded instead.
@@ -4626,7 +4599,7 @@
 
    4- If BB does not end in a conditional expression, then we recurse
       into BB's dominator children.
-   
+
    At the end of the recursive traversal, every SSA name will have a
    list of locations where ASSERT_EXPRs should be added.  When a new
    location for name N is found, it is registered by calling
@@ -4676,6 +4649,9 @@
 
       stmt = gsi_stmt (si);
 
+      if (is_gimple_debug (stmt))
+	continue;
+
       /* See if we can derive an assertion for any of STMT's operands.  */
       FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_USE)
 	{
@@ -4700,7 +4676,7 @@
 		{
 		  tree t = op;
 		  gimple def_stmt = SSA_NAME_DEF_STMT (t);
-	
+
 		  while (is_gimple_assign (def_stmt)
 			 && gimple_assign_rhs_code (def_stmt)  == NOP_EXPR
 			 && TREE_CODE
@@ -4996,7 +4972,7 @@
    IGNORE_OFF_BY_ONE is true if the ARRAY_REF is inside a ADDR_EXPR.  */
 
 static void
-check_array_ref (tree ref, const location_t *location, bool ignore_off_by_one)
+check_array_ref (location_t location, tree ref, bool ignore_off_by_one)
 {
   value_range_t* vr = NULL;
   tree low_sub, up_sub;
@@ -5035,8 +5011,8 @@
           && TREE_CODE (low_sub) == INTEGER_CST
           && tree_int_cst_lt (low_sub, low_bound))
         {
-          warning (OPT_Warray_bounds,
-                   "%Harray subscript is outside array bounds", location);
+          warning_at (location, OPT_Warray_bounds,
+		      "array subscript is outside array bounds");
           TREE_NO_WARNING (ref) = 1;
         }
     }
@@ -5050,15 +5026,15 @@
                                                         0),
                                        up_sub)))
     {
-      warning (OPT_Warray_bounds, "%Harray subscript is above array bounds",
-               location);
+      warning_at (location, OPT_Warray_bounds,
+		  "array subscript is above array bounds");
       TREE_NO_WARNING (ref) = 1;
     }
   else if (TREE_CODE (low_sub) == INTEGER_CST
            && tree_int_cst_lt (low_sub, low_bound))
     {
-      warning (OPT_Warray_bounds, "%Harray subscript is below array bounds",
-               location);
+      warning_at (location, OPT_Warray_bounds,
+		  "array subscript is below array bounds");
       TREE_NO_WARNING (ref) = 1;
     }
 }
@@ -5067,7 +5043,7 @@
    address of an ARRAY_REF, and call check_array_ref on it.  */
 
 static void
-search_for_addr_array (tree t, const location_t *location)
+search_for_addr_array (tree t, location_t location)
 {
   while (TREE_CODE (t) == SSA_NAME)
     {
@@ -5076,7 +5052,7 @@
       if (gimple_code (g) != GIMPLE_ASSIGN)
 	return;
 
-      if (get_gimple_rhs_class (gimple_assign_rhs_code (g)) 
+      if (get_gimple_rhs_class (gimple_assign_rhs_code (g))
 	  != GIMPLE_SINGLE_RHS)
 	return;
 
@@ -5085,14 +5061,14 @@
 
 
   /* We are only interested in addresses of ARRAY_REF's.  */
-  if (TREE_CODE (t) != ADDR_EXPR) 
+  if (TREE_CODE (t) != ADDR_EXPR)
     return;
 
   /* Check each ARRAY_REFs in the reference chain. */
-  do 
+  do
     {
       if (TREE_CODE (t) == ARRAY_REF)
-	check_array_ref (t, location, true /*ignore_off_by_one*/);
+	check_array_ref (location, t, true /*ignore_off_by_one*/);
 
       t = TREE_OPERAND (t, 0);
     }
@@ -5102,7 +5078,7 @@
 /* walk_tree() callback that checks if *TP is
    an ARRAY_REF inside an ADDR_EXPR (in which an array
    subscript one outside the valid range is allowed). Call
-   check_array_ref for each ARRAY_REF found. The location is 
+   check_array_ref for each ARRAY_REF found. The location is
    passed in DATA.  */
 
 static tree
@@ -5110,12 +5086,20 @@
 {
   tree t = *tp;
   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
-  const location_t *location = (const location_t *) wi->info;
+  location_t location;
+
+  if (EXPR_HAS_LOCATION (t))
+    location = EXPR_LOCATION (t);
+  else
+    {
+      location_t *locp = (location_t *) wi->info;
+      location = *locp;
+    }
 
   *walk_subtree = TRUE;
 
   if (TREE_CODE (t) == ARRAY_REF)
-    check_array_ref (t, location, false /*ignore_off_by_one*/);
+    check_array_ref (location, t, false /*ignore_off_by_one*/);
 
   if (TREE_CODE (t) == INDIRECT_REF
       || (TREE_CODE (t) == RETURN_EXPR && TREE_OPERAND (t, 0)))
@@ -5141,9 +5125,23 @@
       /* Skip bb's that are clearly unreachable.  */
       if (single_pred_p (bb))
       {
-	basic_block pred_bb = EDGE_PRED (bb, 0)->src;
+	int i;
+	bool reachable = true;
+	edge e2;
+	edge e = EDGE_PRED (bb, 0);
+	basic_block pred_bb = e->src;
 	gimple ls = NULL;
 
+	for (i = 0; VEC_iterate (edge, to_remove_edges, i, e2); ++i)
+	  if (e == e2)
+	    {
+	      reachable = false;
+	      break;
+	    }
+
+	if (!reachable)
+	  continue;
+
 	if (!gsi_end_p (gsi_last_bb (pred_bb)))
 	  ls = gsi_stmt (gsi_last_bb (pred_bb));
 
@@ -5157,7 +5155,6 @@
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 	{
 	  gimple stmt = gsi_stmt (si);
-	  const location_t *location = gimple_location_ptr (stmt);
 	  struct walk_stmt_info wi;
 	  if (!gimple_has_location (stmt))
 	    continue;
@@ -5169,13 +5166,14 @@
 	      for (i = 0; i < n; i++)
 		{
 		  tree arg = gimple_call_arg (stmt, i);
-		  search_for_addr_array (arg, location);
+		  search_for_addr_array (arg, gimple_location (stmt));
 		}
 	    }
 	  else
 	    {
 	      memset (&wi, 0, sizeof (wi));
-	      wi.info = CONST_CAST (void *, (const void *) location);
+	      wi.info = CONST_CAST (void *, (const void *)
+				    gimple_location_ptr (stmt));
 
 	      walk_gimple_op (gsi_stmt (si),
 			      check_array_bounds,
@@ -5188,21 +5186,21 @@
 /* Convert range assertion expressions into the implied copies and
    copy propagate away the copies.  Doing the trivial copy propagation
    here avoids the need to run the full copy propagation pass after
-   VRP. 
-   
+   VRP.
+
    FIXME, this will eventually lead to copy propagation removing the
    names that had useful range information attached to them.  For
    instance, if we had the assertion N_i = ASSERT_EXPR <N_j, N_j > 3>,
    then N_i will have the range [3, +INF].
-   
+
    However, by converting the assertion into the implied copy
    operation N_i = N_j, we will then copy-propagate N_j into the uses
    of N_i and lose the range information.  We may want to hold on to
    ASSERT_EXPRs a little while longer as the ranges could be used in
    things like jump threading.
-   
+
    The problem with keeping ASSERT_EXPRs around is that passes after
-   VRP need to handle them appropriately. 
+   VRP need to handle them appropriately.
 
    Another approach would be to make the range information a first
    class property of the SSA_NAME so that it can be queried from
@@ -5247,7 +5245,7 @@
 
 	    /* And finally, remove the copy, it is not needed.  */
 	    gsi_remove (&si, true);
-	    release_defs (stmt); 
+	    release_defs (stmt);
 	  }
 	else
 	  gsi_next (&si);
@@ -5278,7 +5276,7 @@
 	  && ((is_gimple_call (stmt)
 	       && gimple_call_fndecl (stmt) != NULL_TREE
 	       && DECL_IS_BUILTIN (gimple_call_fndecl (stmt)))
-	      || ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS)))
+	      || !gimple_vuse (stmt)))
 	return true;
     }
   else if (gimple_code (stmt) == GIMPLE_COND
@@ -5320,7 +5318,12 @@
         {
 	  gimple stmt = gsi_stmt (si);
 
-	  if (!stmt_interesting_for_vrp (stmt))
+ 	  /* If the statement is a control insn, then we do not
+ 	     want to avoid simulating the statement once.  Failure
+ 	     to do so means that those edges will never get added.  */
+	  if (stmt_ends_bb_p (stmt))
+	    prop_set_simulate_again (stmt, true);
+	  else if (!stmt_interesting_for_vrp (stmt))
 	    {
 	      ssa_op_iter i;
 	      tree def;
@@ -5329,9 +5332,7 @@
 	      prop_set_simulate_again (stmt, false);
 	    }
 	  else
-	    {
-	      prop_set_simulate_again (stmt, true);
-	    }
+	    prop_set_simulate_again (stmt, true);
 	}
     }
 }
@@ -5392,7 +5393,7 @@
 
       return SSA_PROP_NOT_INTERESTING;
     }
-  
+
   /* Every other statement produces no useful ranges.  */
   FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
     set_value_range_to_varying (get_value_range (def));
@@ -5675,7 +5676,7 @@
    based on undefined signed overflow, issue a warning if
    appropriate.  */
 
-tree
+static tree
 vrp_evaluate_conditional (enum tree_code code, tree op0, tree op1, gimple stmt)
 {
   bool sop;
@@ -5720,7 +5721,7 @@
 	    location = input_location;
 	  else
 	    location = gimple_location (stmt);
-	  warning (OPT_Wstrict_overflow, "%H%s", &location, warnmsg);
+	  warning_at (location, OPT_Wstrict_overflow, "%s", warnmsg);
 	}
     }
 
@@ -5734,7 +5735,6 @@
 	 the natural range of OP0's type, then the predicate will
 	 always fold regardless of the value of OP0.  If -Wtype-limits
 	 was specified, emit a warning.  */
-      const char *warnmsg = NULL;
       tree type = TREE_TYPE (op0);
       value_range_t *vr0 = get_value_range (op0);
 
@@ -5744,16 +5744,6 @@
 	  && vrp_val_is_max (vr0->max)
 	  && is_gimple_min_invariant (op1))
 	{
-	  if (integer_zerop (ret))
-	    warnmsg = G_("comparison always false due to limited range of "
-		         "data type");
-	  else
-	    warnmsg = G_("comparison always true due to limited range of "
-			 "data type");
-	}
-
-      if (warnmsg)
-	{
 	  location_t location;
 
 	  if (!gimple_has_location (stmt))
@@ -5761,7 +5751,12 @@
 	  else
 	    location = gimple_location (stmt);
 
-	  warning (OPT_Wtype_limits, "%H%s", &location, warnmsg);
+	  warning_at (location, OPT_Wtype_limits,
+		      integer_zerop (ret)
+		      ? G_("comparison always false "
+                           "due to limited range of data type")
+		      : G_("comparison always true "
+                           "due to limited range of data type"));
 	}
     }
 
@@ -5790,7 +5785,7 @@
       fprintf (dump_file, "\nVisiting conditional with predicate: ");
       print_gimple_stmt (dump_file, stmt, 0, 0);
       fprintf (dump_file, "\nWith known ranges\n");
-      
+
       FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)
 	{
 	  fprintf (dump_file, "\t");
@@ -5804,7 +5799,7 @@
 
   /* Compute the value of the predicate COND by checking the known
      ranges of each of its operands.
-     
+
      Note that we cannot evaluate all the equivalent ranges here
      because those ranges may not yet be final and with the current
      propagation strategy, we cannot determine when the value ranges
@@ -5883,7 +5878,7 @@
    If there is a CASE_LABEL for VAL, its index is placed in IDX and true is
    returned.
 
-   If there is no CASE_LABEL for VAL and the is one that is larger than VAL,
+   If there is no CASE_LABEL for VAL and there is one that is larger than VAL,
    it is placed in IDX and false is returned.
 
    If VAL is larger than any CASE_LABEL, n is placed on IDX and false is
@@ -5951,7 +5946,7 @@
       && min_take_default
       && max_take_default)
     {
-      /* Only the default case label reached. 
+      /* Only the default case label reached.
          Return an empty range. */
       *min_idx = 1;
       *max_idx = 0;
@@ -6000,7 +5995,7 @@
 {
   tree op, val;
   value_range_t *vr;
-  size_t i = 0, j = 0, n;
+  size_t i = 0, j = 0;
   bool take_default;
 
   *taken_edge_p = NULL;
@@ -6023,8 +6018,6 @@
     return SSA_PROP_VARYING;
 
   /* Find the single edge that is taken from the switch expression.  */
-  n = gimple_switch_num_labels (stmt);
-
   take_default = !find_case_label_range (stmt, vr->min, vr->max, &i, &j);
 
   /* Check if the range spans no CASE_LABEL. If so, we only reach the default
@@ -6096,7 +6089,9 @@
       fprintf (dump_file, "\n");
     }
 
-  if (is_gimple_assign (stmt) || is_gimple_call (stmt))
+  if (!stmt_interesting_for_vrp (stmt))
+    gcc_assert (stmt_ends_bb_p (stmt));
+  else if (is_gimple_assign (stmt) || is_gimple_call (stmt))
     {
       /* In general, assignments with virtual operands are not useful
 	 for deriving ranges, with the obvious exception of calls to
@@ -6105,7 +6100,7 @@
       if ((is_gimple_call (stmt)
 	   && gimple_call_fndecl (stmt) != NULL_TREE
 	   && DECL_IS_BUILTIN (gimple_call_fndecl (stmt)))
-	  || ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
+	  || !gimple_vuse (stmt))
 	return vrp_visit_assignment_or_call (stmt, output_p);
     }
   else if (gimple_code (stmt) == GIMPLE_COND)
@@ -6599,10 +6594,9 @@
 	    location = input_location;
 	  else
 	    location = gimple_location (stmt);
-	  warning (OPT_Wstrict_overflow,
-		   ("%Hassuming signed overflow does not occur when "
-		    "simplifying / or %% to >> or &"),
-		   &location);
+	  warning_at (location, OPT_Wstrict_overflow,
+		      "assuming signed overflow does not occur when "
+		      "simplifying %</%> or %<%%%> to %<>>%> or %<&%>");
 	}
     }
 
@@ -6682,10 +6676,9 @@
 		location = input_location;
 	      else
 		location = gimple_location (stmt);
-	      warning (OPT_Wstrict_overflow,
-		       ("%Hassuming signed overflow does not occur when "
-			"simplifying abs (X) to X or -X"),
-		       &location);
+	      warning_at (location, OPT_Wstrict_overflow,
+			  "assuming signed overflow does not occur when "
+			  "simplifying %<abs (X)%> to %<X%> or %<-X%>");
 	    }
 
 	  gimple_assign_set_rhs1 (stmt, op);
@@ -6751,13 +6744,9 @@
      value range information we have for op0.  */
   if (min && max)
     {
-      if (compare_values (vr->min, min) == -1)
-	min = min;
-      else
+      if (compare_values (vr->min, min) == 1)
 	min = vr->min;
-      if (compare_values (vr->max, max) == 1)
-	max = max;
-      else
+      if (compare_values (vr->max, max) == -1)
 	max = vr->max;
 
       /* If the new min/max values have converged to a single value,
@@ -6787,7 +6776,7 @@
       && is_gimple_min_invariant (op1))
     {
       value_range_t *vr = get_value_range (op0);
-	  
+
       /* If we have range information for OP0, then we might be
 	 able to simplify this conditional. */
       if (vr->type == VR_RANGE)
@@ -6868,19 +6857,35 @@
   tree vec2;
   switch_update su;
 
-  if (TREE_CODE (op) != SSA_NAME)
+  if (TREE_CODE (op) == SSA_NAME)
+    {
+      vr = get_value_range (op);
+
+      /* We can only handle integer ranges.  */
+      if (vr->type != VR_RANGE
+	  || symbolic_range_p (vr))
+	return false;
+
+      /* Find case label for min/max of the value range.  */
+      take_default = !find_case_label_range (stmt, vr->min, vr->max, &i, &j);
+    }
+  else if (TREE_CODE (op) == INTEGER_CST)
+    {
+      take_default = !find_case_label_index (stmt, 1, op, &i);
+      if (take_default)
+	{
+	  i = 1;
+	  j = 0;
+	}
+      else
+	{
+	  j = i;
+	}
+    }
+  else
     return false;
 
-  vr = get_value_range (op);
-
-  /* We can only handle integer ranges.  */
-  if (vr->type != VR_RANGE
-      || symbolic_range_p (vr))
-    return false;
-
-  /* Find case label for min/max of the value range.  */
   n = gimple_switch_num_labels (stmt);
-  take_default = !find_case_label_range (stmt, vr->min, vr->max, &i, &j);
 
   /* Bail out if this is just all edges taken.  */
   if (i == 1
@@ -6932,7 +6937,7 @@
 
 /* Simplify STMT using ranges if possible.  */
 
-bool
+static bool
 simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
 {
   gimple stmt = gsi_stmt (*gsi);
@@ -6985,8 +6990,80 @@
   return false;
 }
 
+/* If the statement pointed by SI has a predicate whose value can be
+   computed using the value range information computed by VRP, compute
+   its value and return true.  Otherwise, return false.  */
+
+static bool
+fold_predicate_in (gimple_stmt_iterator *si)
+{
+  bool assignment_p = false;
+  tree val;
+  gimple stmt = gsi_stmt (*si);
+
+  if (is_gimple_assign (stmt)
+      && TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
+    {
+      assignment_p = true;
+      val = vrp_evaluate_conditional (gimple_assign_rhs_code (stmt),
+				      gimple_assign_rhs1 (stmt),
+				      gimple_assign_rhs2 (stmt),
+				      stmt);
+    }
+  else if (gimple_code (stmt) == GIMPLE_COND)
+    val = vrp_evaluate_conditional (gimple_cond_code (stmt),
+				    gimple_cond_lhs (stmt),
+				    gimple_cond_rhs (stmt),
+				    stmt);
+  else
+    return false;
+
+  if (val)
+    {
+      if (assignment_p)
+        val = fold_convert (gimple_expr_type (stmt), val);
+
+      if (dump_file)
+	{
+	  fprintf (dump_file, "Folding predicate ");
+	  print_gimple_expr (dump_file, stmt, 0, 0);
+	  fprintf (dump_file, " to ");
+	  print_generic_expr (dump_file, val, 0);
+	  fprintf (dump_file, "\n");
+	}
+
+      if (is_gimple_assign (stmt))
+	gimple_assign_set_rhs_from_tree (si, val);
+      else
+	{
+	  gcc_assert (gimple_code (stmt) == GIMPLE_COND);
+	  if (integer_zerop (val))
+	    gimple_cond_make_false (stmt);
+	  else if (integer_onep (val))
+	    gimple_cond_make_true (stmt);
+	  else
+	    gcc_unreachable ();
+	}
+
+      return true;
+    }
+
+  return false;
+}
+
+/* Callback for substitute_and_fold folding the stmt at *SI.  */
+
+static bool
+vrp_fold_stmt (gimple_stmt_iterator *si)
+{
+  if (fold_predicate_in (si))
+    return true;
+
+  return simplify_stmt_using_ranges (si);
+}
+
 /* Stack of dest,src equivalency pairs that need to be restored after
-   each attempt to thread a block's incoming edge to an outgoing edge. 
+   each attempt to thread a block's incoming edge to an outgoing edge.
 
    A NULL entry is used to mark the end of pairs which need to be
    restored.  */
@@ -7026,7 +7103,7 @@
    Unlike DOM, we do not iterate VRP if jump threading was successful.
    While iterating may expose new opportunities for VRP, it is expected
    those opportunities would be very limited and the compile time cost
-   to expose those opportunities would be significant. 
+   to expose those opportunities would be significant.
 
    As jump threading opportunities are discovered, they are registered
    for later realization.  */
@@ -7152,7 +7229,7 @@
     }
 
   /* We may have ended with ranges that have exactly one value.  Those
-     values can be substituted as any other copy/const propagated
+     values can be substituted as any other const propagated
      value using substitute_and_fold.  */
   single_val_range = XCNEWVEC (prop_value_t, num_ssa_names);
 
@@ -7160,7 +7237,8 @@
   for (i = 0; i < num_ssa_names; i++)
     if (vr_value[i]
 	&& vr_value[i]->type == VR_RANGE
-	&& vr_value[i]->min == vr_value[i]->max)
+	&& vr_value[i]->min == vr_value[i]->max
+	&& is_gimple_min_invariant (vr_value[i]->min))
       {
 	single_val_range[i].value = vr_value[i]->min;
 	do_value_subst_p = true;
@@ -7174,7 +7252,7 @@
       single_val_range = NULL;
     }
 
-  substitute_and_fold (single_val_range, true);
+  substitute_and_fold (single_val_range, vrp_fold_stmt);
 
   if (warn_array_bounds)
       check_all_array_refs ();
@@ -7220,7 +7298,7 @@
      4	  p_5 = ASSERT_EXPR <p_4, p_4 == q_2>;
      5	endif
      6	if (q_2)
-	
+
    In the code above, pointer p_5 has range [q_2, q_2], but from the
    code we can also determine that p_5 cannot be NULL and, if q_2 had
    a non-varying range, p_5's range should also be compatible with it.
@@ -7234,7 +7312,7 @@
    between names so that we can take advantage of information from
    multiple ranges when doing final replacement.  Note that this
    equivalency relation is transitive but not symmetric.
-   
+
    In the example above, p_5 is equivalent to p_4, q_2 and p_3, but we
    cannot assert that q_2 is equivalent to p_5 because q_2 may be used
    in contexts where that assertion does not hold (e.g., in line 6).
@@ -7261,6 +7339,7 @@
 
   to_remove_edges = VEC_alloc (edge, heap, 10);
   to_update_switch_stmts = VEC_alloc (switch_update, heap, 5);
+  threadedge_initialize_values ();
 
   vrp_initialize ();
   ssa_propagate (vrp_visit_stmt, vrp_visit_phi_node);
@@ -7306,6 +7385,7 @@
 
   VEC_free (edge, heap, to_remove_edges);
   VEC_free (switch_update, heap, to_update_switch_stmts);
+  threadedge_finalize_values ();
 
   scev_finalize ();
   loop_optimizer_finalize ();
@@ -7329,7 +7409,7 @@
   NULL,					/* next */
   0,					/* static_pass_number */
   TV_TREE_VRP,				/* tv_id */
-  PROP_ssa | PROP_alias,		/* properties_required */
+  PROP_ssa,				/* properties_required */
   0,					/* properties_provided */
   0,					/* properties_destroyed */
   0,					/* todo_flags_start */