CbC/CbC_gcc: gcc/tree-ssa-ccp.c comparison

comparison gcc/tree-ssa-ccp.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	3bfb6c00c1e0
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 Free Software Foundation, Inc.
 Adapted from original RTL SSA-CCP by Daniel Berlin <dberlin@dberlin.org>
 Adapted to GIMPLE trees by Diego Novillo <dnovillo@redhat.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 3, or (at your option) any
 later version.
 GCC is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 /* Conditional constant propagation (CCP) is based on the SSA
 If the statement is a conditional with a constant predicate, we
 mark the outgoing edges as executable or not executable
 depending on the predicate's value.  This is then used when
 visiting PHI nodes to know when a PHI argument can be ignored.
 2- In ccp_visit_phi_node, if all the PHI arguments evaluate to the
 same constant C, then the LHS of the PHI is set to C.  This
 evaluation is known as the "meet operation".  Since one of the
 goals of this evaluation is to optimistically return constant
 #include "tree-ssa-propagate.h"
 #include "value-prof.h"
 #include "langhooks.h"
 #include "target.h"
 #include "toplev.h"
+#include "dbgcnt.h"
 /* Possible lattice values.  */
 typedef enum
 {
 memory reference used to store (i.e., the LHS of the assignment
 doing the store).  */
 static prop_value_t *const_val;
 static void canonicalize_float_value (prop_value_t *);
+static bool ccp_fold_stmt (gimple_stmt_iterator *);
 /* Dump constant propagation value VAL to file OUTF prefixed by PREFIX.  */
 static void
 dump_lattice_value (FILE *outf, const char *prefix, prop_value_t val)
 tree
 get_symbol_constant_value (tree sym)
 {
 if (TREE_STATIC (sym)
-&& TREE_READONLY (sym)
+&& (TREE_READONLY (sym)
-&& !MTAG_P (sym))
+	  || TREE_CODE (sym) == CONST_DECL))
 {
 tree val = DECL_INITIAL (sym);
 if (val)
 	{
 	  STRIP_USELESS_TYPE_CONVERSION (val);
 	  if (is_gimple_min_invariant (val))
-	    return val;
+	    {
+	      if (TREE_CODE (val) == ADDR_EXPR)
+		{
+		  tree base = get_base_address (TREE_OPERAND (val, 0));
+		  if (base && TREE_CODE (base) == VAR_DECL)
+		    {
+		      TREE_ADDRESSABLE (base) = 1;
+		      if (gimple_referenced_vars (cfun))
+			add_referenced_var (base);
+		    }
+		}
+	      return val;
+	    }
 	}
 /* Variables declared 'const' without an initializer
 	 have zero as the initializer if they may not be
 	 overridden at link or run time.  */
 if (!val
 static prop_value_t
 get_default_value (tree var)
 {
 tree sym = SSA_NAME_VAR (var);
 prop_value_t val = { UNINITIALIZED, NULL_TREE };
-tree cst_val;
+gimple stmt;
-if (!is_gimple_reg (var))
+stmt = SSA_NAME_DEF_STMT (var);
-{
-/* Short circuit for regular CCP.  We are not interested in any
+if (gimple_nop_p (stmt))
-	 non-register when DO_STORE_CCP is false.  */
+{
-val.lattice_val = VARYING;
+/* Variables defined by an empty statement are those used
-}
+	 before being initialized.  If VAR is a local variable, we
-else if ((cst_val = get_symbol_constant_value (sym)) != NULL_TREE)
+	 can assume initially that it is UNDEFINED, otherwise we must
-{
+	 consider it VARYING.  */
-/* Globals and static variables declared 'const' take their
+if (is_gimple_reg (sym) && TREE_CODE (sym) != PARM_DECL)
-	 initial value.  */
+	val.lattice_val = UNDEFINED;
-val.lattice_val = CONSTANT;
+else
-val.value = cst_val;
+	val.lattice_val = VARYING;
 }
-else
+else if (is_gimple_assign (stmt)
-{
+	   /* Value-returning GIMPLE_CALL statements assign to
-gimple stmt = SSA_NAME_DEF_STMT (var);
+	      a variable, and are treated similarly to GIMPLE_ASSIGN.  */
+	   || (is_gimple_call (stmt)
-if (gimple_nop_p (stmt))
+	       && gimple_call_lhs (stmt) != NULL_TREE)
+	   || gimple_code (stmt) == GIMPLE_PHI)
+{
+tree cst;
+if (gimple_assign_single_p (stmt)
+	  && DECL_P (gimple_assign_rhs1 (stmt))
+	  && (cst = get_symbol_constant_value (gimple_assign_rhs1 (stmt))))
 	{
-	  /* Variables defined by an empty statement are those used
+	  val.lattice_val = CONSTANT;
-	     before being initialized.  If VAR is a local variable, we
+	  val.value = cst;
-	     can assume initially that it is UNDEFINED, otherwise we must
-	     consider it VARYING.  */
-	  if (is_gimple_reg (sym) && TREE_CODE (sym) != PARM_DECL)
-	    val.lattice_val = UNDEFINED;
-	  else
-	    val.lattice_val = VARYING;
-	}
-else if (is_gimple_assign (stmt)
-/* Value-returning GIMPLE_CALL statements assign to
-a variable, and are treated similarly to GIMPLE_ASSIGN.  */
-|| (is_gimple_call (stmt)
-&& gimple_call_lhs (stmt) != NULL_TREE)
-	       || gimple_code (stmt) == GIMPLE_PHI)
-{
-	  /* Any other variable defined by an assignment or a PHI node
-	     is considered UNDEFINED.  */
-	  val.lattice_val = UNDEFINED;
 	}
 else
-	{
+	/* Any other variable defined by an assignment or a PHI node
-	  /* Otherwise, VAR will never take on a constant value.  */
+	   is considered UNDEFINED.  */
-	  val.lattice_val = VARYING;
+	val.lattice_val = UNDEFINED;
-	}
+}
+else
+{
+/* Otherwise, VAR will never take on a constant value.  */
+val.lattice_val = VARYING;
 }
 return val;
 }
 likely_value (gimple stmt)
 {
 bool has_constant_operand, has_undefined_operand, all_undefined_operands;
 tree use;
 ssa_op_iter iter;
+unsigned i;
 enum gimple_code code = gimple_code (stmt);
 /* This function appears to be called only for assignments, calls,
 conditionals, and switches, due to the logic in visit_stmt.  */
 /* If the statement has volatile operands, it won't fold to a
 constant value.  */
 if (gimple_has_volatile_ops (stmt))
 return VARYING;
-/* If we are not doing store-ccp, statements with loads
-and/or stores will never fold into a constant.  */
-if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
-return VARYING;
-/* Note that only a GIMPLE_SINGLE_RHS assignment can satisfy
-is_gimple_min_invariant, so we do not consider calls or
-other forms of assignment.  */
-if (gimple_assign_single_p (stmt)
-&& is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
-return CONSTANT;
-if (code == GIMPLE_COND
-&& is_gimple_min_invariant (gimple_cond_lhs (stmt))
-&& is_gimple_min_invariant (gimple_cond_rhs (stmt)))
-return CONSTANT;
-if (code == GIMPLE_SWITCH
-&& is_gimple_min_invariant (gimple_switch_index (stmt)))
-return CONSTANT;
 /* Arrive here for more complex cases.  */
 has_constant_operand = false;
 has_undefined_operand = false;
 all_undefined_operands = true;
-FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE | SSA_OP_VUSE)
+FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
 {
 prop_value_t *val = get_value (use);
 if (val->lattice_val == UNDEFINED)
 	has_undefined_operand = true;
 else
 	all_undefined_operands = false;
 if (val->lattice_val == CONSTANT)
+	has_constant_operand = true;
+}
+/* There may be constants in regular rhs operands.  For calls we
+have to ignore lhs, fndecl and static chain, otherwise only
+the lhs.  */
+for (i = (is_gimple_call (stmt) ? 2 : 0) + gimple_has_lhs (stmt);
+i < gimple_num_ops (stmt); ++i)
+{
+tree op = gimple_op (stmt, i);
+if (!op || TREE_CODE (op) == SSA_NAME)
+	continue;
+if (is_gimple_min_invariant (op))
 	has_constant_operand = true;
 }
 /* If the operation combines operands like COMPLEX_EXPR make sure to
 not mark the result UNDEFINED if only one part of the result is
 /* If there was an UNDEFINED operand but the result may be not UNDEFINED
 fall back to VARYING even if there were CONSTANT operands.  */
 if (has_undefined_operand)
 return VARYING;
+/* We do not consider virtual operands here -- load from read-only
+memory may have only VARYING virtual operands, but still be
+constant.  */
 if (has_constant_operand
-/* We do not consider virtual operands here -- load from read-only
+|| gimple_references_memory_p (stmt))
-	 memory may have only VARYING virtual operands, but still be
-	 constant.  */
-|| ZERO_SSA_OPERANDS (stmt, SSA_OP_USE))
 return CONSTANT;
 return VARYING;
 }
 surely_varying_stmt_p (gimple stmt)
 {
 /* If the statement has operands that we cannot handle, it cannot be
 constant.  */
 if (gimple_has_volatile_ops (stmt))
-return true;
-if (!ZERO_SSA_OPERANDS (stmt, SSA_OP_ALL_VIRTUALS))
 return true;
 /* If it is a call and does not return a value or is not a
 builtin and not an indirect call, it is varying.  */
 if (is_gimple_call (stmt))
 if (!gimple_call_lhs (stmt)
 	  || ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
 	      && !DECL_BUILT_IN (fndecl)))
 	return true;
 }
+/* Any other store operation is not interesting.  */
+else if (gimple_vdef (stmt))
+return true;
 /* Anything other than assignments and conditional jumps are not
 interesting for CCP.  */
 if (gimple_code (stmt) != GIMPLE_ASSIGN
 && gimple_code (stmt) != GIMPLE_COND
 gimple_stmt_iterator i;
 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 {
 	  gimple stmt = gsi_stmt (i);
-	  bool is_varying = surely_varying_stmt_p (stmt);
+	  bool is_varying;
+	  /* 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))
+	    is_varying = false;
+	  else
+	    is_varying = surely_varying_stmt_p (stmt);
 	  if (is_varying)
 	    {
 	      tree def;
 	      ssa_op_iter iter;
 	      /* If the statement will not produce a constant, mark
 		 all its outputs VARYING.  */
 	      FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
-		{
+		set_value_varying (def);
-		  if (is_varying)
-		    set_value_varying (def);
-		}
 	    }
 prop_set_simulate_again (stmt, !is_varying);
 	}
 }
 prop_set_simulate_again (phi, true);
 	}
 }
 }
