CbC/CbC_gcc: gcc/tree-vrp.c comparison

comparison gcc/tree-vrp.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	58ad6c70ea60
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 DEF_VEC_O(switch_update);
 DEF_VEC_ALLOC_O(switch_update, heap);
 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)
 {
 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)
 {
 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);
 }
 /* Return whether VAL is equal to the maximum value of its type.  This
 TYPE_{MIN,MAX}_VALUE.  */
 static inline bool
 needs_overflow_infinity (const_tree type)
 {
-return (INTEGRAL_TYPE_P (type)
+return INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (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 whether TYPE can support our overflow infinity
 representation: we use the TREE_OVERFLOW flag, which only exists
 for constants.  If TYPE doesn't support this, we don't optimize
 }
 set_and_canonicalize_value_range (vr, VR_RANGE, min, max, NULL);
 }
 /* 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.  */
 static value_range_t *
 if (TREE_CODE (expr) == PLUS_EXPR
 || 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
 1 if VAL < VAL2
 0 if !(VAL < VAL2)
 -2 if those are incomparable.  */
 static inline int
 operand_less_p (tree val, tree val2)
 return 0;
 }
 /* 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,
 	+1 if VAL1 > VAL2, and
 	+2 if VAL1 != VAL2
 	  || TREE_CODE (val2) == PLUS_EXPR
 	  || TREE_CODE (val2) == MINUS_EXPR))
 {
 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.  */
 if (TREE_CODE (val1) == SSA_NAME)
 	{
 tree t;
 /* 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;
 /* If VAL1 is a higher address than VAL2, return +1.  */
 	  themselves.
 	  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.
 Benchmark compile/20001226-1.c compilation time after changing this
 function.  */
 static inline int
 return !cmp2;
 }
 /* Return true if value ranges VR0 and VR1 have a non-empty
 intersection.
 Benchmark compile/20001226-1.c compilation time after changing this
 function.
 */
 static inline bool
 {
 int result = compare_values (vr->min, integer_zero_node);
 return (result == 0 || result == 1);
 }
-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
 	 and for value 1, VAR should be ~[1, 1].  We cannot
 	 represent these ranges.
 	 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,
 	 build the anti-range ~[LIMIT_VR->MIN, LIMIT_VR->MAX].  */
 if (limit_vr
 	  && limit_vr->type == VR_RANGE
 	  && compare_values (limit_vr->min, limit_vr->max) == 0)
 	{
 	  /* We want to compute the logical AND of the two ranges;
 	     there are three cases to consider.
 	     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.
 		Typically that will be the VR_RANGE.
 /* For operations that make the resulting range directly
 	 proportional to the original ranges, apply the operation to
 	 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
 	   || code == FLOOR_DIV_EXPR
 	   || code == CEIL_DIV_EXPR
 && INTEGRAL_TYPE_P (TREE_TYPE (op0)))
 {
 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
 	  && TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type))
 	{
 		  && !range_includes_zero_p (&vr0))))
 	{
 	  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))
 	min = positive_overflow_infinity (type);
 else if (!vrp_val_is_min (vr0.min))
 cmp = compare_values (min, max);
 /* 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.  */
 	      if (cmp != 1)
 		max = min;
 extract_range_from_comparison (value_range_t *vr, enum tree_code code,
 			       tree type, tree op0, tree op1)
 {
 bool sop = false;
 tree val;
 val = vrp_evaluate_conditional_warnv_with_ops (code, op0, op1, false, &sop,
 						 NULL);
 /* A disadvantage of using a special infinity as an overflow
 representation is that we lose the ability to record overflow
 return false;
 }
 /* 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.
 - Return BOOLEAN_FALSE_NODE if the comparison always returns false.
 	}
 /* Otherwise, we don't know.  */
 return NULL_TREE;
 }
 gcc_unreachable ();
 }
 /* Given a value range VR, a value VAL and a comparison code COMP, return
 gcc_assert (TREE_CODE (v) == SSA_NAME);
 n = duplicate_ssa_name (v, NULL);
 if (COMPARISON_CLASS_P (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)
 {
 /* Given !V, build the assignment N = false.  */
 			 basic_block bb,
 			 edge e,
 			 gimple_stmt_iterator si)
 {
 assert_locus_t n, loc, last_loc;
-bool found;
 basic_block dest_bb;
 #if defined ENABLE_CHECKING
 gcc_assert (bb == NULL || e == NULL);
 /* The new assertion A will be inserted at BB or E.  We need to
 determine if the new location is dominated by a previously
 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
 the new location to move another assertion previously registered
 at a block dominated by E->DEST.  */
 should not be more than a handful of assertions registered per
 name.  If this becomes a performance problem, a table hashed by
 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
 	  && (loc->val == val
 	      || operand_equal_p (loc->val, val, 0))
 return retval;
 }
 /* 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.
 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).   */
 static bool
 /* We only care about SSA_NAMEs.  */
 if (TREE_CODE (op) != SSA_NAME)
 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.
 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
 the subgraph).  */
 if (!has_single_use (op))
 /* Recurse through the copy.  */
 retval |= register_edge_assert_for_1 (gimple_assign_rhs1 (op_def),
 					    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);
 }
 /* Traverse all the statements in block BB looking for statements that
 may generate useful assertions for the SSA names in their operand.
 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.
 1- For every statement S in BB, all the variables used by S are
 determine that 'a' is always 9 on that edge.  However, an assertion
 on the ELSE clause would be unnecessary.
 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
 register_new_assert_for.  That function keeps track of all the
 registered assertions to prevent adding unnecessary assertions.
 tree op;
 ssa_op_iter i;
 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)
 	{
 	  tree value;
 	  enum tree_code comp_code;
 		 for the operand of the NOP_EXPR.  */
 	      if (comp_code == NE_EXPR && integer_zerop (value))
 		{
 		  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
 			     (gimple_assign_rhs1 (def_stmt)) == SSA_NAME
 			 && POINTER_TYPE_P
 range. If the array subscript is a RANGE, warn if it is
 non-overlapping with valid range.
 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;
 tree low_bound, up_bound = array_ref_up_bound (ref);
 if (TREE_CODE (up_sub) == INTEGER_CST
 && tree_int_cst_lt (up_bound, up_sub)
 && TREE_CODE (low_sub) == INTEGER_CST
 && tree_int_cst_lt (low_sub, low_bound))
 {
-warning (OPT_Warray_bounds,
+warning_at (location, OPT_Warray_bounds,
-"%Harray subscript is outside array bounds", location);
+		      "array subscript is outside array bounds");
 TREE_NO_WARNING (ref) = 1;
 }
 }
 else if (TREE_CODE (up_sub) == INTEGER_CST
 && tree_int_cst_lt (up_bound, up_sub)
 up_bound,
 integer_one_node,
 0),
 up_sub)))
 {
-warning (OPT_Warray_bounds, "%Harray subscript is above array bounds",
+warning_at (location, OPT_Warray_bounds,
-location);
+		  "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",
+warning_at (location, OPT_Warray_bounds,
-location);
+		  "array subscript is below array bounds");
 TREE_NO_WARNING (ref) = 1;
 }
 }
 /* Searches if the expr T, located at LOCATION computes
 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)
 {
 gimple g = SSA_NAME_DEF_STMT (t);
 if (gimple_code (g) != GIMPLE_ASSIGN)
 	return;
 if (get_gimple_rhs_class (gimple_assign_rhs_code (g))
 	  != GIMPLE_SINGLE_RHS)
 	return;
 t = gimple_assign_rhs1 (g);
 }
 /* We are only interested in addresses of ARRAY_REF's.  */
 if (TREE_CODE (t) != ADDR_EXPR)
 return;
 /* Check each ARRAY_REFs in the reference chain. */
 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);
 }
 while (handled_component_p (t));
 }
 /* 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
 passed in DATA.  */
 static tree
 check_array_bounds (tree *tp, int *walk_subtree, void *data)
 {
 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)))
 search_for_addr_array (TREE_OPERAND (t, 0), location);
 FOR_EACH_BB (bb)
 {
 /* 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));
 	if (ls && gimple_code (ls) == GIMPLE_COND
 	  continue;
 }
 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;
 	  if (is_gimple_call (stmt))
 	      size_t i;
 	      size_t n = gimple_call_num_args (stmt);
 	      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,
 			      &wi);
 	    }
 }
 /* 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.
 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.
 Another approach would be to make the range information a first
 class property of the SSA_NAME so that it can be queried from
 any pass.  This is made somewhat more complex by the need for
 multiple ranges to be associated with one SSA_NAME.  */
 		  gcc_assert (TREE_CODE (var) == SSA_NAME);
 		}
 	    /* And finally, remove the copy, it is not needed.  */
 	    gsi_remove (&si, true);
 	    release_defs (stmt);
 	  }
 	else
 	  gsi_next (&si);
 }
 }
 	  && (INTEGRAL_TYPE_P (TREE_TYPE (lhs))
 	      || POINTER_TYPE_P (TREE_TYPE (lhs)))
 	  && ((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
 	   || gimple_code (stmt) == GIMPLE_SWITCH)
 return true;
 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 {
 	  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;
 	      FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_DEF)
 		set_value_range_to_varying (get_value_range (def));
 	      prop_set_simulate_again (stmt, false);
 	    }
 	  else
