CbC/CbC_gcc: gcc/tree-scalar-evolution.c comparison

comparison gcc/tree-scalar-evolution.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	84e7813d76e9
children	1830386684a0

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* Scalar evolution detector.
-Copyright (C) 2003-2017 Free Software Foundation, Inc.
+Copyright (C) 2003-2018 Free Software Foundation, Inc.
 Contributed by Sebastian Pop <s.pop@laposte.net>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "tree-scalar-evolution.h"
 #include "dumpfile.h"
 #include "params.h"
 #include "tree-ssa-propagate.h"
 #include "gimple-fold.h"
+#include "tree-into-ssa.h"
+#include "builtins.h"
 static tree analyze_scalar_evolution_1 (struct loop *, tree);
 static tree analyze_scalar_evolution_for_address_of (struct loop *loop,
 						     tree var);
 static tree
 follow_copies_to_constant (tree var)
 {
 tree res = var;
-while (TREE_CODE (res) == SSA_NAME)
+while (TREE_CODE (res) == SSA_NAME
+	 /* We face not updated SSA form in multiple places and this walk
+	    may end up in sibling loops so we have to guard it.  */
+	 && !name_registered_for_update_p (res))
 {
 gimple *def = SSA_NAME_DEF_STMT (res);
 if (gphi *phi = dyn_cast <gphi *> (def))
 	{
 	  if (tree rhs = degenerate_phi_result (phi))
 case ADDR_EXPR:
 if (TREE_CODE (TREE_OPERAND (rhs1, 0)) == MEM_REF
 	  || handled_component_p (TREE_OPERAND (rhs1, 0)))
 {
 	  machine_mode mode;
-	  HOST_WIDE_INT bitsize, bitpos;
+	  poly_int64 bitsize, bitpos;
 	  int unsignedp, reversep;
 	  int volatilep = 0;
 	  tree base, offset;
 	  tree chrec3;
 	  tree unitpos;
 	      chrec2 = chrec_convert (TREE_TYPE (offset), chrec2, at_stmt);
 	      chrec2 = instantiate_parameters (loop, chrec2);
 	      res = chrec_fold_plus (type, res, chrec2);
 	    }
-	  if (bitpos != 0)
+	  if (maybe_ne (bitpos, 0))
 	    {
-	      gcc_assert ((bitpos % BITS_PER_UNIT) == 0);
+	      unitpos = size_int (exact_div (bitpos, BITS_PER_UNIT));
-	      unitpos = size_int (bitpos / BITS_PER_UNIT);
 	      chrec3 = analyze_scalar_evolution (loop, unitpos);
 	      chrec3 = chrec_convert (TREE_TYPE (unitpos), chrec3, at_stmt);
 	      chrec3 = instantiate_parameters (loop, chrec3);
 	      res = chrec_fold_plus (type, res, chrec3);
 	    }
 if (automatically_generated_chrec_p (expr))
 return expr;
 if (TREE_CODE (expr) == POLYNOMIAL_CHREC
+|| TREE_CODE (expr) == CALL_EXPR
 || get_gimple_rhs_class (TREE_CODE (expr)) == GIMPLE_TERNARY_RHS)
 return chrec_dont_know;
 extract_ops_from_tree (expr, &code, &op0, &op1);
 In this case the arithmetics bellow would overflow.  */
 gcc_checking_assert (wi::ge_p (base_min, type_min, sgn)
 		       && wi::le_p (base_max, type_max, sgn));
 /* Account the possible increment in the last ieration.  */
-bool overflow = false;
+wi::overflow_type overflow = wi::OVF_NONE;
 nit = wi::add (nit, 1, SIGNED, &overflow);
 if (overflow)
 return true;
 /* NIT is typeless and can exceed the precision of the type.  In this case
 This can be done by unsigned arithmetic and we only need to watch overflow
 in the multiplication. The right hand side can always be represented in
 the type.  */
 if (sgn == UNSIGNED || !wi::neg_p (step_max))
 {
-bool overflow = false;
+wi::overflow_type overflow = wi::OVF_NONE;
 if (wi::gtu_p (wi::mul (step_max, nit2, UNSIGNED, &overflow),
 		     type_max - base_max)
 	  || overflow)
 	return true;
 }
 /* If step can be negative, check that nit*(-step) <= base_min-type_min.  */
 if (sgn == SIGNED && wi::neg_p (step_min))
 {
-bool overflow = false, overflow2 = false;
+wi::overflow_type overflow, overflow2;
+overflow = overflow2 = wi::OVF_NONE;
 if (wi::gtu_p (wi::mul (wi::neg (step_min, &overflow2),
 		     nit2, UNSIGNED, &overflow),
 		     base_min - type_min)
 	  || overflow || overflow2)
 return true;
 		       bool allow_nonconstant_step)
 {
 enum tree_code code;
 tree type, ev, base, e;
 wide_int extreme;
-bool folded_casts, overflow;
+bool folded_casts;
 iv->base = NULL_TREE;
 iv->step = NULL_TREE;
 iv->no_overflow = false;
 else
 {
 code = GT_EXPR;
 extreme = wi::max_value (type);
 }
-overflow = false;
+wi::overflow_type overflow = wi::OVF_NONE;
 extreme = wi::sub (extreme, wi::to_wide (iv->step),
 		     TYPE_SIGN (type), &overflow);
 if (overflow)
 return true;
 e = fold_build2 (code, boolean_type_node, base,
 /* Division by power of two is usually cheap, so we allow it.
 	 Forbid anything else.  */
 if (!integer_pow2p (TREE_OPERAND (expr, 1)))
 	return true;
 }
+if (code == CALL_EXPR)
+{
+tree arg;
+call_expr_arg_iterator iter;
+if (!is_inexpensive_builtin (get_callee_fndecl (expr)))
+	return true;
+FOR_EACH_CALL_EXPR_ARG (arg, iter, expr)
+	if (expression_expensive_p (arg))
+	  return true;
+return false;
+}
+if (code == COND_EXPR)
+return (expression_expensive_p (TREE_OPERAND (expr, 0))
+	    || (EXPR_P (TREE_OPERAND (expr, 1))
+		&& EXPR_P (TREE_OPERAND (expr, 2)))
+	    /* If either branch has side effects or could trap.  */
+	    || TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
+	    || generic_expr_could_trap_p (TREE_OPERAND (expr, 1))
+	    || TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0))
+	    || generic_expr_could_trap_p (TREE_OPERAND (expr, 0))
+	    || expression_expensive_p (TREE_OPERAND (expr, 1))
+	    || expression_expensive_p (TREE_OPERAND (expr, 2)));
 switch (TREE_CODE_CLASS (code))
 {
 case tcc_binary:
 case tcc_comparison:
 	 the loop.  */
 if (dump_file)
 	{
 	  fprintf (dump_file, "\nfinal value replacement:\n  ");
 	  print_gimple_stmt (dump_file, phi, 0);
-	  fprintf (dump_file, "  with\n  ");
+	  fprintf (dump_file, " with expr: ");
+	  print_generic_expr (dump_file, def);
 	}
 def = unshare_expr (def);
 remove_phi_node (&psi, false);
 /* If def's type has undefined overflow and there were folded
 gassign *ass = gimple_build_assign (rslt, def);
 gsi_insert_before (&gsi, ass, GSI_SAME_STMT);
 if (dump_file)
 	{
+	  fprintf (dump_file, "\n final stmt:\n  ");
 	  print_gimple_stmt (dump_file, ass, 0);
 	  fprintf (dump_file, "\n");
 	}
 }
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-scalar-evolution.c @ 132:d34655255c78