+/* Debug count support. Reset the values of ssa names
+VARYING when the total number ssa names analyzed is
+beyond the debug count specified.  */
+static void
+do_dbg_cnt (void)
+{
+unsigned i;
+for (i = 0; i < num_ssa_names; i++)
+{
+if (!dbg_cnt (ccp))
+{
+const_val[i].lattice_val = VARYING;
+const_val[i].value = NULL_TREE;
+}
+}
+}
 /* Do final substitution of propagated values, cleanup the flowgraph and
 free allocated storage.
 Return TRUE when something was optimized.  */
 static bool
 ccp_finalize (void)
 {
+bool something_changed;
+do_dbg_cnt ();
 /* Perform substitutions based on the known constant values.  */
-bool something_changed = substitute_and_fold (const_val, false);
+something_changed = substitute_and_fold (const_val, ccp_fold_stmt);
 free (const_val);
 const_val = NULL;
 return something_changed;;
 }
 }
 else
 return SSA_PROP_NOT_INTERESTING;
 }
 /* Return true if we may propagate the address expression ADDR into the
 dereference DEREF and cancel them.  */
 bool
 may_propagate_address_into_dereference (tree addr, tree deref)
 {
 otherwise return the original RHS or NULL_TREE.  */
 static tree
 ccp_fold (gimple stmt)
 {
+location_t loc = gimple_location (stmt);
 switch (gimple_code (stmt))
 {
 case GIMPLE_ASSIGN:
 {
 enum tree_code subcode = gimple_assign_rhs_code (stmt);
 			  *base = save;
 			  return ret;
 			}
 		    }
 		}
+	      else if (TREE_CODE (rhs) == CONSTRUCTOR
+		       && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE
+		       && (CONSTRUCTOR_NELTS (rhs)
+			   == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs))))
+		{
+		  unsigned i;
+		  tree val, list;
+		  list = NULL_TREE;
+		  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val)
+		    {
+		      if (TREE_CODE (val) == SSA_NAME
+			  && get_value (val)->lattice_val == CONSTANT)
+			val = get_value (val)->value;
+		      if (TREE_CODE (val) == INTEGER_CST
+			  || TREE_CODE (val) == REAL_CST
+			  || TREE_CODE (val) == FIXED_CST)
+			list = tree_cons (NULL_TREE, val, list);
+		      else
+			return NULL_TREE;
+		    }
+		  return build_vector (TREE_TYPE (rhs), nreverse (list));
+		}
 if (kind == tcc_reference)
 		{
-		  if (TREE_CODE (rhs) == VIEW_CONVERT_EXPR
+		  if ((TREE_CODE (rhs) == VIEW_CONVERT_EXPR
+		       || TREE_CODE (rhs) == REALPART_EXPR
+		       || TREE_CODE (rhs) == IMAGPART_EXPR)
 		      && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
 		    {
 		      prop_value_t *val = get_value (TREE_OPERAND (rhs, 0));
 		      if (val->lattice_val == CONSTANT)
-			return fold_unary (VIEW_CONVERT_EXPR,
+			return fold_unary_loc (EXPR_LOCATION (rhs),
+					   TREE_CODE (rhs),
 					   TREE_TYPE (rhs), val->value);
+		    }
+		  else if (TREE_CODE (rhs) == INDIRECT_REF
+			   && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
+		    {
+		      prop_value_t *val = get_value (TREE_OPERAND (rhs, 0));
+		      if (val->lattice_val == CONSTANT
+			  && TREE_CODE (val->value) == ADDR_EXPR
+			  && useless_type_conversion_p (TREE_TYPE (rhs),
+							TREE_TYPE (TREE_TYPE (val->value))))
+			rhs = TREE_OPERAND (val->value, 0);
 		    }
 		  return fold_const_aggregate_ref (rhs);
 		}
 else if (kind == tcc_declaration)
 return get_symbol_constant_value (rhs);
 return rhs;
 }
 case GIMPLE_UNARY_RHS:
 {
 /* Handle unary operators that can appear in GIMPLE form.
 Note that we know the single operand must be a constant,
 so this should almost always return a simplified RHS.  */
 		  tree tem;
 		  /* Still try to generate a constant of correct type.  */
 		  if (!useless_type_conversion_p (TREE_TYPE (lhs),
 						  TREE_TYPE (op0))
 		      && ((tem = maybe_fold_offset_to_address
-				   (op0, integer_zero_node, TREE_TYPE (lhs)))
+			   (loc,
+			    op0, integer_zero_node, TREE_TYPE (lhs)))
 			  != NULL_TREE))
 		    return tem;
 		  return op0;
 		}
-return fold_unary_ignore_overflow (subcode,
+return
-						 gimple_expr_type (stmt), op0);
+		fold_unary_ignore_overflow_loc (loc, subcode,
+						gimple_expr_type (stmt), op0);
 }
 case GIMPLE_BINARY_RHS:
 {
 /* Handle binary operators that can appear in GIMPLE form.  */
 	      /* Fold &foo + CST into an invariant reference if possible.  */
 	      if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
 		  && TREE_CODE (op0) == ADDR_EXPR
 		  && TREE_CODE (op1) == INTEGER_CST)
 		{
-		  tree lhs = gimple_assign_lhs (stmt);
+		  tree tem = maybe_fold_offset_to_address
-		  tree tem = maybe_fold_offset_to_address (op0, op1,
+		    (loc, op0, op1, TREE_TYPE (op0));
-							   TREE_TYPE (lhs));
 		  if (tem != NULL_TREE)
 		    return tem;
 		}
-return fold_binary (subcode, gimple_expr_type (stmt), op0, op1);
+return fold_binary_loc (loc, subcode,
+				  gimple_expr_type (stmt), op0, op1);
 }
 default:
 gcc_unreachable ();
 }
 		    val = get_value (args[i]);
 		    if (val->lattice_val == CONSTANT)
 		      args[i] = val->value;
 		  }
 	      }
-	    call = build_call_array (gimple_call_return_type (stmt),
+	    call = build_call_array_loc (loc,
-				     fn, gimple_call_num_args (stmt), args);
+					 gimple_call_return_type (stmt),
-	    retval = fold_call_expr (call, false);
+					 fn, gimple_call_num_args (stmt), args);
+	    retval = fold_call_expr (EXPR_LOCATION (call), call, false);
 	    if (retval)
 	      /* fold_call_expr wraps the result inside a NOP_EXPR.  */
 	      STRIP_NOPS (retval);
 	    return retval;
 	  }
 prop_value_t *val = get_value (op1);
 if (val->lattice_val == CONSTANT)
 op1 = val->value;
 }