-	    {
+	    prop_set_simulate_again (stmt, true);
-	      prop_set_simulate_again (stmt, true);
-	    }
 	}
 }
 }
 	  return SSA_PROP_INTERESTING;
 	}
 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));
 return SSA_PROP_VARYING;
 The ranges of all the names equivalent with the operands in COND
 will be used when trying to compute the value.  If the result is
 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;
 tree ret;
 bool only_ranges;
 	  if (!gimple_has_location (stmt))
 	    location = input_location;
 	  else
 	    location = gimple_location (stmt);
-	  warning (OPT_Wstrict_overflow, "%H%s", &location, warnmsg);
+	  warning_at (location, OPT_Wstrict_overflow, "%s", warnmsg);
 	}
 }
 if (warn_type_limits
 && ret && only_ranges
 /* If the comparison is being folded and the operand on the LHS
 	 is being compared against a constant value that is outside of
 	 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);
 if (vr0->type != VR_VARYING
 	  && INTEGRAL_TYPE_P (type)
 	  && vrp_val_is_min (vr0->min)
 	  && 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))
 	    location = input_location;
 	  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"));
 	}
 }
 return ret;
 }
 ssa_op_iter i;
 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");
 	  print_generic_expr (dump_file, use, 0);
 	  fprintf (dump_file, ": ");
 fprintf (dump_file, "\n");
 }
 /* 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
 of the names in the equivalence set have changed.
 [START_IDX, n - 1] where n is the size of VEC.
 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
 returned. */
 if (i == j
 && min_take_default
 && max_take_default)
 {
 /* Only the default case label reached.
 Return an empty range. */
 *min_idx = 1;
 *max_idx = 0;
 return false;
 }
 static enum ssa_prop_result
 vrp_visit_switch_stmt (gimple stmt, edge *taken_edge_p)
 {
 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;
 op = gimple_switch_index (stmt);
 if (TREE_CODE (op) != SSA_NAME)
 if (vr->type != VR_RANGE
 || symbolic_range_p (vr))
 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
 label */
 if (j < i)
 fprintf (dump_file, "\nVisiting statement:\n");
 print_gimple_stmt (dump_file, stmt, 0, dump_flags);
 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
 	 builtin functions.  */
 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)
 return vrp_visit_cond_stmt (stmt, taken_edge_p);
 else if (gimple_code (stmt) == GIMPLE_SWITCH)
 	  if (!gimple_has_location (stmt))
 	    location = input_location;
 	  else
 	    location = gimple_location (stmt);
-	  warning (OPT_Wstrict_overflow,
+	  warning_at (location, OPT_Wstrict_overflow,
-		   ("%Hassuming signed overflow does not occur when "
+		      "assuming signed overflow does not occur when "
-		    "simplifying / or %% to >> or &"),
+		      "simplifying %</%> or %<%%%> to %<>>%> or %<&%>");
-		   &location);
 	}
 }
 if (val && integer_onep (val))
 {
 	      if (!gimple_has_location (stmt))
 		location = input_location;
 	      else
 		location = gimple_location (stmt);
-	      warning (OPT_Wstrict_overflow,
+	      warning_at (location, OPT_Wstrict_overflow,
-		       ("%Hassuming signed overflow does not occur when "
+			  "assuming signed overflow does not occur when "
-			"simplifying abs (X) to X or -X"),
+			  "simplifying %<abs (X)%> to %<X%> or %<-X%>");
-		       &location);
 	    }
 	  gimple_assign_set_rhs1 (stmt, op);
 	  if (integer_onep (val))
 	    gimple_assign_set_rhs_code (stmt, NEGATE_EXPR);
 /* Now refine the minimum and maximum values using any
 value range information we have for op0.  */
 if (min && max)
 {
-if (compare_values (vr->min, min) == -1)
+if (compare_values (vr->min, min) == 1)
-	min = min;
-else
 	min = vr->min;
-if (compare_values (vr->max, max) == 1)
+if (compare_values (vr->max, max) == -1)
-	max = max;
-else
 	max = vr->max;
 /* If the new min/max values have converged to a single value,
 	 then there is only one value which can satisfy the condition,
 	 return that value.  */
 && TREE_CODE (op0) == SSA_NAME
 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
 && 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)
 	{
 	  tree new_tree = test_for_singularity (cond_code, op0, op1, vr);
 edge_iterator ei;
 size_t i = 0, j = 0, n, n2;
 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
 && j == n - 1
 && take_default)
 return false;
 }
 /* Simplify STMT using ranges if possible.  */