-return fold_binary (code, boolean_type_node, op0, op1);
+return fold_binary_loc (loc, code, boolean_type_node, op0, op1);
 }
 case GIMPLE_SWITCH:
 {
 tree rhs = gimple_switch_index (stmt);
 {
 prop_value_t *value;
 tree base, ctor, idx, field;
 unsigned HOST_WIDE_INT cnt;
 tree cfield, cval;
+if (TREE_CODE_CLASS (TREE_CODE (t)) == tcc_declaration)
+return get_symbol_constant_value (t);
 switch (TREE_CODE (t))
 {
 case ARRAY_REF:
 /* Get a CONSTRUCTOR.  If BASE is a VAR_DECL, get its
 /* Whoo-hoo!  I'll fold ya baby.  Yeah!  */
 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
 	if (tree_int_cst_equal (cfield, idx))
 	  {
 	    STRIP_USELESS_TYPE_CONVERSION (cval);
+	    if (TREE_CODE (cval) == ADDR_EXPR)
+	      {
+		tree base = get_base_address (TREE_OPERAND (cval, 0));
+		if (base && TREE_CODE (base) == VAR_DECL)
+		  add_referenced_var (base);
+	      }
 	    return cval;
 	  }
 break;
 case COMPONENT_REF:
 	if (cfield == field
 	    /* FIXME: Handle bit-fields.  */
 	    && ! DECL_BIT_FIELD (cfield))
 	  {
 	    STRIP_USELESS_TYPE_CONVERSION (cval);
+	    if (TREE_CODE (cval) == ADDR_EXPR)
+	      {
+		tree base = get_base_address (TREE_OPERAND (cval, 0));
+		if (base && TREE_CODE (base) == VAR_DECL)
+		  add_referenced_var (base);
+	      }
 	    return cval;
 	  }
 break;
 case REALPART_EXPR:
 case IMAGPART_EXPR:
 {
 	tree c = fold_const_aggregate_ref (TREE_OPERAND (t, 0));
 	if (c && TREE_CODE (c) == COMPLEX_CST)
-	  return fold_build1 (TREE_CODE (t), TREE_TYPE (t), c);
+	  return fold_build1_loc (EXPR_LOCATION (t),
+			      TREE_CODE (t), TREE_TYPE (t), c);
 	break;
 }
 case INDIRECT_REF:
 {
 {
 enum gimple_code code = gimple_code (stmt);
 if (code == GIMPLE_ASSIGN)
 {
 enum tree_code subcode = gimple_assign_rhs_code (stmt);
 /* Other cases cannot satisfy is_gimple_min_invariant
 without folding.  */
 if (get_gimple_rhs_class (subcode) == GIMPLE_SINGLE_RHS)
 simplified = gimple_assign_rhs1 (stmt);
 }
 else if (code == GIMPLE_SWITCH)
 simplified = gimple_switch_index (stmt);
 else
-/* These cannot satisfy is_gimple_min_invariant without folding.  */
+	/* These cannot satisfy is_gimple_min_invariant without folding.  */
-gcc_assert (code == GIMPLE_CALL || code == GIMPLE_COND);
+	gcc_assert (code == GIMPLE_CALL || code == GIMPLE_COND);
 }
 is_constant = simplified && is_gimple_min_invariant (simplified);
 fold_undefer_overflow_warnings (is_constant, stmt, 0);
 }
 return val;
 }
+/* Fold the stmt at *GSI with CCP specific information that propagating
+and regular folding does not catch.  */
+static bool
+ccp_fold_stmt (gimple_stmt_iterator *gsi)
+{
+gimple stmt = gsi_stmt (*gsi);
+prop_value_t val;
+if (gimple_code (stmt) != GIMPLE_COND)
+return false;
+/* Statement evaluation will handle type mismatches in constants
+more gracefully than the final propagation.  This allows us to
+fold more conditionals here.  */
+val = evaluate_stmt (stmt);
+if (val.lattice_val != CONSTANT
+|| TREE_CODE (val.value) != INTEGER_CST)
+return false;
+if (integer_zerop (val.value))
+gimple_cond_make_false (stmt);
+else
+gimple_cond_make_true (stmt);
+return true;
+}
 /* Visit the assignment statement STMT.  Set the value of its LHS to the
 value computed by the RHS and store LHS in *OUTPUT_P.  If STMT
 creates virtual definitions, set the value of each new name to that
 of the RHS (if we can derive a constant out of the RHS).
 Value-returning call statements also perform an assignment, and
 /* Evaluate statement STMT.  If the statement produces an output value and
 its evaluation changes the lattice value of its output, return
 SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
 output value.
 If STMT is a conditional branch and we can determine its truth
 value, set *TAKEN_EDGE_P accordingly.  If STMT produces a varying
 value, return SSA_PROP_VARYING.  */
 static enum ssa_prop_result
 {
 return flag_tree_ccp != 0;
 }
 struct gimple_opt_pass pass_ccp =
 {
 {
 GIMPLE_PASS,
 "ccp",				/* name */
 gate_ccp,				/* gate */
 | TODO_verify_stmts | TODO_ggc_collect/* todo_flags_finish */
 }
 };
-/* A subroutine of fold_stmt_r.  Attempts to fold *(A+O) to A[X].
+/* A subroutine of fold_stmt.  Attempts to fold *(A+O) to A[X].
 BASE is an array type.  OFFSET is a byte displacement.  ORIG_TYPE
-is the desired result type.  */
+is the desired result type.
+LOC is the location of the original expression.  */
 static tree
-maybe_fold_offset_to_array_ref (tree base, tree offset, tree orig_type,
+maybe_fold_offset_to_array_ref (location_t loc, tree base, tree offset,
+				tree orig_type,
 				bool allow_negative_idx)
 {
 tree min_idx, idx, idx_type, elt_offset = integer_zero_node;
 tree array_type, elt_type, elt_size;
 tree domain_type;
 give false warnings.  The same is true for
 struct A { long x; char d[0]; } *a;
 (char *)a - 4;
 which should be not folded to &a->d[-8].  */
 if (domain_type
 && TYPE_MAX_VALUE (domain_type)
 && TREE_CODE (TYPE_MAX_VALUE (domain_type)) == INTEGER_CST)
 {
 tree up_bound = TYPE_MAX_VALUE (domain_type);
 if (tree_int_cst_lt (up_bound, idx)
 }
 else if (!allow_negative_idx
 	   && compare_tree_int (idx, 0) < 0)
 return NULL_TREE;
-return build4 (ARRAY_REF, elt_type, base, idx, NULL_TREE, NULL_TREE);
+{
+tree t = build4 (ARRAY_REF, elt_type, base, idx, NULL_TREE, NULL_TREE);
+SET_EXPR_LOCATION (t, loc);
+return t;
+}
 }
 /* Attempt to fold *(S+O) to S.X.
 BASE is a record type.  OFFSET is a byte displacement.  ORIG_TYPE
-is the desired result type.  */
+is the desired result type.
+LOC is the location of the original expression.  */
 static tree
-maybe_fold_offset_to_component_ref (tree record_type, tree base, tree offset,
+maybe_fold_offset_to_component_ref (location_t loc, tree record_type,
-				    tree orig_type)
+				    tree base, tree offset, tree orig_type)
 {
 tree f, t, field_type, tail_array_field, field_offset;
 tree ret;
 tree new_base;
 	  && useless_type_conversion_p (orig_type, field_type))
 	{
 	  t = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
 	  return t;
 	}
 /* Don't care about offsets into the middle of scalars.  */
 if (!AGGREGATE_TYPE_P (field_type))
 	continue;
 /* Check for array at the end of the struct.  This is often
 	continue;
 /* If we matched, then set offset to the displacement into
 	 this field.  */
 new_base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
+SET_EXPR_LOCATION (new_base, loc);
 /* Recurse to possibly find the match.  */
-ret = maybe_fold_offset_to_array_ref (new_base, t, orig_type,
+ret = maybe_fold_offset_to_array_ref (loc, new_base, t, orig_type,
 					    f == TYPE_FIELDS (record_type));
 if (ret)
 	return ret;
-ret = maybe_fold_offset_to_component_ref (field_type, new_base, t,
+ret = maybe_fold_offset_to_component_ref (loc, field_type, new_base, t,
 						orig_type);
 if (ret)
 	return ret;
 }
 f = tail_array_field;
 field_type = TREE_TYPE (f);
 offset = int_const_binop (MINUS_EXPR, offset, byte_position (f), 1);
 /* If we get here, we've got an aggregate field, and a possibly
 nonzero offset into them.  Recurse and hope for a valid match.  */
 base = build3 (COMPONENT_REF, field_type, base, f, NULL_TREE);
+SET_EXPR_LOCATION (base, loc);
-t = maybe_fold_offset_to_array_ref (base, offset, orig_type,
+t = maybe_fold_offset_to_array_ref (loc, base, offset, orig_type,
 				      f == TYPE_FIELDS (record_type));
 if (t)
 return t;
-return maybe_fold_offset_to_component_ref (field_type, base, offset,
+return maybe_fold_offset_to_component_ref (loc, field_type, base, offset,
 					     orig_type);
 }
 /* Attempt to express (ORIG_TYPE)BASE+OFFSET as BASE->field_of_orig_type
 or BASE[index] or by combination of those.
+LOC is the location of original expression.
 Before attempting the conversion strip off existing ADDR_EXPRs and
 handled component refs.  */
 tree
-maybe_fold_offset_to_reference (tree base, tree offset, tree orig_type)
+maybe_fold_offset_to_reference (location_t loc, tree base, tree offset,
+				tree orig_type)
 {
 tree ret;
 tree type;
 STRIP_NOPS (base);
 	{
 	  base = newbase;
 	  if (sub_offset)
 	    offset = int_const_binop (PLUS_EXPR, offset,
 				      build_int_cst (TREE_TYPE (offset),
-					     sub_offset / BITS_PER_UNIT), 1);
+						     sub_offset / BITS_PER_UNIT), 1);
 	}
 }
 if (useless_type_conversion_p (orig_type, TREE_TYPE (base))
 && integer_zerop (offset))
 return base;
 type = TREE_TYPE (base);
-ret = maybe_fold_offset_to_component_ref (type, base, offset, orig_type);
+ret = maybe_fold_offset_to_component_ref (loc, type, base, offset, orig_type);
 if (!ret)
-ret = maybe_fold_offset_to_array_ref (base, offset, orig_type, true);
+ret = maybe_fold_offset_to_array_ref (loc, base, offset, orig_type, true);
 return ret;
 }
 /* Attempt to express (ORIG_TYPE)&BASE+OFFSET as &BASE->field_of_orig_type
 or &BASE[index] or by combination of those.
+LOC is the location of the original expression.
 Before attempting the conversion strip off existing component refs.  */
 tree
-maybe_fold_offset_to_address (tree addr, tree offset, tree orig_type)
+maybe_fold_offset_to_address (location_t loc, tree addr, tree offset,
+			      tree orig_type)
 {
 tree t;
 gcc_assert (POINTER_TYPE_P (TREE_TYPE (addr))
 	      && POINTER_TYPE_P (orig_type));
-t = maybe_fold_offset_to_reference (addr, offset, TREE_TYPE (orig_type));
+t = maybe_fold_offset_to_reference (loc, addr, offset,
+				      TREE_TYPE (orig_type));
 if (t != NULL_TREE)
 {
 tree orig = addr;
 tree ptr_type;
 	return NULL_TREE;
 ptr_type = build_pointer_type (TREE_TYPE (t));
 if (!useless_type_conversion_p (orig_type, ptr_type))
 	return NULL_TREE;
-return build_fold_addr_expr_with_type (t, ptr_type);
+return build_fold_addr_expr_with_type_loc (loc, t, ptr_type);
 }
 return NULL_TREE;
 }
-/* A subroutine of fold_stmt_r.  Attempt to simplify *(BASE+OFFSET).
+/* A subroutine of fold_stmt.  Attempt to simplify *(BASE+OFFSET).
 Return the simplified expression, or NULL if nothing could be done.  */
 static tree
 maybe_fold_stmt_indirect (tree expr, tree base, tree offset)
 {
 tree t;
 bool volatile_p = TREE_THIS_VOLATILE (expr);
+location_t loc = EXPR_LOCATION (expr);
 /* We may well have constructed a double-nested PLUS_EXPR via multiple
 substitutions.  Fold that down to one.  Remove NON_LVALUE_EXPRs that
 are sometimes added.  */
 base = fold (base);
 if (TREE_CODE (base) == CONST_DECL
 	  && is_gimple_min_invariant (DECL_INITIAL (base)))
 	return DECL_INITIAL (base);
 /* Try folding *(&B+O) to B.X.  */
-t = maybe_fold_offset_to_reference (base_addr, offset,
+t = maybe_fold_offset_to_reference (loc, base_addr, offset,
 					  TREE_TYPE (expr));
 if (t)
 	{
 	  /* Preserve volatileness of the original expression.
 	     We can end up with a plain decl here which is shared
 	  return t;
 	}
 }
 else
 {
 /* We can get here for out-of-range string constant accesses,
 	 such as "_"[3].  Bail out of the entire substitution search
 	 and arrange for the entire statement to be replaced by a
 	 call to __builtin_trap.  In all likelihood this will all be
 	 constant-folded away, but in the meantime we can't leave with
 	 something that get_expr_operands can't understand.  */
 STRIP_NOPS (t);
 if (TREE_CODE (t) == ADDR_EXPR
 	  && TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
 	{
 	  /* FIXME: Except that this causes problems elsewhere with dead
 	     code not being deleted, and we die in the rtl expanders
 	     because we failed to remove some ssa_name.  In the meantime,
 	     just return zero.  */
 	  /* FIXME2: This condition should be signaled by
 	     fold_read_from_constant_string directly, rather than
 	     re-checking for it here.  */
 	  return integer_zero_node;
 	}
 /* Try folding *(B+O) to B->X.  Still an improvement.  */
 if (POINTER_TYPE_P (TREE_TYPE (base)))
 	{
-t = maybe_fold_offset_to_reference (base, offset,
+t = maybe_fold_offset_to_reference (loc, base, offset,
 				              TREE_TYPE (expr));
 	  if (t)
 	    return t;
 	}
 }
 type of the POINTER_PLUS_EXPR.  We'd like to turn this into
 	&array[x]
 which may be able to propagate further.  */
 tree
-maybe_fold_stmt_addition (tree res_type, tree op0, tree op1)
+maybe_fold_stmt_addition (location_t loc, tree res_type, tree op0, tree op1)
 {
 tree ptd_type;
 tree t;
-/* It had better be a constant.  */
-if (TREE_CODE (op1) != INTEGER_CST)
-return NULL_TREE;
 /* The first operand should be an ADDR_EXPR.  */
 if (TREE_CODE (op0) != ADDR_EXPR)
 return NULL_TREE;
 op0 = TREE_OPERAND (op0, 0);
+/* It had better be a constant.  */
+if (TREE_CODE (op1) != INTEGER_CST)
+{
+/* Or op0 should now be A[0] and the non-constant offset defined
+	 via a multiplication by the array element size.  */
+if (TREE_CODE (op0) == ARRAY_REF
+	  && integer_zerop (TREE_OPERAND (op0, 1))
+	  && TREE_CODE (op1) == SSA_NAME
+	  && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (op0)), 1))
+	{
+	  gimple offset_def = SSA_NAME_DEF_STMT (op1);
+	  if (!is_gimple_assign (offset_def))
+	    return NULL_TREE;
+	  if (gimple_assign_rhs_code (offset_def) == MULT_EXPR
+	      && TREE_CODE (gimple_assign_rhs2 (offset_def)) == INTEGER_CST
+	      && tree_int_cst_equal (gimple_assign_rhs2 (offset_def),
+				     TYPE_SIZE_UNIT (TREE_TYPE (op0))))
+	    return build_fold_addr_expr
+			  (build4 (ARRAY_REF, TREE_TYPE (op0),
+				   TREE_OPERAND (op0, 0),
+				   gimple_assign_rhs1 (offset_def),
+				   TREE_OPERAND (op0, 2),
+				   TREE_OPERAND (op0, 3)));
+	  else if (integer_onep (TYPE_SIZE_UNIT (TREE_TYPE (op0)))
+		   && gimple_assign_rhs_code (offset_def) != MULT_EXPR)
+	    return build_fold_addr_expr
+			  (build4 (ARRAY_REF, TREE_TYPE (op0),
+				   TREE_OPERAND (op0, 0),
+				   op1,
+				   TREE_OPERAND (op0, 2),
+				   TREE_OPERAND (op0, 3)));
+	}
+return NULL_TREE;
+}
 /* If the first operand is an ARRAY_REF, expand it so that we can fold
 the offset into it.  */
 while (TREE_CODE (op0) == ARRAY_REF)
 {
 if (VOID_TYPE_P (ptd_type)
 && TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE)
 ptd_type = TREE_TYPE (TREE_TYPE (op0));
 /* At which point we can try some of the same things as for indirects.  */
-t = maybe_fold_offset_to_array_ref (op0, op1, ptd_type, true);
+t = maybe_fold_offset_to_array_ref (loc, op0, op1, ptd_type, true);
 if (!t)
-t = maybe_fold_offset_to_component_ref (TREE_TYPE (op0), op0, op1,
+t = maybe_fold_offset_to_component_ref (loc, TREE_TYPE (op0), op0, op1,
 					    ptd_type);
 if (t)
-t = build1 (ADDR_EXPR, res_type, t);
+{
+t = build1 (ADDR_EXPR, res_type, t);
+SET_EXPR_LOCATION (t, loc);
+}
 return t;
 }
-/* For passing state through walk_tree into fold_stmt_r and its
+/* Subroutine of fold_stmt.  We perform several simplifications of the
-children.  */
+memory reference tree EXPR and make sure to re-gimplify them properly
+after propagation of constant addresses.  IS_LHS is true if the
-struct fold_stmt_r_data
+reference is supposed to be an lvalue.  */
-{
-gimple stmt;
-bool *changed_p;
-bool *inside_addr_expr_p;
-};
-/* Subroutine of fold_stmt called via walk_tree.  We perform several
-simplifications of EXPR_P, mostly having to do with pointer arithmetic.  */
 static tree
-fold_stmt_r (tree *expr_p, int *walk_subtrees, void *data)
+maybe_fold_reference (tree expr, bool is_lhs)
 {
-struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
+tree *t = &expr;
-struct fold_stmt_r_data *fold_stmt_r_data;
-bool *inside_addr_expr_p;
+if (TREE_CODE (expr) == ARRAY_REF
-bool *changed_p;
+&& !is_lhs)
-tree expr = *expr_p, t;
+{
-bool volatile_p = TREE_THIS_VOLATILE (expr);
+tree tem = fold_read_from_constant_string (expr);
+if (tem)
-fold_stmt_r_data = (struct fold_stmt_r_data *) wi->info;
+	return tem;
-inside_addr_expr_p = fold_stmt_r_data->inside_addr_expr_p;
+}
-changed_p = fold_stmt_r_data->changed_p;
+/* ???  We might want to open-code the relevant remaining cases
-/* ??? It'd be nice if walk_tree had a pre-order option.  */
+to avoid using the generic fold.  */
-switch (TREE_CODE (expr))
+if (handled_component_p (*t)
-{
+&& CONSTANT_CLASS_P (TREE_OPERAND (*t, 0)))
-case INDIRECT_REF:
+{
-t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
+tree tem = fold (*t);
-if (t)
+if (tem != *t)
-	return t;
+	return tem;
-*walk_subtrees = 0;
+}
-t = maybe_fold_stmt_indirect (expr, TREE_OPERAND (expr, 0),
+while (handled_component_p (*t))
-				    integer_zero_node);
+t = &TREE_OPERAND (*t, 0);
+if (TREE_CODE (*t) == INDIRECT_REF)
+{
+tree tem = maybe_fold_stmt_indirect (*t, TREE_OPERAND (*t, 0),
+					   integer_zero_node);
 /* Avoid folding *"abc" = 5 into 'a' = 5.  */
-if (wi->is_lhs && t && TREE_CODE (t) == INTEGER_CST)
+if (is_lhs && tem && CONSTANT_CLASS_P (tem))
-	t = NULL_TREE;
+	tem = NULL_TREE;
-if (!t
+if (!tem
-	  && TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR)
+	  && TREE_CODE (TREE_OPERAND (*t, 0)) == ADDR_EXPR)
 	/* If we had a good reason for propagating the address here,
 	   make sure we end up with valid gimple.  See PR34989.  */
-	t = TREE_OPERAND (TREE_OPERAND (expr, 0), 0);
+	tem = TREE_OPERAND (TREE_OPERAND (*t, 0), 0);
-break;
+if (tem)
-case NOP_EXPR:
+	{
-t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
+	  *t = tem;
-if (t)
+	  tem = maybe_fold_reference (expr, is_lhs);
-	return t;
+	  if (tem)
-*walk_subtrees = 0;
+	    return tem;
+	  return expr;
-if (POINTER_TYPE_P (TREE_TYPE (expr))
+	}
-&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (expr)))
+}
-	  && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0)))
+else if (!is_lhs
-	  && (t = maybe_fold_offset_to_address (TREE_OPERAND (expr, 0),
+	   && DECL_P (*t))
-						integer_zero_node,
+{
-						TREE_TYPE (TREE_TYPE (expr)))))
+tree tem = get_symbol_constant_value (*t);
-	return t;
+if (tem)
-break;
+	{
+	  *t = tem;
-/* ??? Could handle more ARRAY_REFs here, as a variant of INDIRECT_REF.
+	  tem = maybe_fold_reference (expr, is_lhs);
-	 We'd only want to bother decomposing an existing ARRAY_REF if
+	  if (tem)
-	 the base array is found to have another offset contained within.
+	    return tem;
-	 Otherwise we'd be wasting time.  */
+	  return expr;
-case ARRAY_REF:
+	}
-/* If we are not processing expressions found within an
-	 ADDR_EXPR, then we can fold constant array references.
-	 Don't fold on LHS either, to avoid folding "abc"[0] = 5
-	 into 'a' = 5.  */
-if (!*inside_addr_expr_p && !wi->is_lhs)
-	t = fold_read_from_constant_string (expr);
-else
-	t = NULL;
-break;
-case ADDR_EXPR:
-*inside_addr_expr_p = true;
-t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
-*inside_addr_expr_p = false;
-if (t)
-	return t;
-*walk_subtrees = 0;
-/* Make sure the value is properly considered constant, and so gets
-	 propagated as expected.  */
-if (*changed_p)
-recompute_tree_invariant_for_addr_expr (expr);
-return NULL_TREE;
-case COMPONENT_REF:
-t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
-if (t)
-return t;
-*walk_subtrees = 0;
-/* Make sure the FIELD_DECL is actually a field in the type on the lhs.
-	 We've already checked that the records are compatible, so we should
-	 come up with a set of compatible fields.  */
-{
-	tree expr_record = TREE_TYPE (TREE_OPERAND (expr, 0));
-	tree expr_field = TREE_OPERAND (expr, 1);
-if (DECL_FIELD_CONTEXT (expr_field) != TYPE_MAIN_VARIANT (expr_record))
-	  {
-	    expr_field = find_compatible_field (expr_record, expr_field);
-	    TREE_OPERAND (expr, 1) = expr_field;
-	  }
-}
-break;
-case TARGET_MEM_REF:
-t = maybe_fold_tmr (expr);
-break;
-case POINTER_PLUS_EXPR:
-t = walk_tree (&TREE_OPERAND (expr, 0), fold_stmt_r, data, NULL);
-if (t)
-return t;
-t = walk_tree (&TREE_OPERAND (expr, 1), fold_stmt_r, data, NULL);
-if (t)
-return t;
-*walk_subtrees = 0;
-t = maybe_fold_stmt_addition (TREE_TYPE (expr),
-TREE_OPERAND (expr, 0),
-TREE_OPERAND (expr, 1));
-break;
-case COND_EXPR:
-if (COMPARISON_CLASS_P (TREE_OPERAND (expr, 0)))
-{
-	  tree op0 = TREE_OPERAND (expr, 0);
-tree tem;
-	  bool set;
-	  fold_defer_overflow_warnings ();
-	  tem = fold_binary (TREE_CODE (op0), TREE_TYPE (op0),
-			     TREE_OPERAND (op0, 0),
-			     TREE_OPERAND (op0, 1));
-/* This is actually a conditional expression, not a GIMPLE
-conditional statement, however, the valid_gimple_rhs_p
-test still applies.  */
-	  set = tem && is_gimple_condexpr (tem) && valid_gimple_rhs_p (tem);
-	  fold_undefer_overflow_warnings (set, fold_stmt_r_data->stmt, 0);
-	  if (set)
-	    {
-COND_EXPR_COND (expr) = tem;
-	      t = expr;
-	      break;
-	    }
-}
-return NULL_TREE;
-default:
-return NULL_TREE;
-}
-if (t)
-{
-/* Preserve volatileness of the original expression.
-	 We can end up with a plain decl here which is shared
-	 and we shouldn't mess with its flags.  */
-if (!SSA_VAR_P (t))
-	TREE_THIS_VOLATILE (t) = volatile_p;
-*expr_p = t;
-*changed_p = true;
 }
 return NULL_TREE;
 }
 /* Return the string length, maximum string length or maximum value of
 ARG in LENGTH.
 If ARG is an SSA name variable, follow its use-def chains.  If LENGTH
 is not NULL and, for TYPE == 0, its value is not equal to the length
 static bool
 get_maxval_strlen (tree arg, tree *length, bitmap visited, int type)
 {
 tree var, val;
 gimple def_stmt;
 if (TREE_CODE (arg) != SSA_NAME)
 {
 if (TREE_CODE (arg) == COND_EXPR)
 return get_maxval_strlen (COND_EXPR_THEN (arg), length, visited, type)
 && get_maxval_strlen (COND_EXPR_ELSE (arg), length, visited, type);
 if (!get_maxval_strlen (arg, length, visited, type))
 return false;
 }
 }
 return true;
 default:
 return false;
 }
 }
 tree callee, a;
 int arg_idx, type;
 bitmap visited;
 bool ignore;
 int nargs;
+location_t loc = gimple_location (stmt);
 gcc_assert (is_gimple_call (stmt));
 ignore = (gimple_call_lhs (stmt) == NULL);
 	}
 break;
 case BUILT_IN_STRCPY:
 if (val[1] && is_gimple_val (val[1]) && nargs == 2)
-	result = fold_builtin_strcpy (callee,
+	result = fold_builtin_strcpy (loc, callee,
 gimple_call_arg (stmt, 0),
 gimple_call_arg (stmt, 1),
 				      val[1]);
 break;
 case BUILT_IN_STRNCPY:
 if (val[1] && is_gimple_val (val[1]) && nargs == 3)
-	result = fold_builtin_strncpy (callee,
+	result = fold_builtin_strncpy (loc, callee,
 gimple_call_arg (stmt, 0),
 gimple_call_arg (stmt, 1),
 gimple_call_arg (stmt, 2),
 				       val[1]);
 break;
 case BUILT_IN_FPUTS:
 if (nargs == 2)
-	result = fold_builtin_fputs (gimple_call_arg (stmt, 0),
+	result = fold_builtin_fputs (loc, gimple_call_arg (stmt, 0),
 				     gimple_call_arg (stmt, 1),
 				     ignore, false, val[0]);
 break;
 case BUILT_IN_FPUTS_UNLOCKED:
 if (nargs == 2)
-	result = fold_builtin_fputs (gimple_call_arg (stmt, 0),
+	result = fold_builtin_fputs (loc, gimple_call_arg (stmt, 0),
 				     gimple_call_arg (stmt, 1),
 				     ignore, true, val[0]);
 break;
 case BUILT_IN_MEMCPY_CHK:
 case BUILT_IN_MEMPCPY_CHK:
 case BUILT_IN_MEMMOVE_CHK:
 case BUILT_IN_MEMSET_CHK:
 if (val[2] && is_gimple_val (val[2]) && nargs == 4)
-	result = fold_builtin_memory_chk (callee,
+	result = fold_builtin_memory_chk (loc, callee,
 gimple_call_arg (stmt, 0),
 gimple_call_arg (stmt, 1),
 gimple_call_arg (stmt, 2),
 gimple_call_arg (stmt, 3),
 					  val[2], ignore,
 break;
 case BUILT_IN_STRCPY_CHK:
 case BUILT_IN_STPCPY_CHK:
 if (val[1] && is_gimple_val (val[1]) && nargs == 3)
-	result = fold_builtin_stxcpy_chk (callee,
+	result = fold_builtin_stxcpy_chk (loc, callee,
 gimple_call_arg (stmt, 0),
 gimple_call_arg (stmt, 1),
 gimple_call_arg (stmt, 2),
 					  val[1], ignore,
 					  DECL_FUNCTION_CODE (callee));
 break;
 case BUILT_IN_STRNCPY_CHK:
 if (val[2] && is_gimple_val (val[2]) && nargs == 4)
-	result = fold_builtin_strncpy_chk (gimple_call_arg (stmt, 0),
+	result = fold_builtin_strncpy_chk (loc, gimple_call_arg (stmt, 0),
 gimple_call_arg (stmt, 1),
 gimple_call_arg (stmt, 2),
 gimple_call_arg (stmt, 3),
 					   val[2]);
 break;
 static tree
 fold_gimple_assign (gimple_stmt_iterator *si)
 {
 gimple stmt = gsi_stmt (*si);
 enum tree_code subcode = gimple_assign_rhs_code (stmt);
+location_t loc = gimple_location (stmt);
-tree result = NULL;
+tree result = NULL_TREE;
 switch (get_gimple_rhs_class (subcode))
 {
 case GIMPLE_SINGLE_RHS:
 {
 tree rhs = gimple_assign_rhs1 (stmt);
 /* Try to fold a conditional expression.  */
 if (TREE_CODE (rhs) == COND_EXPR)
 {
-tree temp = fold (COND_EXPR_COND (rhs));
+	    tree op0 = COND_EXPR_COND (rhs);
-if (temp != COND_EXPR_COND (rhs))
+	    tree tem;
-result = fold_build3 (COND_EXPR, TREE_TYPE (rhs), temp,
+	    bool set = false;
-COND_EXPR_THEN (rhs), COND_EXPR_ELSE (rhs));
+	    location_t cond_loc = EXPR_LOCATION (rhs);
+	    if (COMPARISON_CLASS_P (op0))
+	      {
+		fold_defer_overflow_warnings ();
+		tem = fold_binary_loc (cond_loc,
+				   TREE_CODE (op0), TREE_TYPE (op0),
+				   TREE_OPERAND (op0, 0),
+				   TREE_OPERAND (op0, 1));
+		/* This is actually a conditional expression, not a GIMPLE
+		   conditional statement, however, the valid_gimple_rhs_p
+		   test still applies.  */
+		set = (tem && is_gimple_condexpr (tem)
+		       && valid_gimple_rhs_p (tem));
+		fold_undefer_overflow_warnings (set, stmt, 0);
+	      }
+	    else if (is_gimple_min_invariant (op0))
+	      {
+		tem = op0;
+		set = true;
+	      }
+	    else
+	      return NULL_TREE;
+	    if (set)
+	      result = fold_build3_loc (cond_loc, COND_EXPR, TREE_TYPE (rhs), tem,
+				    COND_EXPR_THEN (rhs), COND_EXPR_ELSE (rhs));
 }
+	else if (TREE_CODE (rhs) == TARGET_MEM_REF)
+	  return maybe_fold_tmr (rhs);
+	else if (REFERENCE_CLASS_P (rhs))
+	  return maybe_fold_reference (rhs, false);
+	else if (TREE_CODE (rhs) == ADDR_EXPR)
+	  {
+	    tree tem = maybe_fold_reference (TREE_OPERAND (rhs, 0), true);
+	    if (tem)
+	      result = fold_convert (TREE_TYPE (rhs),
+				     build_fold_addr_expr_loc (loc, tem));
+	  }
+	else if (TREE_CODE (rhs) == CONSTRUCTOR
+		 && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE
+		 && (CONSTRUCTOR_NELTS (rhs)
+		     == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs))))
+	  {
+	    /* Fold a constant vector CONSTRUCTOR to VECTOR_CST.  */
+	    unsigned i;
+	    tree val;
+	    FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val)
+	      if (TREE_CODE (val) != INTEGER_CST
+		  && TREE_CODE (val) != REAL_CST
+		  && TREE_CODE (val) != FIXED_CST)
+		return NULL_TREE;
+	    return build_vector_from_ctor (TREE_TYPE (rhs),
+					   CONSTRUCTOR_ELTS (rhs));
+	  }
+	else if (DECL_P (rhs))
+	  return get_symbol_constant_value (rhs);
 /* If we couldn't fold the RHS, hand over to the generic
 fold routines.  */
 if (result == NULL_TREE)
 result = fold (rhs);
 /* Strip away useless type conversions.  Both the NON_LVALUE_EXPR
 that may have been added by fold, and "useless" type
 conversions that might now be apparent due to propagation.  */
 STRIP_USELESS_TYPE_CONVERSION (result);
 if (result != rhs && valid_gimple_rhs_p (result))
 	  return result;
-else
-/* It is possible that fold_stmt_r simplified the RHS.
+	return NULL_TREE;
-Make sure that the subcode of this statement still
-reflects the principal operator of the rhs operand. */
-return rhs;
 }
 break;
 case GIMPLE_UNARY_RHS:
 {
 	tree rhs = gimple_assign_rhs1 (stmt);
-	result = fold_unary (subcode, gimple_expr_type (stmt), rhs);
+	result = fold_unary_loc (loc, subcode, gimple_expr_type (stmt), rhs);
 	if (result)
 	  {
 	    /* If the operation was a conversion do _not_ mark a
 	       resulting constant with TREE_OVERFLOW if the original
 	       constant was not.  These conversions have implementation
 	else if (CONVERT_EXPR_CODE_P (subcode)
 		 && POINTER_TYPE_P (gimple_expr_type (stmt))
 		 && POINTER_TYPE_P (TREE_TYPE (gimple_assign_rhs1 (stmt))))
 	  {
 	    tree type = gimple_expr_type (stmt);
-	    tree t = maybe_fold_offset_to_address (gimple_assign_rhs1 (stmt),
+	    tree t = maybe_fold_offset_to_address (loc,
+						   gimple_assign_rhs1 (stmt),
 						   integer_zero_node, type);
 	    if (t)
 	      return t;
 	  }
 }
 	      type = build_pointer_type (TREE_TYPE (TREE_TYPE (type)));
 	      if (!useless_type_conversion_p
 		    (TREE_TYPE (gimple_assign_lhs (stmt)), type))
 		type = TREE_TYPE (gimple_assign_rhs1 (stmt));
 	    }
-	  result = maybe_fold_stmt_addition (type,
+	  result = maybe_fold_stmt_addition (gimple_location (stmt),
+					     type,
 					     gimple_assign_rhs1 (stmt),
 					     gimple_assign_rhs2 (stmt));
 	}
 if (!result)
-result = fold_binary (subcode,
+result = fold_binary_loc (loc, subcode,
 TREE_TYPE (gimple_assign_lhs (stmt)),
 gimple_assign_rhs1 (stmt),
 gimple_assign_rhs2 (stmt));
 if (result)
 assumed that the operands have been previously folded.  */
 static bool
 fold_gimple_cond (gimple stmt)
 {
-tree result = fold_binary (gimple_cond_code (stmt),
+tree result = fold_binary_loc (gimple_location (stmt),
+			     gimple_cond_code (stmt),
 boolean_type_node,
 gimple_cond_lhs (stmt),
 gimple_cond_rhs (stmt));
 if (result)
 }
 return false;
 }
+static void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree);
 /* Attempt to fold a call statement referenced by the statement iterator GSI.
 The statement may be replaced by another statement, e.g., if the call
 simplifies to a constant value. Return true if any changes were made.
 It is assumed that the operands have been previously folded.  */
 if (callee && DECL_BUILT_IN (callee))
 {
 tree result = ccp_fold_builtin (stmt);
 if (result)
-return update_call_from_tree (gsi, result);
+	{
+if (!update_call_from_tree (gsi, result))
+	    gimplify_and_update_call_from_tree (gsi, result);
+	  return true;
+	}
 }
 else
 {
 /* Check for resolvable OBJ_TYPE_REF.  The only sorts we can resolve
 here are when we've propagated the address of a decl into the
 }
 return false;
 }
-/* Fold the statement pointed to by GSI.  In some cases, this function may
+/* Worker for both fold_stmt and fold_stmt_inplace.  The INPLACE argument
-replace the whole statement with a new one.  Returns true iff folding
+distinguishes both cases.  */
-makes any changes.  */
+static bool
-bool
+fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace)
-fold_stmt (gimple_stmt_iterator *gsi)
+{
-{
-tree res;
-struct fold_stmt_r_data fold_stmt_r_data;
-struct walk_stmt_info wi;
 bool changed = false;
-bool inside_addr_expr = false;
 gimple stmt = gsi_stmt (*gsi);
+unsigned i;
-fold_stmt_r_data.stmt = stmt;
-fold_stmt_r_data.changed_p = &changed;
-fold_stmt_r_data.inside_addr_expr_p = &inside_addr_expr;
-memset (&wi, 0, sizeof (wi));
-wi.info = &fold_stmt_r_data;
-/* Fold the individual operands.
-For example, fold instances of *&VAR into VAR, etc.  */
-res = walk_gimple_op (stmt, fold_stmt_r, &wi);
-gcc_assert (!res);
 /* Fold the main computation performed by the statement.  */
 switch (gimple_code (stmt))
 {
 case GIMPLE_ASSIGN:
 {
+	unsigned old_num_ops = gimple_num_ops (stmt);
 	tree new_rhs = fold_gimple_assign (gsi);
-	if (new_rhs != NULL_TREE)
+	if (new_rhs != NULL_TREE
+	    && (!inplace
+		|| get_gimple_rhs_num_ops (TREE_CODE (new_rhs)) < old_num_ops))
 	  {
 	    gimple_assign_set_rhs_from_tree (gsi, new_rhs);
 	    changed = true;
 	  }
-	stmt = gsi_stmt (*gsi);
 	break;
 }
 case GIMPLE_COND:
 changed |= fold_gimple_cond (stmt);
 break;
 case GIMPLE_CALL:
+/* Fold *& in call arguments.  */
+for (i = 0; i < gimple_call_num_args (stmt); ++i)
+	if (REFERENCE_CLASS_P (gimple_call_arg (stmt, i)))
+	  {
+	    tree tmp = maybe_fold_reference (gimple_call_arg (stmt, i), false);
+	    if (tmp)
+	      {
+		gimple_call_set_arg (stmt, i, tmp);
+		changed = true;
+	      }
+	  }
 /* The entire statement may be replaced in this case.  */
-changed |= fold_gimple_call (gsi);
+if (!inplace)
+	changed |= fold_gimple_call (gsi);
 break;
-default:
+case GIMPLE_ASM:
-return changed;
+/* Fold *& in asm operands.  */
+for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
+	{
+	  tree link = gimple_asm_output_op (stmt, i);
+	  tree op = TREE_VALUE (link);
+	  if (REFERENCE_CLASS_P (op)
+	      && (op = maybe_fold_reference (op, true)) != NULL_TREE)
+	    {
+	      TREE_VALUE (link) = op;
+	      changed = true;
+	    }
+	}
+for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
+	{
+	  tree link = gimple_asm_input_op (stmt, i);
+	  tree op = TREE_VALUE (link);
+	  if (REFERENCE_CLASS_P (op)
+	      && (op = maybe_fold_reference (op, false)) != NULL_TREE)
+	    {
+	      TREE_VALUE (link) = op;
+	      changed = true;
+	    }
+	}
 break;
+default:;
+}
+stmt = gsi_stmt (*gsi);
+/* Fold *& on the lhs.  */
+if (gimple_has_lhs (stmt))
+{
+tree lhs = gimple_get_lhs (stmt);
+if (lhs && REFERENCE_CLASS_P (lhs))
+	{
+	  tree new_lhs = maybe_fold_reference (lhs, true);
+	  if (new_lhs)
+	    {
+	      gimple_set_lhs (stmt, new_lhs);
+	      changed = true;
+	    }
+	}
 }
 return changed;
+}
+/* Fold the statement pointed to by GSI.  In some cases, this function may
+replace the whole statement with a new one.  Returns true iff folding
+makes any changes.
+The statement pointed to by GSI should be in valid gimple form but may
+be in unfolded state as resulting from for example constant propagation
+which can produce *&x = 0.  */
+bool
+fold_stmt (gimple_stmt_iterator *gsi)
+{
+return fold_stmt_1 (gsi, false);
 }
 /* Perform the minimal folding on statement STMT.  Only operations like
 *&x created by constant propagation are handled.  The statement cannot
 be replaced with a new one.  Return true if the statement was
-changed, false otherwise.  */
+changed, false otherwise.
+The statement STMT should be in valid gimple form but may
+be in unfolded state as resulting from for example constant propagation
+which can produce *&x = 0.  */
 bool
 fold_stmt_inplace (gimple stmt)
 {
-tree res;
+gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
-struct fold_stmt_r_data fold_stmt_r_data;
+bool changed = fold_stmt_1 (&gsi, true);
-struct walk_stmt_info wi;
+gcc_assert (gsi_stmt (gsi) == stmt);
-gimple_stmt_iterator si;
-bool changed = false;
-bool inside_addr_expr = false;
-fold_stmt_r_data.stmt = stmt;
-fold_stmt_r_data.changed_p = &changed;
-fold_stmt_r_data.inside_addr_expr_p = &inside_addr_expr;
-memset (&wi, 0, sizeof (wi));
-wi.info = &fold_stmt_r_data;
-/* Fold the individual operands.
-For example, fold instances of *&VAR into VAR, etc.
-It appears that, at one time, maybe_fold_stmt_indirect
-would cause the walk to return non-null in order to
-signal that the entire statement should be replaced with
-a call to _builtin_trap.  This functionality is currently
-disabled, as noted in a FIXME, and cannot be supported here.  */
-res = walk_gimple_op (stmt, fold_stmt_r, &wi);
-gcc_assert (!res);
-/* Fold the main computation performed by the statement.  */
-switch (gimple_code (stmt))
-{
-case GIMPLE_ASSIGN:
-{
-	unsigned old_num_ops;
-	tree new_rhs;
-	old_num_ops = gimple_num_ops (stmt);
-	si = gsi_for_stmt (stmt);
-	new_rhs = fold_gimple_assign (&si);
-	if (new_rhs != NULL_TREE
-	    && get_gimple_rhs_num_ops (TREE_CODE (new_rhs)) < old_num_ops)
-	  {
-	    gimple_assign_set_rhs_from_tree (&si, new_rhs);
-	    changed = true;
-	  }
-	gcc_assert (gsi_stmt (si) == stmt);
-	break;
-}
-case GIMPLE_COND:
-changed |= fold_gimple_cond (stmt);
-break;
-default:
-break;
-}
 return changed;
 }
 /* Try to optimize out __builtin_stack_restore.  Optimize it out
 if there is another __builtin_stack_restore in the same basic
 ASM_EXPRs after this __builtin_stack_restore.  */
 static tree
 optimize_stack_restore (gimple_stmt_iterator i)
 {
-tree callee, rhs;
+tree callee;
-gimple stmt, stack_save;
+gimple stmt;
-gimple_stmt_iterator stack_save_gsi;
 basic_block bb = gsi_bb (i);
 gimple call = gsi_stmt (i);
 if (gimple_code (call) != GIMPLE_CALL
 callee = gimple_call_fndecl (stmt);
 if (!callee || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL)
 	return NULL_TREE;
 if (DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_RESTORE)
-	break;
+	goto second_stack_restore;
 }
-if (gsi_end_p (i)
+if (!gsi_end_p (i))
-&& (! single_succ_p (bb)
-	  || single_succ_edge (bb)->dest != EXIT_BLOCK_PTR))
 return NULL_TREE;
-stack_save = SSA_NAME_DEF_STMT (gimple_call_arg (call, 0));
+/* Allow one successor of the exit block, or zero successors.  */
-if (gimple_code (stack_save) != GIMPLE_CALL
+switch (EDGE_COUNT (bb->succs))
-|| gimple_call_lhs (stack_save) != gimple_call_arg (call, 0)
+{
-|| stmt_could_throw_p (stack_save)
+case 0:
-|| !has_single_use (gimple_call_arg (call, 0)))
+break;
-return NULL_TREE;
+case 1:
+if (single_succ_edge (bb)->dest != EXIT_BLOCK_PTR)
-callee = gimple_call_fndecl (stack_save);
+	return NULL_TREE;
-if (!callee
+break;
-|| DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
+default:
-|| DECL_FUNCTION_CODE (callee) != BUILT_IN_STACK_SAVE
-|| gimple_call_num_args (stack_save) != 0)
-return NULL_TREE;
-stack_save_gsi = gsi_for_stmt (stack_save);
-push_stmt_changes (gsi_stmt_ptr (&stack_save_gsi));
-rhs = build_int_cst (TREE_TYPE (gimple_call_arg (call, 0)), 0);
-if (!update_call_from_tree (&stack_save_gsi, rhs))
-{
-discard_stmt_changes (gsi_stmt_ptr (&stack_save_gsi));
 return NULL_TREE;
 }
-pop_stmt_changes (gsi_stmt_ptr (&stack_save_gsi));
+second_stack_restore:
+/* If there's exactly one use, then zap the call to __builtin_stack_save.
+If there are multiple uses, then the last one should remove the call.
+In any case, whether the call to __builtin_stack_save can be removed
+or not is irrelevant to removing the call to __builtin_stack_restore.  */
+if (has_single_use (gimple_call_arg (call, 0)))
+{
+gimple stack_save = SSA_NAME_DEF_STMT (gimple_call_arg (call, 0));
+if (is_gimple_call (stack_save))
+	{
+	  callee = gimple_call_fndecl (stack_save);
+	  if (callee
+	      && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
+	      && DECL_FUNCTION_CODE (callee) == BUILT_IN_STACK_SAVE)
+	    {
+	      gimple_stmt_iterator stack_save_gsi;
+	      tree rhs;
+	      stack_save_gsi = gsi_for_stmt (stack_save);
+	      rhs = build_int_cst (TREE_TYPE (gimple_call_arg (call, 0)), 0);
+	      update_call_from_tree (&stack_save_gsi, rhs);
+	    }
+	}
+}
 /* No effect, so the statement will be deleted.  */
 return integer_zero_node;
 }
 static tree
 optimize_stdarg_builtin (gimple call)
 {
 tree callee, lhs, rhs, cfun_va_list;
 bool va_list_simple_ptr;
+location_t loc = gimple_location (call);
 if (gimple_code (call) != GIMPLE_CALL)
 return NULL_TREE;
 callee = gimple_call_fndecl (call);
 lhs = gimple_call_arg (call, 0);
 if (!POINTER_TYPE_P (TREE_TYPE (lhs))
 	  || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs)))
 	     != TYPE_MAIN_VARIANT (cfun_va_list))
 	return NULL_TREE;
-lhs = build_fold_indirect_ref (lhs);
+lhs = build_fold_indirect_ref_loc (loc, lhs);
-rhs = build_call_expr (built_in_decls[BUILT_IN_NEXT_ARG],
+rhs = build_call_expr_loc (loc, built_in_decls[BUILT_IN_NEXT_ARG],
 1, integer_zero_node);
-rhs = fold_convert (TREE_TYPE (lhs), rhs);
+rhs = fold_convert_loc (loc, TREE_TYPE (lhs), rhs);
 return build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, rhs);
 case BUILT_IN_VA_COPY:
 if (!va_list_simple_ptr)
 	return NULL_TREE;
 if (!POINTER_TYPE_P (TREE_TYPE (lhs))
 	  || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs)))
 	     != TYPE_MAIN_VARIANT (cfun_va_list))
 	return NULL_TREE;