-bool
+static bool
 simplify_stmt_using_ranges (gimple_stmt_iterator *gsi)
 {
 gimple stmt = gsi_stmt (*gsi);
 if (is_gimple_assign (stmt))
 {
 return simplify_switch_using_ranges (stmt);
 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.
 A NULL entry is used to mark the end of pairs which need to be
 restored.  */
 static VEC(tree,heap) *stack;
 with edges that may be suitable for jump threading.
 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.
 As jump threading opportunities are discovered, they are registered
 for later realization.  */
 static void
 dump_all_value_ranges (dump_file);
 fprintf (dump_file, "\n");
 }
 /* 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);
 do_value_subst_p = false;
 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;
 }
 	 do single value substitution in substitute_and_fold.  */
 free (single_val_range);
 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 ();
 /* We must identify jump threading opportunities before we release
 2	p_4 = ASSERT_EXPR <p_3, p_3 != 0>
 3	if (p_4 == q_2)
 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.
 These equivalences are created by two expressions: ASSERT_EXPR and
 Together with value ranges, we also propagate these equivalences
 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).
 TODO, the main difference between this pass and Patterson's is that
 insert_range_assertions ();
 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);
 vrp_finalize ();
 if (VEC_length (edge, to_remove_edges) > 0)
 free_dominance_info (CDI_DOMINATORS);
 VEC_free (edge, heap, to_remove_edges);
 VEC_free (switch_update, heap, to_update_switch_stmts);
+threadedge_finalize_values ();
 scev_finalize ();
 loop_optimizer_finalize ();
 return 0;
 }
 execute_vrp,				/* execute */
 NULL,					/* sub */
 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 */
 TODO_cleanup_cfg
 | TODO_ggc_collect

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-vrp.c @ 55:77e2b8dfacca gcc-4.4.5