-lhs = build_fold_indirect_ref (lhs);
+lhs = build_fold_indirect_ref_loc (loc, lhs);
 rhs = gimple_call_arg (call, 1);
 if (TYPE_MAIN_VARIANT (TREE_TYPE (rhs))
 	  != TYPE_MAIN_VARIANT (cfun_va_list))
 	return NULL_TREE;
-rhs = fold_convert (TREE_TYPE (lhs), rhs);
+rhs = fold_convert_loc (loc, TREE_TYPE (lhs), rhs);
 return build2 (MODIFY_EXPR, TREE_TYPE (lhs), lhs, rhs);
 case BUILT_IN_VA_END:
 /* No effect, so the statement will be deleted.  */
 return integer_zero_node;
 push_gimplify_context (&gctx);
 if (lhs == NULL_TREE)
 gimplify_and_add (expr, &stmts);
 else
 tmp = get_initialized_tmp_var (expr, &stmts, NULL);
 pop_gimplify_context (NULL);
 if (gimple_has_location (stmt))
 mark_symbols_for_renaming (new_stmt);
 gsi_next (si_p);
 }
 if (lhs == NULL_TREE)
-new_stmt = gimple_build_nop ();
+{
+new_stmt = gimple_build_nop ();
+unlink_stmt_vdef (stmt);
+release_defs (stmt);
+}
 else
 {
 new_stmt = gimple_build_assign (lhs, tmp);
-copy_virtual_operands (new_stmt, stmt);
+gimple_set_vuse (new_stmt, gimple_vuse (stmt));
+gimple_set_vdef (new_stmt, gimple_vdef (stmt));
 move_ssa_defining_stmt_for_defs (new_stmt, stmt);
 }
 gimple_set_location (new_stmt, gimple_location (stmt));
 gsi_replace (si_p, new_stmt, false);
 execute_fold_all_builtins (void)
 {
 bool cfg_changed = false;
 basic_block bb;
 unsigned int todoflags = 0;
 FOR_EACH_BB (bb)
 {
 gimple_stmt_iterator i;
 for (i = gsi_start_bb (bb); !gsi_end_p (i); )
 	{
 	      fprintf (dump_file, "Simplified\n  ");
 	      print_gimple_stmt (dump_file, stmt, 0, dump_flags);
 	    }
 old_stmt = stmt;
-	  push_stmt_changes (gsi_stmt_ptr (&i));
 if (!update_call_from_tree (&i, result))
-{
+	    {
-gimplify_and_update_call_from_tree (&i, result);
+	      gimplify_and_update_call_from_tree (&i, result);
-todoflags |= TODO_rebuild_alias;
+	      todoflags |= TODO_update_address_taken;
-}
+	    }
 	  stmt = gsi_stmt (i);
-	  pop_stmt_changes (gsi_stmt_ptr (&i));
+	  update_stmt (stmt);
 	  if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt)
 	      && gimple_purge_dead_eh_edges (bb))
 	    cfg_changed = true;
 || DECL_BUILT_IN_CLASS (callee) != BUILT_IN_NORMAL
 	      || DECL_FUNCTION_CODE (callee) == fcode)
 	    gsi_next (&i);
 	}
 }
 /* Delete unreachable blocks.  */
 if (cfg_changed)
 todoflags |= TODO_cleanup_cfg;
 return todoflags;
 }
 struct gimple_opt_pass pass_fold_builtins =
 {
 {
 GIMPLE_PASS,
 "fab",				/* name */
 NULL,					/* gate */
 execute_fold_all_builtins,		/* execute */
 NULL,					/* sub */
 NULL,					/* next */
 0,					/* static_pass_number */
-0,					/* tv_id */
+TV_NONE,				/* tv_id */
 PROP_cfg | PROP_ssa,			/* properties_required */
 0,					/* properties_provided */
 0,					/* properties_destroyed */
 0,					/* todo_flags_start */
 TODO_dump_func

Mercurial > hg > CbC > CbC_gcc

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