CbC/CbC_gcc: gcc/ipa-fnsummary.c comparison

comparison gcc/ipa-fnsummary.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Function summary pass.
-Copyright (C) 2003-2018 Free Software Foundation, Inc.
+Copyright (C) 2003-2020 Free Software Foundation, Inc.
 Contributed by Jan Hubicka
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 #include "diagnostic.h"
 #include "fold-const.h"
 #include "print-tree.h"
 #include "tree-inline.h"
 #include "gimple-pretty-print.h"
-#include "params.h"
 #include "cfganal.h"
 #include "gimple-iterator.h"
 #include "tree-cfg.h"
 #include "tree-ssa-loop-niter.h"
 #include "tree-ssa-loop.h"
 #include "ipa-utils.h"
 #include "cfgexpand.h"
 #include "gimplify.h"
 #include "stringpool.h"
 #include "attribs.h"
+#include "tree-into-ssa.h"
 /* Summaries.  */
-function_summary <ipa_fn_summary *> *ipa_fn_summaries;
+fast_function_summary <ipa_fn_summary *, va_gc> *ipa_fn_summaries;
-call_summary <ipa_call_summary *> *ipa_call_summaries;
+fast_function_summary <ipa_size_summary *, va_heap> *ipa_size_summaries;
+fast_call_summary <ipa_call_summary *, va_heap> *ipa_call_summaries;
 /* Edge predicates goes here.  */
 static object_allocator<predicate> edge_predicate_pool ("edge predicates");
 if (hints & INLINE_HINT_declared_inline)
 {
 hints &= ~INLINE_HINT_declared_inline;
 fprintf (f, " declared_inline");
 }
-if (hints & INLINE_HINT_array_index)
-{
-hints &= ~INLINE_HINT_array_index;
-fprintf (f, " array_index");
-}
 if (hints & INLINE_HINT_known_hot)
 {
 hints &= ~INLINE_HINT_known_hot;
 fprintf (f, " known_hot");
 }
 }
 /* Record SIZE and TIME to SUMMARY.
 The accounted code will be executed when EXEC_PRED is true.
-When NONCONST_PRED is false the code will evaulate to constant and
+When NONCONST_PRED is false the code will evaluate to constant and
-will get optimized out in specialized clones of the function.   */
+will get optimized out in specialized clones of the function.
+If CALL is true account to call_size_time_table rather than
+size_time_table.   */
 void
 ipa_fn_summary::account_size_time (int size, sreal time,
 				   const predicate &exec_pred,
-				   const predicate &nonconst_pred_in)
+				   const predicate &nonconst_pred_in,
+				   bool call)
 {
 size_time_entry *e;
 bool found = false;
 int i;
 predicate nonconst_pred;
+vec<size_time_entry, va_gc> *table = call
+	 			       ? call_size_time_table : size_time_table;
 if (exec_pred == false)
 return;
 nonconst_pred = nonconst_pred_in & exec_pred;
 if (nonconst_pred == false)
 return;
-/* We need to create initial empty unconitional clause, but otherwie
+/* We need to create initial empty unconditional clause, but otherwise
 we don't need to account empty times and sizes.  */
-if (!size && time == 0 && size_time_table)
+if (!size && time == 0 && table)
 return;
-gcc_assert (time >= 0);
+/* Only for calls we are unaccounting what we previously recorded.  */
+gcc_checking_assert (time >= 0 || call);
-for (i = 0; vec_safe_iterate (size_time_table, i, &e); i++)
+for (i = 0; vec_safe_iterate (table, i, &e); i++)
 if (e->exec_predicate == exec_pred
 	&& e->nonconst_predicate == nonconst_pred)
 {
 	found = true;
 	break;
 }
-if (i == 256)
+if (i == max_size_time_table_size)
 {
 i = 0;
 found = true;
-e = &(*size_time_table)[0];
+e = &(*table)[0];
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file,
 		 "\t\tReached limit on number of entries, "
 		 "ignoring the predicate.");
 }
 else
 fprintf (dump_file, "\n");
 }
 if (!found)
 {
-struct size_time_entry new_entry;
+class size_time_entry new_entry;
 new_entry.size = size;
 new_entry.time = time;
 new_entry.exec_predicate = exec_pred;
 new_entry.nonconst_predicate = nonconst_pred;
-vec_safe_push (size_time_table, new_entry);
+if (call)
+vec_safe_push (call_size_time_table, new_entry);
+else
+vec_safe_push (size_time_table, new_entry);
 }
 else
 {
 e->size += size;
 e->time += time;
-}
+/* FIXME: PR bootstrap/92653 gcc_checking_assert (e->time >= -1); */
-}
+/* Tolerate small roundoff issues.  */
+if (e->time < 0)
-/* We proved E to be unreachable, redirect it to __bultin_unreachable.  */
+	e->time = 0;
+}
+}
+/* We proved E to be unreachable, redirect it to __builtin_unreachable.  */
 static struct cgraph_edge *
 redirect_to_unreachable (struct cgraph_edge *e)
 {
 struct cgraph_node *callee = !e->inline_failed ? e->callee : NULL;
 struct cgraph_node *target = cgraph_node::get_create
 		      (builtin_decl_implicit (BUILT_IN_UNREACHABLE));
 if (e->speculative)
-e = e->resolve_speculation (target->decl);
+e = cgraph_edge::resolve_speculation (e, target->decl);
 else if (!e->callee)
-e->make_direct (target);
+e = cgraph_edge::make_direct (e, target);
 else
 e->redirect_callee (target);
-struct ipa_call_summary *es = ipa_call_summaries->get (e);
+class ipa_call_summary *es = ipa_call_summaries->get (e);
 e->inline_failed = CIF_UNREACHABLE;
 e->count = profile_count::zero ();
 es->call_stmt_size = 0;
 es->call_stmt_time = 0;
 if (callee)
 just once.  Do it always on the direct edge, so we do not
 	 attempt to resolve speculation while duplicating the edge.  */
 && (!e->speculative || e->callee))
 e = redirect_to_unreachable (e);
-struct ipa_call_summary *es = ipa_call_summaries->get (e);
+class ipa_call_summary *es = ipa_call_summaries->get (e);
 if (predicate && *predicate != true)
 {
 if (!es->predicate)
 	es->predicate = edge_predicate_pool.allocate ();
 *es->predicate = *predicate;
 **p = new_predicate;
 }
 }
-/* Compute what conditions may or may not hold given invormation about
+/* Compute what conditions may or may not hold given information about
 parameters.  RET_CLAUSE returns truths that may hold in a specialized copy,
-whie RET_NONSPEC_CLAUSE returns truths that may hold in an nonspecialized
+while RET_NONSPEC_CLAUSE returns truths that may hold in an nonspecialized
 copy when called in a given context.  It is a bitmask of conditions. Bit
 0 means that condition is known to be false, while bit 1 means that condition
 may or may not be true.  These differs - for example NOT_INLINED condition
-is always false in the second and also builtin_constant_p tests can not use
+is always false in the second and also builtin_constant_p tests cannot use
 the fact that parameter is indeed a constant.
 KNOWN_VALS is partial mapping of parameters of NODE to constant values.
-KNOWN_AGGS is a vector of aggreggate jump functions for each parameter.
+KNOWN_AGGS is a vector of aggregate known offset/value set for each
-Return clause of possible truths. When INLINE_P is true, assume that we are
+parameter.  Return clause of possible truths.  When INLINE_P is true, assume
-inlining.
+that we are inlining.
 ERROR_MARK means compile time invariant.  */
 static void
 evaluate_conditions_for_known_args (struct cgraph_node *node,
 				    bool inline_p,
 				    vec<tree> known_vals,
-				    vec<ipa_agg_jump_function_p>
+				    vec<value_range> known_value_ranges,
-				    known_aggs,
+				    vec<ipa_agg_value_set> known_aggs,
 				    clause_t *ret_clause,
 				    clause_t *ret_nonspec_clause)
 {
 clause_t clause = inline_p ? 0 : 1 << predicate::not_inlined_condition;
 clause_t nonspec_clause = 1 << predicate::not_inlined_condition;
-struct ipa_fn_summary *info = ipa_fn_summaries->get (node);
+class ipa_fn_summary *info = ipa_fn_summaries->get (node);
 int i;
 struct condition *c;
 for (i = 0; vec_safe_iterate (info->conds, i, &c); i++)
 {
-tree val;
+tree val = NULL;
 tree res;
+int j;
+struct expr_eval_op *op;
 /* We allow call stmt to have fewer arguments than the callee function
 (especially for K&R style programs).  So bound check here (we assume
 known_aggs vector, if non-NULL, has the same length as
 known_vals).  */
-gcc_checking_assert (!known_aggs.exists ()
+gcc_checking_assert (!known_aggs.length () || !known_vals.length ()
 			   || (known_vals.length () == known_aggs.length ()));
-if (c->operand_num >= (int) known_vals.length ())
+if (c->agg_contents)
+	{
+	  struct ipa_agg_value_set *agg;
+	  if (c->code == predicate::changed
+	      && !c->by_ref
+	      && c->operand_num < (int)known_vals.length ()
+	      && (known_vals[c->operand_num] == error_mark_node))
+	    continue;
+	  if (c->operand_num < (int)known_aggs.length ())
+	    {
+	      agg = &known_aggs[c->operand_num];
+	      val = ipa_find_agg_cst_for_param (agg,
+						c->operand_num
+						   < (int) known_vals.length ()
+						? known_vals[c->operand_num]
+						: NULL,
+						c->offset, c->by_ref);
+	    }
+	  else
+	    val = NULL_TREE;
+	}
+else if (c->operand_num < (int) known_vals.length ())
+	{
+	  val = known_vals[c->operand_num];
+	  if (val == error_mark_node && c->code != predicate::changed)
+	    val = NULL_TREE;
+	}
+if (!val
+	  && (c->code == predicate::changed
+	      || c->code == predicate::is_not_constant))
 	{
 	  clause |= 1 << (i + predicate::first_dynamic_condition);
 	  nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
 	  continue;
 	}
+if (c->code == predicate::changed)
-if (c->agg_contents)
+	{
-	{
-	  struct ipa_agg_jump_function *agg;
-	  if (c->code == predicate::changed
-	      && !c->by_ref
-	      && (known_vals[c->operand_num] == error_mark_node))
-	    continue;
-	  if (known_aggs.exists ())
-	    {
-	      agg = known_aggs[c->operand_num];
-	      val = ipa_find_agg_cst_for_param (agg, known_vals[c->operand_num],
-						c->offset, c->by_ref);
-	    }
-	  else
-	    val = NULL_TREE;
-	}
-else
-	{
-	  val = known_vals[c->operand_num];
-	  if (val == error_mark_node && c->code != predicate::changed)
-	    val = NULL_TREE;
-	}
-if (!val)
-	{
-	  clause |= 1 << (i + predicate::first_dynamic_condition);
 	  nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
 	  continue;
 	}
-if (c->code == predicate::changed)
+if (c->code == predicate::is_not_constant)
 	{
 	  nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
 	  continue;
 	}
-if (tree_to_shwi (TYPE_SIZE (TREE_TYPE (val))) != c->size)
+if (val && TYPE_SIZE (c->type) == TYPE_SIZE (TREE_TYPE (val)))
 	{
-	  clause |= 1 << (i + predicate::first_dynamic_condition);
+	  if (c->type != TREE_TYPE (val))
-	  nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
+	    val = fold_unary (VIEW_CONVERT_EXPR, c->type, val);
-	  continue;
+	  for (j = 0; vec_safe_iterate (c->param_ops, j, &op); j++)
-	}
+	    {
-if (c->code == predicate::is_not_constant)
+	      if (!val)
-	{
+		break;
-	  nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
+	      if (!op->val[0])
-	  continue;
+		val = fold_unary (op->code, op->type, val);
-	}
+	      else if (!op->val[1])
+		val = fold_binary (op->code, op->type,
-val = fold_unary (VIEW_CONVERT_EXPR, TREE_TYPE (c->val), val);
+				   op->index ? op->val[0] : val,
-res = val
+				   op->index ? val : op->val[0]);
-	? fold_binary_to_constant (c->code, boolean_type_node, val, c->val)
+	      else if (op->index == 0)
-	: NULL;
+		val = fold_ternary (op->code, op->type,
+				    val, op->val[0], op->val[1]);
-if (res && integer_zerop (res))
+	      else if (op->index == 1)
-	continue;
+		val = fold_ternary (op->code, op->type,
+				    op->val[0], val, op->val[1]);
+	      else if (op->index == 2)
+		val = fold_ternary (op->code, op->type,
+				    op->val[0], op->val[1], val);
+	      else
+		val = NULL_TREE;
+	    }
+	  res = val
+	    ? fold_binary_to_constant (c->code, boolean_type_node, val, c->val)
+	    : NULL;
+	  if (res && integer_zerop (res))
+	    continue;
+	  if (res && integer_onep (res))
+	    {
+	      clause |= 1 << (i + predicate::first_dynamic_condition);
+	      nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
+	      continue;
+	    }
+	}
+if (c->operand_num < (int) known_value_ranges.length ()
+	  && !c->agg_contents
+	  && !known_value_ranges[c->operand_num].undefined_p ()
+	  && !known_value_ranges[c->operand_num].varying_p ()
+	  && TYPE_SIZE (c->type)
+		 == TYPE_SIZE (known_value_ranges[c->operand_num].type ())
+	  && (!val || TREE_CODE (val) != INTEGER_CST))
+	{
+	  value_range vr = known_value_ranges[c->operand_num];
+	  if (!useless_type_conversion_p (c->type, vr.type ()))
+	    {
+	      value_range res;
+	      range_fold_unary_expr (&res, NOP_EXPR,
+				     c->type, &vr, vr.type ());
+	      vr = res;
+	    }
+	  tree type = c->type;
+	  for (j = 0; vec_safe_iterate (c->param_ops, j, &op); j++)
+	    {
+	      if (vr.varying_p () || vr.undefined_p ())
+		break;
+	      value_range res;
+	      if (!op->val[0])
+	        range_fold_unary_expr (&res, op->code, op->type, &vr, type);
+	      else if (!op->val[1])
+		{
+		  value_range op0 (op->val[0], op->val[0]);
+		  range_fold_binary_expr (&res, op->code, op->type,
+					  op->index ? &op0 : &vr,
+					  op->index ? &vr : &op0);
+		}
+	      else
+		gcc_unreachable ();
+	      type = op->type;
+	      vr = res;
+	    }
+	  if (!vr.varying_p () && !vr.undefined_p ())
+	    {
+	      value_range res;
+	      value_range val_vr (c->val, c->val);
+	      range_fold_binary_expr (&res, c->code, boolean_type_node,
+				      &vr,
+				      &val_vr);
+	      if (res.zero_p ())
+		continue;
+	    }
+	}
 clause |= 1 << (i + predicate::first_dynamic_condition);
 nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
 }
 *ret_clause = clause;
 if (ret_nonspec_clause)
 *ret_nonspec_clause = nonspec_clause;
 }
-/* Work out what conditions might be true at invocation of E.  */
+/* Work out what conditions might be true at invocation of E.
+Compute costs for inlined edge if INLINE_P is true.
+Return in CLAUSE_PTR the evaluated conditions and in NONSPEC_CLAUSE_PTR
+(if non-NULL) conditions evaluated for nonspecialized clone called
+in a given context.
+KNOWN_VALS_PTR and KNOWN_AGGS_PTR must be non-NULL and will be filled by
+known constant and aggregate values of parameters.
+KNOWN_CONTEXT_PTR, if non-NULL, will be filled by polymorphic call contexts
+of parameter used by a polymorphic call.  */
 void
 evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
 			      clause_t *clause_ptr,
 			      clause_t *nonspec_clause_ptr,
 			      vec<tree> *known_vals_ptr,
 			      vec<ipa_polymorphic_call_context>
 			      *known_contexts_ptr,
-			      vec<ipa_agg_jump_function_p> *known_aggs_ptr)
+			      vec<ipa_agg_value_set> *known_aggs_ptr)
 {
 struct cgraph_node *callee = e->callee->ultimate_alias_target ();
-struct ipa_fn_summary *info = ipa_fn_summaries->get (callee);
+class ipa_fn_summary *info = ipa_fn_summaries->get (callee);
-vec<tree> known_vals = vNULL;
+auto_vec<value_range, 32> known_value_ranges;
-vec<ipa_agg_jump_function_p> known_aggs = vNULL;
+class ipa_edge_args *args;
 if (clause_ptr)
 *clause_ptr = inline_p ? 0 : 1 << predicate::not_inlined_condition;
-if (known_vals_ptr)
-known_vals_ptr->create (0);
-if (known_contexts_ptr)
-known_contexts_ptr->create (0);
 if (ipa_node_params_sum
 && !e->call_stmt_cannot_inline_p
-&& ((clause_ptr && info->conds) || known_vals_ptr || known_contexts_ptr))
+&& (info->conds || known_contexts_ptr)
-{
+&& (args = IPA_EDGE_REF (e)) != NULL)
-struct ipa_node_params *caller_parms_info, *callee_pi;
+{
-struct ipa_edge_args *args = IPA_EDGE_REF (e);
+struct cgraph_node *caller;
-struct ipa_call_summary *es = ipa_call_summaries->get (e);
+class ipa_node_params *caller_parms_info, *callee_pi = NULL;
+class ipa_call_summary *es = ipa_call_summaries->get (e);
 int i, count = ipa_get_cs_argument_count (args);
-if (e->caller->global.inlined_to)
+if (count)
-	caller_parms_info = IPA_NODE_REF (e->caller->global.inlined_to);
+	{
-else
+	  if (e->caller->inlined_to)
-	caller_parms_info = IPA_NODE_REF (e->caller);
+	    caller = e->caller->inlined_to;
-callee_pi = IPA_NODE_REF (e->callee);
+	  else
+	    caller = e->caller;
-if (count && (info->conds || known_vals_ptr))
+	  caller_parms_info = IPA_NODE_REF (caller);
-	known_vals.safe_grow_cleared (count);
+callee_pi = IPA_NODE_REF (callee);
-if (count && (info->conds || known_aggs_ptr))
-	known_aggs.safe_grow_cleared (count);
+	  /* Watch for thunks.  */
-if (count && known_contexts_ptr)
+	  if (callee_pi)
-	known_contexts_ptr->safe_grow_cleared (count);
+	    /* Watch for variadic functions.  */
+	    count = MIN (count, ipa_get_param_count (callee_pi));
-for (i = 0; i < count; i++)
+	}
-	{
-	  struct ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);
+if (callee_pi)
-	  tree cst = ipa_value_from_jfunc (caller_parms_info, jf,
+	for (i = 0; i < count; i++)
-					   ipa_get_type (callee_pi, i));
+	  {
+	    struct ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);
-	  if (!cst && e->call_stmt
-	      && i < (int)gimple_call_num_args (e->call_stmt))
+	    if (ipa_is_param_used_by_indirect_call (callee_pi, i)
-	    {
+		|| ipa_is_param_used_by_ipa_predicates (callee_pi, i))
-	      cst = gimple_call_arg (e->call_stmt, i);
+	      {
-	      if (!is_gimple_min_invariant (cst))
+		/* Determine if we know constant value of the parameter.  */
-		cst = NULL;
+		tree cst = ipa_value_from_jfunc (caller_parms_info, jf,
-	    }
+						 ipa_get_type (callee_pi, i));
-	  if (cst)
-	    {
+		if (!cst && e->call_stmt
-	      gcc_checking_assert (TREE_CODE (cst) != TREE_BINFO);
+		    && i < (int)gimple_call_num_args (e->call_stmt))
-	      if (known_vals.exists ())
+		  {
-		known_vals[i] = cst;
+		    cst = gimple_call_arg (e->call_stmt, i);
-	    }
+		    if (!is_gimple_min_invariant (cst))
-	  else if (inline_p && !es->param[i].change_prob)
+		      cst = NULL;
-	    known_vals[i] = error_mark_node;
+		  }
+		if (cst)
-	  if (known_contexts_ptr)
+		  {
-	    (*known_contexts_ptr)[i]
+		    gcc_checking_assert (TREE_CODE (cst) != TREE_BINFO);
-	      = ipa_context_from_jfunc (caller_parms_info, e, i, jf);
+		    if (!known_vals_ptr->length ())
-	  /* TODO: When IPA-CP starts propagating and merging aggregate jump
+		      vec_safe_grow_cleared (known_vals_ptr, count);
-	     functions, use its knowledge of the caller too, just like the
+		    (*known_vals_ptr)[i] = cst;
-	     scalar case above.  */
+		  }
-	  known_aggs[i] = &jf->agg;
+		else if (inline_p && !es->param[i].change_prob)
-	}
+		  {
-}
+		    if (!known_vals_ptr->length ())
-else if (e->call_stmt && !e->call_stmt_cannot_inline_p
+		      vec_safe_grow_cleared (known_vals_ptr, count);
-	   && ((clause_ptr && info->conds) || known_vals_ptr))
+		    (*known_vals_ptr)[i] = error_mark_node;
+		  }
+		/* If we failed to get simple constant, try value range.  */
+		if ((!cst || TREE_CODE (cst) != INTEGER_CST)
+		    && ipa_is_param_used_by_ipa_predicates (callee_pi, i))
+		  {
+		    value_range vr
+		       = ipa_value_range_from_jfunc (caller_parms_info, e, jf,
+						     ipa_get_type (callee_pi,
+								   i));
+		    if (!vr.undefined_p () && !vr.varying_p ())
+		      {
+			if (!known_value_ranges.length ())
+			  known_value_ranges.safe_grow_cleared (count);
+			known_value_ranges[i] = vr;
+		      }
+		  }
+		/* Determine known aggregate values.  */
+		ipa_agg_value_set agg
+		    = ipa_agg_value_set_from_jfunc (caller_parms_info,
+						    caller, &jf->agg);
+		if (agg.items.length ())
+		  {
+		    if (!known_aggs_ptr->length ())
+		      vec_safe_grow_cleared (known_aggs_ptr, count);
+		    (*known_aggs_ptr)[i] = agg;
+		  }
+	      }
+	    /* For calls used in polymorphic calls we further determine
+	       polymorphic call context.  */
+	    if (known_contexts_ptr
+		&& ipa_is_param_used_by_polymorphic_call (callee_pi, i))
+	      {
+		ipa_polymorphic_call_context
+		   ctx = ipa_context_from_jfunc (caller_parms_info, e, i, jf);
+		if (!ctx.useless_p ())
+		  {
+		    if (!known_contexts_ptr->length ())
+		      known_contexts_ptr->safe_grow_cleared (count);
+		    (*known_contexts_ptr)[i]
+		      = ipa_context_from_jfunc (caller_parms_info, e, i, jf);
+		  }
+	       }
+	  }
+	else
+	  gcc_assert (!count || callee->thunk.thunk_p);
+}
+else if (e->call_stmt && !e->call_stmt_cannot_inline_p && info->conds)
 {
 int i, count = (int)gimple_call_num_args (e->call_stmt);
-if (count && (info->conds || known_vals_ptr))
-	known_vals.safe_grow_cleared (count);
 for (i = 0; i < count; i++)
 	{
 	  tree cst = gimple_call_arg (e->call_stmt, i);
 	  if (!is_gimple_min_invariant (cst))
 	    cst = NULL;
 	  if (cst)
-	    known_vals[i] = cst;
+	    {
+	      if (!known_vals_ptr->length ())
+	        vec_safe_grow_cleared (known_vals_ptr, count);
+	      (*known_vals_ptr)[i] = cst;
+	    }
 	}
 }
 evaluate_conditions_for_known_args (callee, inline_p,
-				      known_vals, known_aggs, clause_ptr,
+				      *known_vals_ptr,
+				      known_value_ranges,
+				      *known_aggs_ptr,
+				      clause_ptr,
 				      nonspec_clause_ptr);
-if (known_vals_ptr)
-*known_vals_ptr = known_vals;
-else
-known_vals.release ();
-if (known_aggs_ptr)
-*known_aggs_ptr = known_aggs;
-else
-known_aggs.release ();
 }
 /* Allocate the function summary. */
 static void
 ipa_fn_summary_alloc (void)
 {
 gcc_checking_assert (!ipa_fn_summaries);
+ipa_size_summaries = new ipa_size_summary_t (symtab);
 ipa_fn_summaries = ipa_fn_summary_t::create_ggc (symtab);
-ipa_call_summaries = new ipa_call_summary_t (symtab, false);
+ipa_call_summaries = new ipa_call_summary_t (symtab);
 }
 ipa_call_summary::~ipa_call_summary ()
 {
 if (predicate)
 {
 if (loop_iterations)
 edge_predicate_pool.remove (loop_iterations);
 if (loop_stride)
 edge_predicate_pool.remove (loop_stride);
-if (array_index)
-edge_predicate_pool.remove (array_index);
 vec_free (conds);
 vec_free (size_time_table);
+vec_free (call_size_time_table);
 }
 void
 ipa_fn_summary_t::remove_callees (cgraph_node *node)
 {
 out that something was optimized out.  */
 if (ipa_node_params_sum && dst->clone.tree_map)
 {
 vec<size_time_entry, va_gc> *entry = info->size_time_table;
 /* Use SRC parm info since it may not be copied yet.  */
-struct ipa_node_params *parms_info = IPA_NODE_REF (src);
+class ipa_node_params *parms_info = IPA_NODE_REF (src);
 vec<tree> known_vals = vNULL;
 int count = ipa_get_param_count (parms_info);
 int i, j;
 clause_t possible_truths;
 predicate true_pred = true;
 	{
 	  struct ipa_replace_map *r;
 	  for (j = 0; vec_safe_iterate (dst->clone.tree_map, j, &r); j++)
 	    {
-	      if (((!r->old_tree && r->parm_num == i)
+	      if (r->parm_num == i)
-		   || (r->old_tree && r->old_tree == ipa_get_param (parms_info, i)))
-		   && r->replace_p && !r->ref_p)
 		{
 		  known_vals[i] = r->new_tree;
 		  break;
 		}
 	    }
 	}
 evaluate_conditions_for_known_args (dst, false,
 					  known_vals,
+					  vNULL,
 					  vNULL,
 					  &possible_truths,
 					  /* We are going to specialize,
 					     so ignore nonspec truths.  */
 					  NULL);
 known_vals.release ();
 info->account_size_time (0, 0, true_pred, true_pred);
 /* Remap size_time vectors.
-Simplify the predicate by prunning out alternatives that are known
+Simplify the predicate by pruning out alternatives that are known
 to be false.
 TODO: as on optimization, we can also eliminate conditions known
 to be true.  */
 for (i = 0; vec_safe_iterate (entry, i, &e); i++)
 	{
 /* Remap edge predicates with the same simplification as above.
 Also copy constantness arrays.   */
 for (edge = dst->callees; edge; edge = next)
 	{
 	  predicate new_predicate;
-	  struct ipa_call_summary *es = ipa_call_summaries->get_create (edge);
+	  class ipa_call_summary *es = ipa_call_summaries->get (edge);
 	  next = edge->next_callee;
 	  if (!edge->inline_failed)
 	    inlined_to_p = true;
 	  if (!es->predicate)
 	  if (new_predicate == false && *es->predicate != false)
 	    optimized_out_size += es->call_stmt_size * ipa_fn_summary::size_scale;
 	  edge_set_predicate (edge, &new_predicate);
 	}
-/* Remap indirect edge predicates with the same simplificaiton as above.
+/* Remap indirect edge predicates with the same simplification as above.
 Also copy constantness arrays.   */
 for (edge = dst->indirect_calls; edge; edge = next)
 	{
 	  predicate new_predicate;
-	  struct ipa_call_summary *es = ipa_call_summaries->get_create (edge);
+	  class ipa_call_summary *es = ipa_call_summaries->get (edge);
 	  next = edge->next_callee;
 	  gcc_checking_assert (edge->inline_failed);
 	  if (!es->predicate)
 	    continue;
 	}
 remap_hint_predicate_after_duplication (&info->loop_iterations,
 					      possible_truths);
 remap_hint_predicate_after_duplication (&info->loop_stride,
 					      possible_truths);
-remap_hint_predicate_after_duplication (&info->array_index,
-					      possible_truths);
 /* If inliner or someone after inliner will ever start producing
 non-trivial clones, we will get trouble with lack of information
 about updating self sizes, because size vectors already contains
-sizes of the calees.  */
+sizes of the callees.  */
 gcc_assert (!inlined_to_p || !optimized_out_size);
 }
 else
 {
 info->size_time_table = vec_safe_copy (info->size_time_table);
 	{
 	  predicate p = *info->loop_stride;
 	  info->loop_stride = NULL;
 	  set_hint_predicate (&info->loop_stride, p);
 	}
-if (info->array_index)
+}
-	{
+if (!dst->inlined_to)
-	  predicate p = *info->array_index;
-	  info->array_index = NULL;
-	  set_hint_predicate (&info->array_index, p);
-	}
-}
-if (!dst->global.inlined_to)
 ipa_update_overall_fn_summary (dst);
 }
 /* Hook that is called by cgraph.c when a node is duplicated.  */
 void
 ipa_call_summary_t::duplicate (struct cgraph_edge *src,
 			       struct cgraph_edge *dst,
-			       struct ipa_call_summary *srcinfo,
+			       class ipa_call_summary *srcinfo,
-			       struct ipa_call_summary *info)
+			       class ipa_call_summary *info)
 {
 new (info) ipa_call_summary (*srcinfo);
 info->predicate = NULL;
 edge_set_predicate (dst, srcinfo->predicate);
 info->param = srcinfo->param.copy ();
 /* Dump edge summaries associated to NODE and recursively to all clones.
 Indent by INDENT.  */
 static void
 dump_ipa_call_summary (FILE *f, int indent, struct cgraph_node *node,
-		       struct ipa_fn_summary *info)
+		       class ipa_fn_summary *info)
 {
 struct cgraph_edge *edge;
 for (edge = node->callees; edge; edge = edge->next_callee)
 {
-struct ipa_call_summary *es = ipa_call_summaries->get (edge);
+class ipa_call_summary *es = ipa_call_summaries->get (edge);
 struct cgraph_node *callee = edge->callee->ultimate_alias_target ();
 int i;
 fprintf (f,
-	       "%*s%s/%i %s\n%*s  loop depth:%2i freq:%4.2f size:%2i time: %2i",
+	       "%*s%s %s\n%*s  freq:%4.2f",
-	       indent, "", callee->name (), callee->order,
+	       indent, "", callee->dump_name (),
 	       !edge->inline_failed
 	       ? "inlined" : cgraph_inline_failed_string (edge-> inline_failed),
-	       indent, "", es->loop_depth, edge->sreal_frequency ().to_double (),
+	       indent, "", edge->sreal_frequency ().to_double ());
-	       es->call_stmt_size, es->call_stmt_time);
+if (cross_module_call_p (edge))
+	fprintf (f, " cross module");
+if (es)
+	fprintf (f, " loop depth:%2i size:%2i time: %2i",
+		 es->loop_depth, es->call_stmt_size, es->call_stmt_time);
 ipa_fn_summary *s = ipa_fn_summaries->get (callee);
+ipa_size_summary *ss = ipa_size_summaries->get (callee);
 if (s != NULL)
-	fprintf (f, "callee size:%2i stack:%2i",
+	fprintf (f, " callee size:%2i stack:%2i",
-		 (int) (s->size / ipa_fn_summary::size_scale),
+		 (int) (ss->size / ipa_fn_summary::size_scale),
 		 (int) s->estimated_stack_size);
-if (es->predicate)
+if (es && es->predicate)
 	{
 	  fprintf (f, " predicate: ");
 	  es->predicate->dump (f, info->conds);
 	}
 else
 	fprintf (f, "\n");
-if (es->param.exists ())
+if (es && es->param.exists ())
 	for (i = 0; i < (int) es->param.length (); i++)
 	  {
 	    int prob = es->param[i].change_prob;
 	    if (!prob)
 	      fprintf (f, "%*s op%i change %f%% of time\n", indent + 2, "", i,
 		       prob * 100.0 / REG_BR_PROB_BASE);
 	  }
 if (!edge->inline_failed)
 	{
-	  ipa_fn_summary *s = ipa_fn_summaries->get (callee);
+	  ipa_size_summary *ss = ipa_size_summaries->get (callee);
-	  fprintf (f, "%*sStack frame offset %i, callee self size %i,"
+	  fprintf (f, "%*sStack frame offset %i, callee self size %i\n",
-		   " callee size %i\n",
 		   indent + 2, "",
-		   (int) s->stack_frame_offset,
+		   (int) ipa_get_stack_frame_offset (callee),
-		   (int) s->estimated_self_stack_size,
+		   (int) ss->estimated_self_stack_size);
-		   (int) s->estimated_stack_size);
 	  dump_ipa_call_summary (f, indent + 2, callee, info);
 	}
 }
 for (edge = node->indirect_calls; edge; edge = edge->next_callee)
 {
-struct ipa_call_summary *es = ipa_call_summaries->get (edge);
+class ipa_call_summary *es = ipa_call_summaries->get (edge);
 fprintf (f, "%*sindirect call loop depth:%2i freq:%4.2f size:%2i"
 	       " time: %2i",
 	       indent, "",
 	       es->loop_depth,
 	       edge->sreal_frequency ().to_double (), es->call_stmt_size,
 void
 ipa_dump_fn_summary (FILE *f, struct cgraph_node *node)
 {
 if (node->definition)
 {
-struct ipa_fn_summary *s = ipa_fn_summaries->get (node);
+class ipa_fn_summary *s = ipa_fn_summaries->get (node);
+class ipa_size_summary *ss = ipa_size_summaries->get (node);
 if (s != NULL)
 	{
 	  size_time_entry *e;
 	  int i;
 	  fprintf (f, "IPA function summary for %s", node->dump_name ());
 	  if (s->inlinable)
 	    fprintf (f, " inlinable");
 	  if (s->fp_expressions)
 	    fprintf (f, " fp_expression");
 	  fprintf (f, "\n  global time:     %f\n", s->time.to_double ());
-	  fprintf (f, "  self size:       %i\n", s->self_size);
+	  fprintf (f, "  self size:       %i\n", ss->self_size);
-	  fprintf (f, "  global size:     %i\n", s->size);
+	  fprintf (f, "  global size:     %i\n", ss->size);
 	  fprintf (f, "  min size:       %i\n", s->min_size);
 	  fprintf (f, "  self stack:      %i\n",
-		   (int) s->estimated_self_stack_size);
+		   (int) ss->estimated_self_stack_size);
 	  fprintf (f, "  global stack:    %i\n", (int) s->estimated_stack_size);
 	  if (s->growth)
 	    fprintf (f, "  estimated growth:%i\n", (int) s->growth);
 	  if (s->scc_no)
 	    fprintf (f, "  In SCC:          %i\n", (int) s->scc_no);
 	  if (s->loop_stride)
 	    {
 	      fprintf (f, "  loop stride:");
 	      s->loop_stride->dump (f, s->conds);
 	    }
-	  if (s->array_index)
-	    {
-	      fprintf (f, "  array index:");
-	      s->array_index->dump (f, s->conds);
-	    }
 	  fprintf (f, "  calls:\n");
 	  dump_ipa_call_summary (f, 4, node, s);
 	  fprintf (f, "\n");
 	}
 else
 ipa_dump_fn_summaries (FILE *f)
 {
 struct cgraph_node *node;
 FOR_EACH_DEFINED_FUNCTION (node)
-if (!node->global.inlined_to)
+if (!node->inlined_to)
 ipa_dump_fn_summary (f, node);
 }
 /* Callback of walk_aliased_vdefs.  Flags that it has been invoked to the
 boolean variable pointed to by DATA.  */
 /* If OP refers to value of function parameter, return the corresponding
 parameter.  If non-NULL, the size of the memory load (or the SSA_NAME of the
 PARM_DECL) will be stored to *SIZE_P in that case too.  */
 static tree
-unmodified_parm_1 (gimple *stmt, tree op, HOST_WIDE_INT *size_p)
+unmodified_parm_1 (ipa_func_body_info *fbi, gimple *stmt, tree op,
+		   poly_int64 *size_p)
 {
 /* SSA_NAME referring to parm default def?  */
 if (TREE_CODE (op) == SSA_NAME
 && SSA_NAME_IS_DEFAULT_DEF (op)
 && TREE_CODE (SSA_NAME_VAR (op)) == PARM_DECL)
 {
 if (size_p)
-	*size_p = tree_to_shwi (TYPE_SIZE (TREE_TYPE (op)));
+	*size_p = tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (op)));
 return SSA_NAME_VAR (op);
 }
 /* Non-SSA parm reference?  */
 if (TREE_CODE (op) == PARM_DECL)
 {
 bool modified = false;
 ao_ref refd;
 ao_ref_init (&refd, op);
-walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified, &modified,
+int walked = walk_aliased_vdefs (&refd, gimple_vuse (stmt),
-			  NULL);
+				       mark_modified, &modified, NULL, NULL,
+				       fbi->aa_walk_budget + 1);
+if (walked < 0)
+	{
+	  fbi->aa_walk_budget = 0;
+	  return NULL_TREE;
+	}
 if (!modified)
 	{
 	  if (size_p)
-	    *size_p = tree_to_shwi (TYPE_SIZE (TREE_TYPE (op)));
+	    *size_p = tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (op)));
 	  return op;
 	}
 }
 return NULL_TREE;
 }
 parameter.  Also traverse chains of SSA register assignments.  If non-NULL,
 the size of the memory load (or the SSA_NAME of the PARM_DECL) will be
 stored to *SIZE_P in that case too.  */
 static tree
-unmodified_parm (gimple *stmt, tree op, HOST_WIDE_INT *size_p)
+unmodified_parm (ipa_func_body_info *fbi, gimple *stmt, tree op,
-{
+		 poly_int64 *size_p)
-tree res = unmodified_parm_1 (stmt, op, size_p);
+{
+tree res = unmodified_parm_1 (fbi, stmt, op, size_p);
 if (res)
 return res;
 if (TREE_CODE (op) == SSA_NAME
 && !SSA_NAME_IS_DEFAULT_DEF (op)
 && gimple_assign_single_p (SSA_NAME_DEF_STMT (op)))
-return unmodified_parm (SSA_NAME_DEF_STMT (op),
+return unmodified_parm (fbi, SSA_NAME_DEF_STMT (op),
 			    gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op)),
 			    size_p);
 return NULL_TREE;
 }
 statement in which OP is used or loaded.  */
 static bool
 unmodified_parm_or_parm_agg_item (struct ipa_func_body_info *fbi,
 				  gimple *stmt, tree op, int *index_p,
-				  HOST_WIDE_INT *size_p,
+				  poly_int64 *size_p,
 				  struct agg_position_info *aggpos)
 {
-tree res = unmodified_parm_1 (stmt, op, size_p);
+tree res = unmodified_parm_1 (fbi, stmt, op, size_p);
 gcc_checking_assert (aggpos);
 if (res)
 {
 *index_p = ipa_get_param_decl_index (fbi->info, res);
 2 - for sure it is eliminated.
 We are not terribly sophisticated, basically looking for simple abstraction
 penalty wrappers.  */
 static int
-eliminated_by_inlining_prob (gimple *stmt)
+eliminated_by_inlining_prob (ipa_func_body_info *fbi, gimple *stmt)
 {
 enum gimple_code code = gimple_code (stmt);
 enum tree_code rhs_code;
 if (!optimize)
 rhs_code = gimple_assign_rhs_code (stmt);
 /* Casts of parameters, loads from parameters passed by reference
 and stores to return value or parameters are often free after
-inlining dua to SRA and further combining.
+inlining due to SRA and further combining.
 Assume that half of statements goes away.  */
 if (CONVERT_EXPR_CODE_P (rhs_code)
 	  || rhs_code == VIEW_CONVERT_EXPR
 	  || rhs_code == ADDR_EXPR
 	  || gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
 	    inner_rhs = rhs;
 	  if (!inner_lhs)
 	    inner_lhs = lhs;
 	  /* Reads of parameter are expected to be free.  */
-	  if (unmodified_parm (stmt, inner_rhs, NULL))
+	  if (unmodified_parm (fbi, stmt, inner_rhs, NULL))
 	    rhs_free = true;
 	  /* Match expressions of form &this->field. Those will most likely
 	     combine with something upstream after inlining.  */
 	  else if (TREE_CODE (inner_rhs) == ADDR_EXPR)
 	    {
 	      tree op = get_base_address (TREE_OPERAND (inner_rhs, 0));
 	      if (TREE_CODE (op) == PARM_DECL)
 		rhs_free = true;
 	      else if (TREE_CODE (op) == MEM_REF
-		       && unmodified_parm (stmt, TREE_OPERAND (op, 0), NULL))
+		       && unmodified_parm (fbi, stmt, TREE_OPERAND (op, 0),
+					   NULL))
 		rhs_free = true;
 	    }
 	  /* When parameter is not SSA register because its address is taken
 	     and it is just copied into one, the statement will be completely
 	    return 2;
 	  /* Reads of parameters passed by reference
 	     expected to be free (i.e. optimized out after inlining).  */
 	  if (TREE_CODE (inner_rhs) == MEM_REF
-	      && unmodified_parm (stmt, TREE_OPERAND (inner_rhs, 0), NULL))
+	      && unmodified_parm (fbi, stmt, TREE_OPERAND (inner_rhs, 0), NULL))
 	    rhs_free = true;
 	  /* Copying parameter passed by reference into gimple register is
 	     probably also going to copy propagate, but we can't be quite
 	     sure.  */
 	  if (rhs_free && is_gimple_reg (lhs))
 	    lhs_free = true;
 	  /* Writes to parameters, parameters passed by value and return value
-	     (either dirrectly or passed via invisible reference) are free.
+	     (either directly or passed via invisible reference) are free.
 	     TODO: We ought to handle testcase like
 	     struct a {int a,b;};
 	     struct a
-	     retrurnsturct (void)
+	     returnstruct (void)
 	     {
 	     struct a a ={1,2};
 	     return a;
 	     }
 	     This translate into:
-	     retrurnsturct ()
+	     returnstruct ()
 	     {
 	     int a$b;
 	     int a$a;
 	     struct a a;
 	     struct a D.2739;
 	     For that we either need to copy ipa-split logic detecting writes
 	     to return value.  */
 	  if (TREE_CODE (inner_lhs) == PARM_DECL
 	      || TREE_CODE (inner_lhs) == RESULT_DECL
 	      || (TREE_CODE (inner_lhs) == MEM_REF
-		  && (unmodified_parm (stmt, TREE_OPERAND (inner_lhs, 0), NULL)
+		  && (unmodified_parm (fbi, stmt, TREE_OPERAND (inner_lhs, 0),
+				       NULL)
 		      || (TREE_CODE (TREE_OPERAND (inner_lhs, 0)) == SSA_NAME
 			  && SSA_NAME_VAR (TREE_OPERAND (inner_lhs, 0))
 			  && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND
 						      (inner_lhs,
 						       0))) == RESULT_DECL))))
 default:
 return 0;
 }
 }
+/* Analyze EXPR if it represents a series of simple operations performed on
+a function parameter and return true if so.  FBI, STMT, EXPR, INDEX_P and
+AGGPOS have the same meaning like in unmodified_parm_or_parm_agg_item.
+Type of the parameter or load from an aggregate via the parameter is
+stored in *TYPE_P.  Operations on the parameter are recorded to
+PARAM_OPS_P if it is not NULL.  */
+static bool
+decompose_param_expr (struct ipa_func_body_info *fbi,
+		      gimple *stmt, tree expr,
+		      int *index_p, tree *type_p,
+		      struct agg_position_info *aggpos,
+		      expr_eval_ops *param_ops_p = NULL)
+{
+int op_limit = opt_for_fn (fbi->node->decl, param_ipa_max_param_expr_ops);
+int op_count = 0;
+if (param_ops_p)
+*param_ops_p = NULL;
+while (true)
+{
+expr_eval_op eval_op;
+unsigned rhs_count;
+unsigned cst_count = 0;
+if (unmodified_parm_or_parm_agg_item (fbi, stmt, expr, index_p, NULL,
+					    aggpos))
+	{
+	  tree type = TREE_TYPE (expr);
+	  if (aggpos->agg_contents)
+	    {
+	      /* Stop if containing bit-field.  */
+	      if (TREE_CODE (expr) == BIT_FIELD_REF
+		  || contains_bitfld_component_ref_p (expr))
+		break;
+	    }
+	  *type_p = type;
+	  return true;
+	}
+if (TREE_CODE (expr) != SSA_NAME || SSA_NAME_IS_DEFAULT_DEF (expr))
+	break;
+if (!is_gimple_assign (stmt = SSA_NAME_DEF_STMT (expr)))
+	break;
+switch (gimple_assign_rhs_class (stmt))
+	{
+	case GIMPLE_SINGLE_RHS:
+	  expr = gimple_assign_rhs1 (stmt);
+	  continue;
+	case GIMPLE_UNARY_RHS:
+	  rhs_count = 1;
+	  break;
+	case GIMPLE_BINARY_RHS:
+	  rhs_count = 2;
+	  break;
+	case GIMPLE_TERNARY_RHS:
+	  rhs_count = 3;
+	  break;
+	default:
+	  goto fail;
+	}
+/* Stop if expression is too complex.  */
+if (op_count++ == op_limit)
+	break;
+if (param_ops_p)
+	{
+	  eval_op.code = gimple_assign_rhs_code (stmt);
+	  eval_op.type = TREE_TYPE (gimple_assign_lhs (stmt));
+	  eval_op.val[0] = NULL_TREE;
+	  eval_op.val[1] = NULL_TREE;
+	}
+expr = NULL_TREE;
+for (unsigned i = 0; i < rhs_count; i++)
+	{
+	  tree op = gimple_op (stmt, i + 1);
+	  gcc_assert (op && !TYPE_P (op));
+	  if (is_gimple_ip_invariant (op))
+	    {
+	      if (++cst_count == rhs_count)
+		goto fail;
+	      eval_op.val[cst_count - 1] = op;
+	    }
+	  else if (!expr)
+	    {
+	      /* Found a non-constant operand, and record its index in rhs
+		 operands.  */
+	      eval_op.index = i;
+	      expr = op;
+	    }
+	  else
+	    {
+	      /* Found more than one non-constant operands.  */
+	      goto fail;
+	    }
+	}
+if (param_ops_p)
+	vec_safe_insert (*param_ops_p, 0, eval_op);
+}
+/* Failed to decompose, free resource and return.  */
+fail:
+if (param_ops_p)
+vec_free (*param_ops_p);
+return false;
+}
 /* If BB ends by a conditional we can turn into predicates, attach corresponding
 predicates to the CFG edges.   */
 static void
 set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
-				   struct ipa_fn_summary *summary,
+				   class ipa_fn_summary *summary,
+				   class ipa_node_params *params_summary,
 				   basic_block bb)
 {
 gimple *last;
-tree op;
+tree op, op2;
 int index;
-HOST_WIDE_INT size;
 struct agg_position_info aggpos;
 enum tree_code code, inverted_code;
 edge e;
 edge_iterator ei;
 gimple *set_stmt;
-tree op2;
+tree param_type;
+expr_eval_ops param_ops;
 last = last_stmt (bb);
 if (!last || gimple_code (last) != GIMPLE_COND)
 return;
 if (!is_gimple_ip_invariant (gimple_cond_rhs (last)))
 return;
 op = gimple_cond_lhs (last);
-/* TODO: handle conditionals like
-var = op0 < 4;
+if (decompose_param_expr (fbi, last, op, &index, &param_type, &aggpos,
-if (var != 0).  */
+			    &param_ops))
-if (unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &size, &aggpos))
 {
 code = gimple_cond_code (last);
 inverted_code = invert_tree_comparison (code, HONOR_NANS (op));
 FOR_EACH_EDGE (e, ei, bb->succs)
 	{
 	  enum tree_code this_code = (e->flags & EDGE_TRUE_VALUE
 				      ? code : inverted_code);
 	  /* invert_tree_comparison will return ERROR_MARK on FP
-	     comparsions that are not EQ/NE instead of returning proper
+	     comparisons that are not EQ/NE instead of returning proper
-	     unordered one.  Be sure it is not confused with NON_CONSTANT.  */
+	     unordered one.  Be sure it is not confused with NON_CONSTANT.
-	  if (this_code != ERROR_MARK)
+	     And if the edge's target is the final block of diamond CFG graph
+	     of this conditional statement, we do not need to compute
+	     predicate for the edge because the final block's predicate must
+	     be at least as that of the first block of the statement.  */
+	  if (this_code != ERROR_MARK
+	      && !dominated_by_p (CDI_POST_DOMINATORS, bb, e->dest))
 	    {
 	      predicate p
-		= add_condition (summary, index, size, &aggpos, this_code,
+		= add_condition (summary, params_summary, index,
-				 unshare_expr_without_location
+			       	 param_type, &aggpos,
-				 (gimple_cond_rhs (last)));
+				 this_code, gimple_cond_rhs (last), param_ops);
 	      e->aux = edge_predicate_pool.allocate ();
 	      *(predicate *) e->aux = p;
 	    }
 	}
+vec_free (param_ops);
 }
 if (TREE_CODE (op) != SSA_NAME)
 return;
 /* Special case
 else
 nonconstant_code.
 Here we can predicate nonconstant_code.  We can't
 really handle constant_code since we have no predicate
 for this and also the constant code is not known to be
-optimized away when inliner doen't see operand is constant.
+optimized away when inliner doesn't see operand is constant.
 Other optimizers might think otherwise.  */
 if (gimple_cond_code (last) != NE_EXPR
 || !integer_zerop (gimple_cond_rhs (last)))
 return;
 set_stmt = SSA_NAME_DEF_STMT (op);
 if (!gimple_call_builtin_p (set_stmt, BUILT_IN_CONSTANT_P)
 || gimple_call_num_args (set_stmt) != 1)
 return;
 op2 = gimple_call_arg (set_stmt, 0);
-if (!unmodified_parm_or_parm_agg_item (fbi, set_stmt, op2, &index, &size,
+if (!decompose_param_expr (fbi, set_stmt, op2, &index, &param_type, &aggpos))
-					 &aggpos))
 return;
 FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_FALSE_VALUE)
 {
-predicate p = add_condition (summary, index, size, &aggpos,
+predicate p = add_condition (summary, params_summary, index,
+		     		   param_type, &aggpos,
 				   predicate::is_not_constant, NULL_TREE);
 e->aux = edge_predicate_pool.allocate ();
 *(predicate *) e->aux = p;
 }
 }
 /* If BB ends by a switch we can turn into predicates, attach corresponding
 predicates to the CFG edges.   */
 static void
 set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
-				     struct ipa_fn_summary *summary,
+				     class ipa_fn_summary *summary,
+				     class ipa_node_params *params_summary,
 				     basic_block bb)
 {
 gimple *lastg;
 tree op;
 int index;
-HOST_WIDE_INT size;
 struct agg_position_info aggpos;
 edge e;
 edge_iterator ei;
 size_t n;
 size_t case_idx;
+tree param_type;
+expr_eval_ops param_ops;
 lastg = last_stmt (bb);
 if (!lastg || gimple_code (lastg) != GIMPLE_SWITCH)
 return;
 gswitch *last = as_a <gswitch *> (lastg);
 op = gimple_switch_index (last);
-if (!unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &size, &aggpos))
+if (!decompose_param_expr (fbi, last, op, &index, &param_type, &aggpos,
+			     &param_ops))
 return;
+auto_vec<std::pair<tree, tree> > ranges;
+tree type = TREE_TYPE (op);
+int bound_limit = opt_for_fn (fbi->node->decl,
+				param_ipa_max_switch_predicate_bounds);
+int bound_count = 0;
+wide_int vr_wmin, vr_wmax;
+value_range_kind vr_type = get_range_info (op, &vr_wmin, &vr_wmax);
 FOR_EACH_EDGE (e, ei, bb->succs)
 {
 e->aux = edge_predicate_pool.allocate ();
 *(predicate *) e->aux = false;
 }
+e = gimple_switch_edge (cfun, last, 0);
+/* Set BOUND_COUNT to maximum count to bypass computing predicate for
+default case if its target basic block is in convergence point of all
+switch cases, which can be determined by checking whether it
+post-dominates the switch statement.  */
+if (dominated_by_p (CDI_POST_DOMINATORS, bb, e->dest))
+bound_count = INT_MAX;
 n = gimple_switch_num_labels (last);
-for (case_idx = 0; case_idx < n; ++case_idx)
+for (case_idx = 1; case_idx < n; ++case_idx)
 {
 tree cl = gimple_switch_label (last, case_idx);
-tree min, max;
+tree min = CASE_LOW (cl);
+tree max = CASE_HIGH (cl);
 predicate p;
 e = gimple_switch_edge (cfun, last, case_idx);
-min = CASE_LOW (cl);
-max = CASE_HIGH (cl);
+/* The case value might not have same type as switch expression,
+	 extend the value based on the expression type.  */
-/* For default we might want to construct predicate that none
+if (TREE_TYPE (min) != type)
-of cases is met, but it is bit hard to do not having negations
+	min = wide_int_to_tree (type, wi::to_wide (min));
-of conditionals handy.  */
-if (!min && !max)
+if (!max)
+	max = min;
+else if (TREE_TYPE (max) != type)
+	max = wide_int_to_tree (type, wi::to_wide (max));
+/* The case's target basic block is in convergence point of all switch
+	 cases, its predicate should be at least as that of the switch
+	 statement.  */
+if (dominated_by_p (CDI_POST_DOMINATORS, bb, e->dest))
 	p = true;
-else if (!max)
+else if (min == max)
-	p = add_condition (summary, index, size, &aggpos, EQ_EXPR,
+	p = add_condition (summary, params_summary, index, param_type,
-			   unshare_expr_without_location (min));
+		           &aggpos, EQ_EXPR, min, param_ops);
 else
 	{
 	  predicate p1, p2;
-	  p1 = add_condition (summary, index, size, &aggpos, GE_EXPR,
+	  p1 = add_condition (summary, params_summary, index, param_type,
-			      unshare_expr_without_location (min));
+			      &aggpos, GE_EXPR, min, param_ops);
-	  p2 = add_condition (summary, index, size, &aggpos, LE_EXPR,
+	  p2 = add_condition (summary,  params_summary,index, param_type,
-			      unshare_expr_without_location (max));
+			      &aggpos, LE_EXPR, max, param_ops);
 	  p = p1 & p2;
 	}
-*(struct predicate *) e->aux
+*(class predicate *) e->aux
-	= p.or_with (summary->conds, *(struct predicate *) e->aux);
+	= p.or_with (summary->conds, *(class predicate *) e->aux);
-}
+/* If there are too many disjoint case ranges, predicate for default
+	 case might become too complicated.  So add a limit here.  */
+if (bound_count > bound_limit)
+	continue;
+bool new_range = true;
+if (!ranges.is_empty ())
+	{
+	  wide_int curr_wmin = wi::to_wide (min);
+	  wide_int last_wmax = wi::to_wide (ranges.last ().second);
+	  /* Merge case ranges if they are continuous.  */
+	  if (curr_wmin == last_wmax + 1)
+	    new_range = false;
+	  else if (vr_type == VR_ANTI_RANGE)
+	    {
+	      /* If two disjoint case ranges can be connected by anti-range
+		 of switch index, combine them to one range.  */
+	      if (wi::lt_p (vr_wmax, curr_wmin - 1, TYPE_SIGN (type)))
+		vr_type = VR_UNDEFINED;
+	      else if (wi::le_p (vr_wmin, last_wmax + 1, TYPE_SIGN (type)))
+		new_range = false;
+	    }
+	}
+/* Create/extend a case range.  And we count endpoints of range set,
+	 this number nearly equals to number of conditions that we will create
+	 for predicate of default case.  */
+if (new_range)
+	{
+	  bound_count += (min == max) ? 1 : 2;
+	  ranges.safe_push (std::make_pair (min, max));
+	}
+else
+	{
+	  bound_count += (ranges.last ().first == ranges.last ().second);
+	  ranges.last ().second = max;
+	}
+}
+e = gimple_switch_edge (cfun, last, 0);
+if (bound_count > bound_limit)
+{
+*(class predicate *) e->aux = true;
+vec_free (param_ops);
+return;
+}
+predicate p_seg = true;
+predicate p_all = false;
+if (vr_type != VR_RANGE)
+{
+vr_wmin = wi::to_wide (TYPE_MIN_VALUE (type));
+vr_wmax = wi::to_wide (TYPE_MAX_VALUE (type));
+}
+/* Construct predicate to represent default range set that is negation of
+all case ranges.  Case range is classified as containing single/non-single
+values.  Suppose a piece of case ranges in the following.
+[D1...D2]  [S1] ... [Sn]  [D3...D4]
+To represent default case's range sets between two non-single value
+case ranges (From D2 to D3), we construct predicate as:
+D2 < x < D3 && x != S1 && ... && x != Sn
+*/
+for (size_t i = 0; i < ranges.length (); i++)
+{
+tree min = ranges[i].first;
+tree max = ranges[i].second;
+if (min == max)
+	p_seg &= add_condition (summary, params_summary, index,
+		       		param_type, &aggpos, NE_EXPR,
+				min, param_ops);
+else
+	{
+	  /* Do not create sub-predicate for range that is beyond low bound
+	     of switch index.  */
+	  if (wi::lt_p (vr_wmin, wi::to_wide (min), TYPE_SIGN (type)))
+	    {
+	      p_seg &= add_condition (summary, params_summary, index,
+			     	      param_type, &aggpos,
+				      LT_EXPR, min, param_ops);
+	      p_all = p_all.or_with (summary->conds, p_seg);
+	    }
+	  /* Do not create sub-predicate for range that is beyond up bound
+	     of switch index.  */
+	  if (wi::le_p (vr_wmax, wi::to_wide (max), TYPE_SIGN (type)))
+	    {
+	      p_seg = false;
+	      break;
+	    }
+	  p_seg = add_condition (summary, params_summary, index,
+			 	 param_type, &aggpos, GT_EXPR,
+				 max, param_ops);
+	}
+}
+p_all = p_all.or_with (summary->conds, p_seg);
+*(class predicate *) e->aux
+= p_all.or_with (summary->conds, *(class predicate *) e->aux);
+vec_free (param_ops);
 }
 /* For each BB in NODE attach to its AUX pointer predicate under
 which it is executable.  */
 static void
 compute_bb_predicates (struct ipa_func_body_info *fbi,
 		       struct cgraph_node *node,
-		       struct ipa_fn_summary *summary)
+		       class ipa_fn_summary *summary,
+		       class ipa_node_params *params_summary)
 {
 struct function *my_function = DECL_STRUCT_FUNCTION (node->decl);
 bool done = false;
 basic_block bb;
 FOR_EACH_BB_FN (bb, my_function)
 {
-set_cond_stmt_execution_predicate (fbi, summary, bb);
+set_cond_stmt_execution_predicate (fbi, summary, params_summary, bb);
-set_switch_stmt_execution_predicate (fbi, summary, bb);
+set_switch_stmt_execution_predicate (fbi, summary, params_summary, bb);
 }
 /* Entry block is always executable.  */
 ENTRY_BLOCK_PTR_FOR_FN (my_function)->aux
 = edge_predicate_pool.allocate ();
 	      if (e->src->aux)
 		{
 		  predicate this_bb_predicate
 		    = *(predicate *) e->src->aux;
 		  if (e->aux)
-		    this_bb_predicate &= (*(struct predicate *) e->aux);
+		    this_bb_predicate &= (*(class predicate *) e->aux);
 		  p = p.or_with (summary->conds, this_bb_predicate);
 		  if (p == true)
 		    break;
 		}
 	    }
-	  if (p == false)
+	  if (p != false)
-	    gcc_checking_assert (!bb->aux);
+	    {
-	  else
+	      basic_block pdom_bb;
-	    {
 	      if (!bb->aux)
 		{
 		  done = false;
 		  bb->aux = edge_predicate_pool.allocate ();
 		  *((predicate *) bb->aux) = p;
 		    {
 		      done = false;
 		      *((predicate *) bb->aux) = p;
 		    }
 		}
+	      /* For switch/if statement, we can OR-combine predicates of all
+		 its cases/branches to get predicate for basic block in their
+		 convergence point, but sometimes this will generate very
+		 complicated predicate.  Actually, we can get simplified
+		 predicate in another way by using the fact that predicate
+		 for a basic block must also hold true for its post dominators.
+		 To be specific, basic block in convergence point of
+		 conditional statement should include predicate of the
+		 statement.  */
+	      pdom_bb = get_immediate_dominator (CDI_POST_DOMINATORS, bb);
+	      if (pdom_bb == EXIT_BLOCK_PTR_FOR_FN (my_function) || !pdom_bb)
+		;
+	      else if (!pdom_bb->aux)
+		{
+		  done = false;
+		  pdom_bb->aux = edge_predicate_pool.allocate ();
+		  *((predicate *) pdom_bb->aux) = p;
+		}
+	      else if (p != *(predicate *) pdom_bb->aux)
+		{
+		  p = p.or_with (summary->conds, *(predicate *)pdom_bb->aux);
+		  if (p != *(predicate *) pdom_bb->aux)
+		    {
+		      done = false;
+		      *((predicate *) pdom_bb->aux) = p;
+		    }
+		}
 	    }
 	}
 }
 }
 /* Return predicate specifying when the STMT might have result that is not
 a compile time constant.  */
 static predicate
-will_be_nonconstant_expr_predicate (struct ipa_node_params *info,
+will_be_nonconstant_expr_predicate (ipa_func_body_info *fbi,
-				    struct ipa_fn_summary *summary,
+				    class ipa_fn_summary *summary,
+				    class ipa_node_params *params_summary,
 				    tree expr,
 				    vec<predicate> nonconstant_names)
 {
 tree parm;
 int index;
-HOST_WIDE_INT size;
 while (UNARY_CLASS_P (expr))
 expr = TREE_OPERAND (expr, 0);
-parm = unmodified_parm (NULL, expr, &size);
+parm = unmodified_parm (fbi, NULL, expr, NULL);
-if (parm && (index = ipa_get_param_decl_index (info, parm)) >= 0)
+if (parm && (index = ipa_get_param_decl_index (fbi->info, parm)) >= 0)
-return add_condition (summary, index, size, NULL, predicate::changed,
+return add_condition (summary, params_summary, index, TREE_TYPE (parm), NULL,
-			  NULL_TREE);
+			  predicate::changed, NULL_TREE);
 if (is_gimple_min_invariant (expr))
 return false;
 if (TREE_CODE (expr) == SSA_NAME)
 return nonconstant_names[SSA_NAME_VERSION (expr)];
 if (BINARY_CLASS_P (expr) || COMPARISON_CLASS_P (expr))
 {
-predicate p1 = will_be_nonconstant_expr_predicate
+predicate p1
-	(info, summary, TREE_OPERAND (expr, 0),
+	= will_be_nonconstant_expr_predicate (fbi, summary,
-	 nonconstant_names);
+					      params_summary,
+					      TREE_OPERAND (expr, 0),
+					      nonconstant_names);
 if (p1 == true)
 	return p1;
-predicate p2;
+predicate p2
-p2 = will_be_nonconstant_expr_predicate (info, summary,
+	= will_be_nonconstant_expr_predicate (fbi, summary,
-					       TREE_OPERAND (expr, 1),
+					      params_summary,
-					       nonconstant_names);
+					      TREE_OPERAND (expr, 1),
+					      nonconstant_names);
 return p1.or_with (summary->conds, p2);
 }
 else if (TREE_CODE (expr) == COND_EXPR)
 {
-predicate p1 = will_be_nonconstant_expr_predicate
+predicate p1
-	(info, summary, TREE_OPERAND (expr, 0),
+	= will_be_nonconstant_expr_predicate (fbi, summary,
-	 nonconstant_names);
+					      params_summary,
+					      TREE_OPERAND (expr, 0),
+					      nonconstant_names);
 if (p1 == true)
 	return p1;
-predicate p2;
+predicate p2
-p2 = will_be_nonconstant_expr_predicate (info, summary,
+	= will_be_nonconstant_expr_predicate (fbi, summary,
-					       TREE_OPERAND (expr, 1),
+					      params_summary,
-					       nonconstant_names);
+					      TREE_OPERAND (expr, 1),
+					      nonconstant_names);
 if (p2 == true)
 	return p2;
 p1 = p1.or_with (summary->conds, p2);
-p2 = will_be_nonconstant_expr_predicate (info, summary,
+p2 = will_be_nonconstant_expr_predicate (fbi, summary,
+					       params_summary,
 					       TREE_OPERAND (expr, 2),
 					       nonconstant_names);
 return p2.or_with (summary->conds, p1);
 }
 else if (TREE_CODE (expr) == CALL_EXPR)
 /* Return predicate specifying when the STMT might have result that is not
 a compile time constant.  */
 static predicate
 will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
-			       struct ipa_fn_summary *summary,
+			       class ipa_fn_summary *summary,
+			       class ipa_node_params *params_summary,
 			       gimple *stmt,
 			       vec<predicate> nonconstant_names)
 {
 predicate p = true;
 ssa_op_iter iter;
 tree use;
+tree param_type = NULL_TREE;
 predicate op_non_const;
 bool is_load;
 int base_index;
-HOST_WIDE_INT size;
 struct agg_position_info aggpos;
-/* What statments might be optimized away
+/* What statements might be optimized away
 when their arguments are constant.  */
 if (gimple_code (stmt) != GIMPLE_ASSIGN
 && gimple_code (stmt) != GIMPLE_COND
 && gimple_code (stmt) != GIMPLE_SWITCH
 && (gimple_code (stmt) != GIMPLE_CALL
 is_load = gimple_assign_load_p (stmt);
 /* Loads can be optimized when the value is known.  */
 if (is_load)
 {
-tree op;
+tree op = gimple_assign_rhs1 (stmt);
-gcc_assert (gimple_assign_single_p (stmt));
+if (!decompose_param_expr (fbi, stmt, op, &base_index, &param_type,
-op = gimple_assign_rhs1 (stmt);
+				 &aggpos))
-if (!unmodified_parm_or_parm_agg_item (fbi, stmt, op, &base_index, &size,
-					     &aggpos))
 	return p;
 }
 else
 base_index = -1;
 /* See if we understand all operands before we start
 adding conditionals.  */
 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
 {
-tree parm = unmodified_parm (stmt, use, NULL);
+tree parm = unmodified_parm (fbi, stmt, use, NULL);
 /* For arguments we can build a condition.  */
 if (parm && ipa_get_param_decl_index (fbi->info, parm) >= 0)
 	continue;
 if (TREE_CODE (use) != SSA_NAME)
 	return p;
 return p;
 }
 if (is_load)
 op_non_const =
-add_condition (summary, base_index, size, &aggpos, predicate::changed,
+add_condition (summary, params_summary,
-		     NULL);
+		     base_index, param_type, &aggpos,
+		     predicate::changed, NULL_TREE);
 else
 op_non_const = false;
 FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
 {
-HOST_WIDE_INT size;
+tree parm = unmodified_parm (fbi, stmt, use, NULL);
-tree parm = unmodified_parm (stmt, use, &size);
 int index;
 if (parm && (index = ipa_get_param_decl_index (fbi->info, parm)) >= 0)
 	{
 	  if (index != base_index)
-	    p = add_condition (summary, index, size, NULL, predicate::changed,
+	    p = add_condition (summary, params_summary, index,
-			       NULL_TREE);
+			       TREE_TYPE (parm), NULL,
+			       predicate::changed, NULL_TREE);
 	  else
 	    continue;
 	}
 else
 	p = nonconstant_names[SSA_NAME_VERSION (use)];
 tree op;
 bitmap bb_set;
 gimple *stmt;
 };
-/* Value is initialized in INIT_BB and used in USE_BB.  We want to copute
+/* Value is initialized in INIT_BB and used in USE_BB.  We want to compute
 probability how often it changes between USE_BB.
 INIT_BB->count/USE_BB->count is an estimate, but if INIT_BB
 is in different loop nest, we can do better.
 This is all just estimate.  In theory we look for minimal cut separating
 INIT_BB and USE_BB, but we only want to anticipate loop invariant motion
 anyway.  */
 static basic_block
 get_minimal_bb (basic_block init_bb, basic_block use_bb)
 {
-struct loop *l = find_common_loop (init_bb->loop_father, use_bb->loop_father);
+class loop *l = find_common_loop (init_bb->loop_father, use_bb->loop_father);
 if (l && l->header->count < init_bb->count)
 return l->header;
 return init_bb;
 }
 Value 0 is reserved for compile time invariants.
 For common parameters it is REG_BR_PROB_BASE.  For loop invariants it
 ought to be REG_BR_PROB_BASE / estimated_iters.  */
 static int
-param_change_prob (gimple *stmt, int i)
+param_change_prob (ipa_func_body_info *fbi, gimple *stmt, int i)
 {
 tree op = gimple_call_arg (stmt, i);
 basic_block bb = gimple_bb (stmt);
 if (TREE_CODE (op) == WITH_SIZE_EXPR)
 	return 0;
 if (!bb->count.nonzero_p ())
 	return REG_BR_PROB_BASE;
 if (dump_file)
 	{
-	  fprintf (dump_file, "     Analyzing param change probablity of ");
+	  fprintf (dump_file, "     Analyzing param change probability of ");
 print_generic_expr (dump_file, op, TDF_SLIM);
 	  fprintf (dump_file, "\n");
 	}
 ao_ref_init (&refd, op);
 info.op = op;
 info.stmt = stmt;
 info.bb_set = BITMAP_ALLOC (NULL);
-walk_aliased_vdefs (&refd, gimple_vuse (stmt), record_modified, &info,
+int walked
-			  NULL);
+	= walk_aliased_vdefs (&refd, gimple_vuse (stmt), record_modified, &info,
-if (bitmap_bit_p (info.bb_set, bb->index))
+			      NULL, NULL, fbi->aa_walk_budget);
+if (walked < 0 || bitmap_bit_p (info.bb_set, bb->index))
 	{
 	  if (dump_file)
-	    fprintf (dump_file, "     Set in same BB as used.\n");
+	    {
+	      if (walked < 0)
+		fprintf (dump_file, "     Ran out of AA walking budget.\n");
+	      else
+		fprintf (dump_file, "     Set in same BB as used.\n");
+	    }
 	  BITMAP_FREE (info.bb_set);
 	  return REG_BR_PROB_BASE;
 	}
 bitmap_iterator bi;
 /* Find whether a basic block BB is the final block of a (half) diamond CFG
 sub-graph and if the predicate the condition depends on is known.  If so,
 return true and store the pointer the predicate in *P.  */
 static bool
-phi_result_unknown_predicate (struct ipa_node_params *info,
+phi_result_unknown_predicate (ipa_func_body_info *fbi,
-			      ipa_fn_summary *summary, basic_block bb,
+			      ipa_fn_summary *summary,
+			      class ipa_node_params *params_summary,
+			      basic_block bb,
 			      predicate *p,
 			      vec<predicate> nonconstant_names)
 {
 edge e;
 edge_iterator ei;
 if (!stmt
 || gimple_code (stmt) != GIMPLE_COND
 || !is_gimple_ip_invariant (gimple_cond_rhs (stmt)))
 return false;
-*p = will_be_nonconstant_expr_predicate (info, summary,
+*p = will_be_nonconstant_expr_predicate (fbi, summary, params_summary,
 					   gimple_cond_lhs (stmt),
 					   nonconstant_names);
 if (*p == true)
 return false;
 else
 and *P being the predicate describing whether the selected PHI argument is
 known, store a predicate for the result of the PHI statement into
 NONCONSTANT_NAMES, if possible.  */
 static void
-predicate_for_phi_result (struct ipa_fn_summary *summary, gphi *phi,
+predicate_for_phi_result (class ipa_fn_summary *summary, gphi *phi,
 			  predicate *p,
 			  vec<predicate> nonconstant_names)
 {
 unsigned i;
 {
 fprintf (dump_file, "\t\tphi predicate: ");
 p->dump (dump_file, summary->conds);
 }
 nonconstant_names[SSA_NAME_VERSION (gimple_phi_result (phi))] = *p;
-}
-/* Return predicate specifying when array index in access OP becomes non-constant.  */
-static predicate
-array_index_predicate (ipa_fn_summary *info,
-		       vec< predicate> nonconstant_names, tree op)
-{
-predicate p = false;
-while (handled_component_p (op))
-{
-if (TREE_CODE (op) == ARRAY_REF || TREE_CODE (op) == ARRAY_RANGE_REF)
-	{
-	  if (TREE_CODE (TREE_OPERAND (op, 1)) == SSA_NAME)
-	    p = p.or_with (info->conds,
-			   nonconstant_names[SSA_NAME_VERSION
-						  (TREE_OPERAND (op, 1))]);
-	}
-op = TREE_OPERAND (op, 0);
-}
-return p;
 }
 /* For a typical usage of __builtin_expect (a<b, 1), we
 may introduce an extra relation stmt:
 With the builtin, we have
 /* Return true when the basic blocks contains only clobbers followed by RESX.
 Such BBs are kept around to make removal of dead stores possible with
 presence of EH and will be optimized out by optimize_clobbers later in the
 game.
-NEED_EH is used to recurse in case the clobber has non-EH predecestors
+NEED_EH is used to recurse in case the clobber has non-EH predecessors
 that can be clobber only, too.. When it is false, the RESX is not necessary
 on the end of basic block.  */
 static bool
 clobber_only_eh_bb_p (basic_block bb, bool need_eh = true)
 if (gimple_code (stmt) == GIMPLE_LABEL)
 	break;
 return false;
 }
-/* See if all predecestors are either throws or clobber only BBs.  */
+/* See if all predecessors are either throws or clobber only BBs.  */
 FOR_EACH_EDGE (e, ei, bb->preds)
 if (!(e->flags & EDGE_EH)
 	&& !clobber_only_eh_bb_p (e->src, false))
 return false;
 EARLY indicates run from early optimization pipeline.  */
 static void
 analyze_function_body (struct cgraph_node *node, bool early)
 {
-sreal time = 0;
+sreal time = opt_for_fn (node->decl, param_uninlined_function_time);
 /* Estimate static overhead for function prologue/epilogue and alignment. */
-int size = 2;
+int size = opt_for_fn (node->decl, param_uninlined_function_insns);
 /* Benefits are scaled by probability of elimination that is in range
 <0,2>.  */
 basic_block bb;
 struct function *my_function = DECL_STRUCT_FUNCTION (node->decl);
 sreal freq;
-struct ipa_fn_summary *info = ipa_fn_summaries->get_create (node);
+class ipa_fn_summary *info = ipa_fn_summaries->get_create (node);
+class ipa_node_params *params_summary = early ? NULL : IPA_NODE_REF (node);
 predicate bb_predicate;
 struct ipa_func_body_info fbi;
 vec<predicate> nonconstant_names = vNULL;
 int nblocks, n;
 int *order;
-predicate array_index = true;
 gimple *fix_builtin_expect_stmt;
 gcc_assert (my_function && my_function->cfg);
 gcc_assert (cfun == my_function);
 memset(&fbi, 0, sizeof(fbi));
+vec_free (info->conds);
 info->conds = NULL;
+vec_free (info->size_time_table);
 info->size_time_table = NULL;
 /* When optimizing and analyzing for IPA inliner, initialize loop optimizer
 so we can produce proper inline hints.
 so we can produce correct BB predicates.  */
 if (opt_for_fn (node->decl, optimize))
 {
 calculate_dominance_info (CDI_DOMINATORS);
+calculate_dominance_info (CDI_POST_DOMINATORS);
 if (!early)
 loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS);
 else
 	{
 	  ipa_check_create_node_params ();
 	{
 	  fbi.node = node;
 	  fbi.info = IPA_NODE_REF (node);
 	  fbi.bb_infos = vNULL;
 	  fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun));
-	  fbi.param_count = count_formal_params(node->decl);
+	  fbi.param_count = count_formal_params (node->decl);
+	  fbi.aa_walk_budget = opt_for_fn (node->decl, param_ipa_max_aa_steps);
 	  nonconstant_names.safe_grow_cleared
 	    (SSANAMES (my_function)->length ());
 	}
 }
 if (dump_file)
 fprintf (dump_file, "\nAnalyzing function body size: %s\n",
-	     node->name ());
+	     node->dump_name ());
 /* When we run into maximal number of entries, we assign everything to the
 constant truth case.  Be sure to have it in list. */
 bb_predicate = true;
 info->account_size_time (0, 0, bb_predicate, bb_predicate);
 bb_predicate = predicate::not_inlined ();
-info->account_size_time (2 * ipa_fn_summary::size_scale, 0, bb_predicate,
+info->account_size_time (opt_for_fn (node->decl,
+				param_uninlined_function_insns)
+			   * ipa_fn_summary::size_scale,
+			   opt_for_fn (node->decl,
+				param_uninlined_function_time),
+			   bb_predicate,
 		           bb_predicate);
 if (fbi.info)
-compute_bb_predicates (&fbi, node, info);
+compute_bb_predicates (&fbi, node, info, params_summary);
 order = XNEWVEC (int, n_basic_blocks_for_fn (cfun));
 nblocks = pre_and_rev_post_order_compute (NULL, order, false);
 for (n = 0; n < nblocks; n++)
 {
 bb = BASIC_BLOCK_FOR_FN (cfun, order[n]);
 	  for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
 	       gsi_next (&bsi))
 	    {
 	      if (first_phi
-		  && !phi_result_unknown_predicate (fbi.info, info, bb,
+		  && !phi_result_unknown_predicate (&fbi, info,
+			  			    params_summary,
+			 			    bb,
 						    &phi_predicate,
 						    nonconstant_names))
 		break;
 	      first_phi = false;
 	      if (dump_file && (dump_flags & TDF_DETAILS))
 	    }
 	}
 fix_builtin_expect_stmt = find_foldable_builtin_expect (bb);
-for (gimple_stmt_iterator bsi = gsi_start_bb (bb); !gsi_end_p (bsi);
+for (gimple_stmt_iterator bsi = gsi_start_nondebug_bb (bb);
-	   gsi_next (&bsi))
+	   !gsi_end_p (bsi); gsi_next_nondebug (&bsi))
 	{
 	  gimple *stmt = gsi_stmt (bsi);
 	  int this_size = estimate_num_insns (stmt, &eni_size_weights);
 	  int this_time = estimate_num_insns (stmt, &eni_time_weights);
 	  int prob;
 	  predicate will_be_nonconstant;
 /* This relation stmt should be folded after we remove
-buildin_expect call. Adjust the cost here.  */
+__builtin_expect call. Adjust the cost here.  */
 	  if (stmt == fix_builtin_expect_stmt)
 {
 this_size--;
 this_time--;
 }
 	      print_gimple_stmt (dump_file, stmt, 0);
 	      fprintf (dump_file, "\t\tfreq:%3.2f size:%3i time:%3i\n",
 		       freq.to_double (), this_size,
 		       this_time);
 	    }
-	  if (gimple_assign_load_p (stmt) && nonconstant_names.exists ())
-	    {
-	      predicate this_array_index;
-	      this_array_index =
-		array_index_predicate (info, nonconstant_names,
-				       gimple_assign_rhs1 (stmt));
-	      if (this_array_index != false)
-		array_index &= this_array_index;
-	    }
-	  if (gimple_store_p (stmt) && nonconstant_names.exists ())
-	    {
-	      predicate this_array_index;
-	      this_array_index =
-		array_index_predicate (info, nonconstant_names,
-				       gimple_get_lhs (stmt));
-	      if (this_array_index != false)
-		array_index &= this_array_index;
-	    }
 	  if (is_gimple_call (stmt)
 	      && !gimple_call_internal_p (stmt))
 	    {
 	      struct cgraph_edge *edge = node->get_edge (stmt);
 		  if (count)
 		    es->param.safe_grow_cleared (count);
 		  for (i = 0; i < count; i++)
 		    {
-		      int prob = param_change_prob (stmt, i);
+		      int prob = param_change_prob (&fbi, stmt, i);
 		      gcc_assert (prob >= 0 && prob <= REG_BR_PROB_BASE);
 		      es->param[i].change_prob = prob;
 		    }
 		}
 	      es->call_stmt_size = this_size;
 	      es->call_stmt_time = this_time;
 	      es->loop_depth = bb_loop_depth (bb);
 	      edge_set_predicate (edge, &bb_predicate);
-	    }
+	      if (edge->speculative)
+		{
-	  /* TODO: When conditional jump or swithc is known to be constant, but
+		  cgraph_edge *indirect
+			= edge->speculative_call_indirect_edge ();
+	          ipa_call_summary *es2
+			 = ipa_call_summaries->get_create (indirect);
+		  ipa_call_summaries->duplicate (edge, indirect,
+						 es, es2);
+		  /* Edge is the first direct call.
+		     create and duplicate call summaries for multiple
+		     speculative call targets.  */
+		  for (cgraph_edge *direct
+			 = edge->next_speculative_call_target ();
+		       direct;
+		       direct = direct->next_speculative_call_target ())
+		    {
+		      ipa_call_summary *es3
+			= ipa_call_summaries->get_create (direct);
+		      ipa_call_summaries->duplicate (edge, direct,
+						     es, es3);
+		    }
+		}
+	    }
+	  /* TODO: When conditional jump or switch is known to be constant, but
 	     we did not translate it into the predicates, we really can account
 	     just maximum of the possible paths.  */
 	  if (fbi.info)
 	    will_be_nonconstant
-	      = will_be_nonconstant_predicate (&fbi, info,
+	      = will_be_nonconstant_predicate (&fbi, info, params_summary,
 					       stmt, nonconstant_names);
 	  else
 	    will_be_nonconstant = true;
 	  if (this_time || this_size)
 	    {
 	      sreal final_time = (sreal)this_time * freq;
-	      prob = eliminated_by_inlining_prob (stmt);
+	      prob = eliminated_by_inlining_prob (&fbi, stmt);
 	      if (prob == 1 && dump_file && (dump_flags & TDF_DETAILS))
 		fprintf (dump_file,
 			 "\t\t50%% will be eliminated by inlining\n");
 	      if (prob == 2 && dump_file && (dump_flags & TDF_DETAILS))
 		fprintf (dump_file, "\t\tWill be eliminated by inlining\n");
-	      struct predicate p = bb_predicate & will_be_nonconstant;
+	      class predicate p = bb_predicate & will_be_nonconstant;
 	      /* We can ignore statement when we proved it is never going
-		 to happen, but we can not do that for call statements
+		 to happen, but we cannot do that for call statements
 		 because edges are accounted specially.  */
 	      if (*(is_gimple_call (stmt) ? &bb_predicate : &p) != false)
 		{
 		  time += final_time;
 		{
 		  if (prob)
 		    {
 		      predicate ip = bb_predicate & predicate::not_inlined ();
 		      info->account_size_time (this_size * prob,
-					       (this_time * prob) / 2, ip,
+					       (final_time * prob) / 2, ip,
 					       p);
 		    }
 		  if (prob != 2)
 		    info->account_size_time (this_size * (2 - prob),
-					     (this_time * (2 - prob) / 2),
+					     (final_time * (2 - prob) / 2),
 					     bb_predicate,
 					     p);
 		}
 	      if (!info->fp_expressions && fp_expression_p (stmt))
 		{
 		  info->fp_expressions = true;
 		  if (dump_file)
 		    fprintf (dump_file, "   fp_expression set\n");
 		}
+	    }
-	      gcc_assert (time >= 0);
-	      gcc_assert (size >= 0);
+	  /* Account cost of address calculations in the statements.  */
-	    }
+	  for (unsigned int i = 0; i < gimple_num_ops (stmt); i++)
-	}
+	    {
-}
+	      for (tree op = gimple_op (stmt, i);
-set_hint_predicate (&ipa_fn_summaries->get_create (node)->array_index,
+		   op && handled_component_p (op);
-		      array_index);
+		   op = TREE_OPERAND (op, 0))
+	        if ((TREE_CODE (op) == ARRAY_REF
+		     || TREE_CODE (op) == ARRAY_RANGE_REF)
+		    && TREE_CODE (TREE_OPERAND (op, 1)) == SSA_NAME)
+		  {
+		    predicate p = bb_predicate;
+		    if (fbi.info)
+		      p = p & will_be_nonconstant_expr_predicate
+				 (&fbi, info, params_summary,
+				  TREE_OPERAND (op, 1),
+			          nonconstant_names);
+		    if (p != false)
+		      {
+			time += freq;
+			size += 1;
+			if (dump_file)
+			  fprintf (dump_file,
+				   "\t\tAccounting address calculation.\n");
+			info->account_size_time (ipa_fn_summary::size_scale,
+						 freq,
+						 bb_predicate,
+						 p);
+		      }
+		  }
+	    }
+	}
+}
 free (order);
 if (nonconstant_names.exists () && !early)
 {
-struct loop *loop;
+class loop *loop;
 predicate loop_iterations = true;
 predicate loop_stride = true;
 if (dump_file && (dump_flags & TDF_DETAILS))
 	flow_loops_dump (dump_file, NULL, 0);
 FOR_EACH_LOOP (loop, 0)
 	{
 	  vec<edge> exits;
 	  edge ex;
 	  unsigned int j;
-	  struct tree_niter_desc niter_desc;
+	  class tree_niter_desc niter_desc;
 	  bb_predicate = *(predicate *) loop->header->aux;
 	  exits = get_loop_exit_edges (loop);
 	  FOR_EACH_VEC_ELT (exits, j, ex)
 	    if (number_of_iterations_exit (loop, ex, &niter_desc, false)
 		&& !is_gimple_min_invariant (niter_desc.niter))
 	    {
 	      predicate will_be_nonconstant
-		= will_be_nonconstant_expr_predicate (fbi.info, info,
+		= will_be_nonconstant_expr_predicate (&fbi, info,
+						      params_summary,
 						      niter_desc.niter,
 						      nonconstant_names);
 	      if (will_be_nonconstant != true)
 		will_be_nonconstant = bb_predicate & will_be_nonconstant;
 	      if (will_be_nonconstant != true
 				  def, &iv, true)
 		      || is_gimple_min_invariant (iv.step))
 		    continue;
 		  predicate will_be_nonconstant
-		    = will_be_nonconstant_expr_predicate (fbi.info, info,
+		    = will_be_nonconstant_expr_predicate (&fbi, info,
-							  iv.step,
+				    			  params_summary,
+				   			  iv.step,
 							  nonconstant_names);
 		  if (will_be_nonconstant != true)
 		    will_be_nonconstant = bb_predicate & will_be_nonconstant;
 		  if (will_be_nonconstant != true
 		      && will_be_nonconstant != false)
 	    edge_predicate_pool.remove ((predicate *) e->aux);
 	  e->aux = NULL;
 	}
 }
 ipa_fn_summary *s = ipa_fn_summaries->get (node);
+ipa_size_summary *ss = ipa_size_summaries->get (node);
 s->time = time;
-s->self_size = size;
+ss->self_size = size;
 nonconstant_names.release ();
 ipa_release_body_info (&fbi);
 if (opt_for_fn (node->decl, optimize))
 {
 if (!early)
 loop_optimizer_finalize ();
 else if (!ipa_edge_args_sum)
 	ipa_free_all_node_params ();
 free_dominance_info (CDI_DOMINATORS);
+free_dominance_info (CDI_POST_DOMINATORS);
 }
 if (dump_file)
 {
 fprintf (dump_file, "\n");
 ipa_dump_fn_summary (dump_file, node);
 void
 compute_fn_summary (struct cgraph_node *node, bool early)
 {
 HOST_WIDE_INT self_stack_size;
 struct cgraph_edge *e;
-struct ipa_fn_summary *info;
+gcc_assert (!node->inlined_to);
-gcc_assert (!node->global.inlined_to);
 if (!ipa_fn_summaries)
 ipa_fn_summary_alloc ();
 /* Create a new ipa_fn_summary.  */
 ((ipa_fn_summary_t *)ipa_fn_summaries)->remove_callees (node);
 ipa_fn_summaries->remove (node);
-info = ipa_fn_summaries->get_create (node);
+class ipa_fn_summary *info = ipa_fn_summaries->get_create (node);
+class ipa_size_summary *size_info = ipa_size_summaries->get_create (node);
 /* Estimate the stack size for the function if we're optimizing.  */
 self_stack_size = optimize && !node->thunk.thunk_p
 		    ? estimated_stack_frame_size (node) : 0;
-info->estimated_self_stack_size = self_stack_size;
+size_info->estimated_self_stack_size = self_stack_size;
 info->estimated_stack_size = self_stack_size;
-info->stack_frame_offset = 0;
 if (node->thunk.thunk_p)
 {
 ipa_call_summary *es = ipa_call_summaries->get_create (node->callees);
 predicate t = true;
-node->local.can_change_signature = false;
+node->can_change_signature = false;
 es->call_stmt_size = eni_size_weights.call_cost;
 es->call_stmt_time = eni_time_weights.call_cost;
-info->account_size_time (ipa_fn_summary::size_scale * 2, 2, t, t);
+info->account_size_time (ipa_fn_summary::size_scale
+			       * opt_for_fn (node->decl,
+				 param_uninlined_function_thunk_insns),
+			       opt_for_fn (node->decl,
+				 param_uninlined_function_thunk_time), t, t);
 t = predicate::not_inlined ();
 info->account_size_time (2 * ipa_fn_summary::size_scale, 0, t, t);
 ipa_update_overall_fn_summary (node);
-info->self_size = info->size;
+size_info->self_size = size_info->size;
-/* We can not inline instrumentation clones.  */
+if (stdarg_p (TREE_TYPE (node->decl)))
-if (node->thunk.add_pointer_bounds_args)
-	{
-info->inlinable = false;
-node->callees->inline_failed = CIF_CHKP;
-	}
-else if (stdarg_p (TREE_TYPE (node->decl)))
 	{
 	  info->inlinable = false;
 	  node->callees->inline_failed = CIF_VARIADIC_THUNK;
 	}
 else
 }
 else
 {
 /* Even is_gimple_min_invariant rely on current_function_decl.  */
 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
+/* During IPA profile merging we may be called w/o virtual SSA form
+	  built.  */
+update_ssa (TODO_update_ssa_only_virtuals);
 /* Can this function be inlined at all?  */
 if (!opt_for_fn (node->decl, optimize)
 	   && !lookup_attribute ("always_inline",
 				 DECL_ATTRIBUTES (node->decl)))
 if (TYPE_ATTRIBUTES (TREE_TYPE (node->decl))
 	   /* Likewise for #pragma omp declare simd functions or functions
 	      with simd attribute.  */
 	   || lookup_attribute ("omp declare simd",
 				DECL_ATTRIBUTES (node->decl)))
-	 node->local.can_change_signature = false;
+	 node->can_change_signature = false;
 else
 	 {
 	   /* Otherwise, inlinable functions always can change signature.  */
 	   if (info->inlinable)
-	     node->local.can_change_signature = true;
+	     node->can_change_signature = true;
 	   else
 	     {
-	       /* Functions calling builtin_apply can not change signature.  */
+	       /* Functions calling builtin_apply cannot change signature.  */
 	       for (e = node->callees; e; e = e->next_callee)
 		 {
 		   tree cdecl = e->callee->decl;
 		   if (fndecl_built_in_p (cdecl, BUILT_IN_APPLY_ARGS)
 		       || fndecl_built_in_p (cdecl, BUILT_IN_VA_START))
 		     break;
 		 }
-	       node->local.can_change_signature = !e;
+	       node->can_change_signature = !e;
 	     }
 	 }
-/* Functions called by instrumentation thunk can't change signature
-	  because instrumentation thunk modification is not supported.  */
-if (node->local.can_change_signature)
-	 for (e = node->callers; e; e = e->next_caller)
-	   if (e->caller->thunk.thunk_p
-	       && e->caller->thunk.add_pointer_bounds_args)
-	     {
-	       node->local.can_change_signature = false;
-	       break;
-	     }
 analyze_function_body (node, early);
 pop_cfun ();
 }
 for (e = node->callees; e; e = e->next_callee)
 if (e->callee->comdat_local_p ())
 break;
 node->calls_comdat_local = (e != NULL);
 /* Inlining characteristics are maintained by the cgraph_mark_inline.  */
-info->size = info->self_size;
+size_info->size = size_info->self_size;
-info->stack_frame_offset = 0;
+info->estimated_stack_size = size_info->estimated_self_stack_size;
-info->estimated_stack_size = info->estimated_self_stack_size;
 /* Code above should compute exactly the same result as
 ipa_update_overall_fn_summary but because computation happens in
 different order the roundoff errors result in slight changes.  */
 ipa_update_overall_fn_summary (node);
-gcc_assert (info->size == info->self_size);
+/* In LTO mode we may have speculative edges set.  */
+gcc_assert (in_lto_p || size_info->size == size_info->self_size);
 }
 /* Compute parameters of functions used by inliner using
 current_function_decl.  */
 static bool
 estimate_edge_devirt_benefit (struct cgraph_edge *ie,
 			      int *size, int *time,
 			      vec<tree> known_vals,
 			      vec<ipa_polymorphic_call_context> known_contexts,
-			      vec<ipa_agg_jump_function_p> known_aggs)
+			      vec<ipa_agg_value_set> known_aggs)
 {
 tree target;
 struct cgraph_node *callee;
-struct ipa_fn_summary *isummary;
+class ipa_fn_summary *isummary;
 enum availability avail;
 bool speculative;
-if (!known_vals.exists () && !known_contexts.exists ())
+if (!known_vals.length () && !known_contexts.length ())
 return false;
 if (!opt_for_fn (ie->caller->decl, flag_indirect_inlining))
 return false;
 target = ipa_get_indirect_edge_target (ie, known_vals, known_contexts,
 return false;
 callee = callee->function_symbol (&avail);
 if (avail < AVAIL_AVAILABLE)
 return false;
 isummary = ipa_fn_summaries->get (callee);
+if (isummary == NULL)
+return false;
 return isummary->inlinable;
 }
 /* Increase SIZE, MIN_SIZE (if non-NULL) and TIME for size and time needed to
 handle edge E with probability PROB.
 site.  */
 static inline void
 estimate_edge_size_and_time (struct cgraph_edge *e, int *size, int *min_size,
 			     sreal *time,
-			     int prob,
 			     vec<tree> known_vals,
 			     vec<ipa_polymorphic_call_context> known_contexts,
-			     vec<ipa_agg_jump_function_p> known_aggs,
+			     vec<ipa_agg_value_set> known_aggs,
 			     ipa_hints *hints)
 {
-struct ipa_call_summary *es = ipa_call_summaries->get (e);
+class ipa_call_summary *es = ipa_call_summaries->get (e);
 int call_size = es->call_stmt_size;
 int call_time = es->call_stmt_time;
 int cur_size;
-if (!e->callee
+if (!e->callee && hints && e->maybe_hot_p ()
 && estimate_edge_devirt_benefit (e, &call_size, &call_time,
-				       known_vals, known_contexts, known_aggs)
+				       known_vals, known_contexts, known_aggs))
-&& hints && e->maybe_hot_p ())
 *hints |= INLINE_HINT_indirect_call;
 cur_size = call_size * ipa_fn_summary::size_scale;
 *size += cur_size;
 if (min_size)
 *min_size += cur_size;
-if (prob == REG_BR_PROB_BASE)
+if (time)
 *time += ((sreal)call_time) * e->sreal_frequency ();
-else
+}
-*time += ((sreal)call_time * prob) * e->sreal_frequency ();
-}
+/* Increase SIZE, MIN_SIZE and TIME for size and time needed to handle all
+calls in NODE.  POSSIBLE_TRUTHS, KNOWN_VALS, KNOWN_AGGS and KNOWN_CONTEXTS
+describe context of the call site.
+Helper for estimate_calls_size_and_time which does the same but
+(in most cases) faster.  */
+static void
+estimate_calls_size_and_time_1 (struct cgraph_node *node, int *size,
+			        int *min_size, sreal *time,
+			        ipa_hints *hints,
+			        clause_t possible_truths,
+			        vec<tree> known_vals,
+			        vec<ipa_polymorphic_call_context> known_contexts,
+			        vec<ipa_agg_value_set> known_aggs)
+{
+struct cgraph_edge *e;
+for (e = node->callees; e; e = e->next_callee)
+{
+if (!e->inline_failed)
+	{
+	  gcc_checking_assert (!ipa_call_summaries->get (e));
+	  estimate_calls_size_and_time_1 (e->callee, size, min_size, time,
+					  hints,
+					  possible_truths,
+					  known_vals, known_contexts,
+					  known_aggs);
+	  continue;
+	}
+class ipa_call_summary *es = ipa_call_summaries->get (e);
+/* Do not care about zero sized builtins.  */
+if (!es->call_stmt_size)
+	{
+	  gcc_checking_assert (!es->call_stmt_time);
+	  continue;
+	}
+if (!es->predicate
+	  || es->predicate->evaluate (possible_truths))
+	{
+	  /* Predicates of calls shall not use NOT_CHANGED codes,
+	     so we do not need to compute probabilities.  */
+	  estimate_edge_size_and_time (e, size,
+				       es->predicate ? NULL : min_size,
+				       time,
+				       known_vals, known_contexts,
+				       known_aggs, hints);
+	}
+}
+for (e = node->indirect_calls; e; e = e->next_callee)
+{
+class ipa_call_summary *es = ipa_call_summaries->get (e);
+if (!es->predicate
+	  || es->predicate->evaluate (possible_truths))
+	estimate_edge_size_and_time (e, size,
+				     es->predicate ? NULL : min_size,
+				     time,
+				     known_vals, known_contexts, known_aggs,
+				     hints);
+}
+}
+/* Populate sum->call_size_time_table for edges from NODE.  */
+static void
+summarize_calls_size_and_time (struct cgraph_node *node,
+			       ipa_fn_summary *sum)
+{
+struct cgraph_edge *e;
+for (e = node->callees; e; e = e->next_callee)
+{
+if (!e->inline_failed)
+	{
+	  gcc_checking_assert (!ipa_call_summaries->get (e));
+	  summarize_calls_size_and_time (e->callee, sum);
+	  continue;
+	}
+int size = 0;
+sreal time = 0;
+estimate_edge_size_and_time (e, &size, NULL, &time,
+				   vNULL, vNULL, vNULL, NULL);
+struct predicate pred = true;
+class ipa_call_summary *es = ipa_call_summaries->get (e);
+if (es->predicate)
+	pred = *es->predicate;
+sum->account_size_time (size, time, pred, pred, true);
+}
+for (e = node->indirect_calls; e; e = e->next_callee)
+{
+int size = 0;
+sreal time = 0;
+estimate_edge_size_and_time (e, &size, NULL, &time,
+				   vNULL, vNULL, vNULL, NULL);
+struct predicate pred = true;
+class ipa_call_summary *es = ipa_call_summaries->get (e);
+if (es->predicate)
+	pred = *es->predicate;
+sum->account_size_time (size, time, pred, pred, true);
+}
+}
 /* Increase SIZE, MIN_SIZE and TIME for size and time needed to handle all
 calls in NODE.  POSSIBLE_TRUTHS, KNOWN_VALS, KNOWN_AGGS and KNOWN_CONTEXTS
 describe context of the call site.  */
 			      int *min_size, sreal *time,
 			      ipa_hints *hints,
 			      clause_t possible_truths,
 			      vec<tree> known_vals,
 			      vec<ipa_polymorphic_call_context> known_contexts,
-			      vec<ipa_agg_jump_function_p> known_aggs)
+			      vec<ipa_agg_value_set> known_aggs)
 {
-struct cgraph_edge *e;
+class ipa_fn_summary *sum = ipa_fn_summaries->get (node);
-for (e = node->callees; e; e = e->next_callee)
+bool use_table = true;
-{
-struct ipa_call_summary *es = ipa_call_summaries->get_create (e);
+gcc_assert (node->callees || node->indirect_calls);
-/* Do not care about zero sized builtins.  */
+/* During early inlining we do not calculate info for very
-if (e->inline_failed && !es->call_stmt_size)
+large functions and thus there is no need for producing
-	{
+summaries.  */
-	  gcc_checking_assert (!es->call_stmt_time);
+if (!ipa_node_params_sum)
-	  continue;
+use_table = false;
-	}
+/* Do not calculate summaries for simple wrappers; it is waste
-if (!es->predicate
+of memory.  */
-	  || es->predicate->evaluate (possible_truths))
+else if (node->callees && node->indirect_calls
-	{
+&& node->callees->inline_failed && !node->callees->next_callee)
-	  if (e->inline_failed)
+use_table = false;
-	    {
+/* If there is an indirect edge that may be optimized, we need
-	      /* Predicates of calls shall not use NOT_CHANGED codes,
+to go the slow way.  */
-	         sowe do not need to compute probabilities.  */
+else if ((known_vals.length ()
-	      estimate_edge_size_and_time (e, size,
+	    || known_contexts.length ()
-					   es->predicate ? NULL : min_size,
+	    || known_aggs.length ()) && hints)
-					   time, REG_BR_PROB_BASE,
+{
-					   known_vals, known_contexts,
+class ipa_node_params *params_summary = IPA_NODE_REF (node);
-					   known_aggs, hints);
+unsigned int nargs = params_summary
-	    }
+			   ? ipa_get_param_count (params_summary) : 0;
-	  else
-	    estimate_calls_size_and_time (e->callee, size, min_size, time,
+for (unsigned int i = 0; i < nargs && use_table; i++)
-					  hints,
+	{
-					  possible_truths,
+	  if (ipa_is_param_used_by_indirect_call (params_summary, i)
-					  known_vals, known_contexts,
+	      && ((known_vals.length () > i && known_vals[i])
-					  known_aggs);
+		  || (known_aggs.length () > i
-	}
+		      && known_aggs[i].items.length ())))
-}
+	    use_table = false;
-for (e = node->indirect_calls; e; e = e->next_callee)
+	  else if (ipa_is_param_used_by_polymorphic_call (params_summary, i)
-{
+		   && (known_contexts.length () > i
-struct ipa_call_summary *es = ipa_call_summaries->get_create (e);
+		       && !known_contexts[i].useless_p ()))
-if (!es->predicate
+	    use_table = false;
-	  || es->predicate->evaluate (possible_truths))
+	}
-	estimate_edge_size_and_time (e, size,
+}
-				     es->predicate ? NULL : min_size,
-				     time, REG_BR_PROB_BASE,
+/* Fast path is via the call size time table.  */
-				     known_vals, known_contexts, known_aggs,
+if (use_table)
-				     hints);
+{
-}
+/* Build summary if it is absent.  */
-}
+if (!sum->call_size_time_table)
+	{
+	  predicate true_pred = true;
-/* Estimate size and time needed to execute NODE assuming
+	  sum->account_size_time (0, 0, true_pred, true_pred, true);
-POSSIBLE_TRUTHS clause, and KNOWN_VALS, KNOWN_AGGS and KNOWN_CONTEXTS
+	  summarize_calls_size_and_time (node, sum);
-information about NODE's arguments.  If non-NULL use also probability
+	}
-information present in INLINE_PARAM_SUMMARY vector.
-Additionally detemine hints determined by the context.  Finally compute
+int old_size = *size;
+sreal old_time = time ? *time : 0;
+if (min_size)
+	*min_size += (*sum->call_size_time_table)[0].size;
+unsigned int i;
+size_time_entry *e;
+/* Walk the table and account sizes and times.  */
+for (i = 0; vec_safe_iterate (sum->call_size_time_table, i, &e);
+	   i++)
+	if (e->exec_predicate.evaluate (possible_truths))
+	  {
+	    *size += e->size;
+	    if (time)
+	      *time += e->time;
+	  }
+/* Be careful and see if both methods agree.  */
+if ((flag_checking || dump_file)
+	  /* Do not try to sanity check when we know we lost some
+	     precision.  */
+	  && sum->call_size_time_table->length ()
+	     < ipa_fn_summary::max_size_time_table_size)
+	{
+	  estimate_calls_size_and_time_1 (node, &old_size, NULL, &old_time, NULL,
+					  possible_truths, known_vals,
+					  known_contexts, known_aggs);
+	  gcc_assert (*size == old_size);
+	  if (time && (*time - old_time > 1 || *time - old_time < -1)
+	      && dump_file)
+	    fprintf (dump_file, "Time mismatch in call summary %f!=%f\n",
+		     old_time.to_double (),
+		     time->to_double ());
+	}
+}
+/* Slow path by walking all edges.  */
+else
+estimate_calls_size_and_time_1 (node, size, min_size, time, hints,
+				    possible_truths, known_vals, known_contexts,
+				    known_aggs);
+}
+/* Default constructor for ipa call context.
+Memory allocation of known_vals, known_contexts
+and known_aggs vectors is owned by the caller, but can
+be release by ipa_call_context::release.
+inline_param_summary is owned by the caller.  */
+ipa_call_context::ipa_call_context (cgraph_node *node,
+				    clause_t possible_truths,
+				    clause_t nonspec_possible_truths,
+				    vec<tree> known_vals,
+				    vec<ipa_polymorphic_call_context>
+				   	 known_contexts,
+				    vec<ipa_agg_value_set> known_aggs,
+				    vec<inline_param_summary>
+				   	 inline_param_summary)
+: m_node (node), m_possible_truths (possible_truths),
+m_nonspec_possible_truths (nonspec_possible_truths),
+m_inline_param_summary (inline_param_summary),
+m_known_vals (known_vals),
+m_known_contexts (known_contexts),
+m_known_aggs (known_aggs)
+{
+}
+/* Set THIS to be a duplicate of CTX.  Copy all relevant info.  */
+void
+ipa_call_context::duplicate_from (const ipa_call_context &ctx)
+{
+m_node = ctx.m_node;
+m_possible_truths = ctx.m_possible_truths;
+m_nonspec_possible_truths = ctx.m_nonspec_possible_truths;
+class ipa_node_params *params_summary = IPA_NODE_REF (m_node);
+unsigned int nargs = params_summary
+		       ? ipa_get_param_count (params_summary) : 0;
+m_inline_param_summary = vNULL;
+/* Copy the info only if there is at least one useful entry.  */
+if (ctx.m_inline_param_summary.exists ())
+{
+unsigned int n = MIN (ctx.m_inline_param_summary.length (), nargs);
+for (unsigned int i = 0; i < n; i++)
+	if (ipa_is_param_used_by_ipa_predicates (params_summary, i)
+	    && !ctx.m_inline_param_summary[i].useless_p ())
+	  {
+m_inline_param_summary
+		    = ctx.m_inline_param_summary.copy ();
+	    break;
+	  }
+}
+m_known_vals = vNULL;
+if (ctx.m_known_vals.exists ())
+{
+unsigned int n = MIN (ctx.m_known_vals.length (), nargs);
+for (unsigned int i = 0; i < n; i++)
+	if (ipa_is_param_used_by_indirect_call (params_summary, i)
+	    && ctx.m_known_vals[i])
+	  {
+	    m_known_vals = ctx.m_known_vals.copy ();
+	    break;
+	  }
+}
+m_known_contexts = vNULL;
+if (ctx.m_known_contexts.exists ())
+{
+unsigned int n = MIN (ctx.m_known_contexts.length (), nargs);
+for (unsigned int i = 0; i < n; i++)
+	if (ipa_is_param_used_by_polymorphic_call (params_summary, i)
+	    && !ctx.m_known_contexts[i].useless_p ())
+	  {
+	    m_known_contexts = ctx.m_known_contexts.copy ();
+	    break;
+	  }
+}
+m_known_aggs = vNULL;
+if (ctx.m_known_aggs.exists ())
+{
+unsigned int n = MIN (ctx.m_known_aggs.length (), nargs);
+for (unsigned int i = 0; i < n; i++)
+	if (ipa_is_param_used_by_indirect_call (params_summary, i)
+	    && !ctx.m_known_aggs[i].is_empty ())
+	  {
+	    m_known_aggs = ipa_copy_agg_values (ctx.m_known_aggs);
+	    break;
+	  }
+}
+}
+/* Release memory used by known_vals/contexts/aggs vectors.
+If ALL is true release also inline_param_summary.
+This happens when context was previously duplicated to be stored
+into cache.  */
+void
+ipa_call_context::release (bool all)
+{
+/* See if context is initialized at first place.  */
+if (!m_node)
+return;
+ipa_release_agg_values (m_known_aggs, all);
+if (all)
+{
+m_known_vals.release ();
+m_known_contexts.release ();
+m_inline_param_summary.release ();
+}
+}
+/* Return true if CTX describes the same call context as THIS.  */
+bool
+ipa_call_context::equal_to (const ipa_call_context &ctx)
+{
+if (m_node != ctx.m_node
+|| m_possible_truths != ctx.m_possible_truths
+|| m_nonspec_possible_truths != ctx.m_nonspec_possible_truths)
+return false;
+class ipa_node_params *params_summary = IPA_NODE_REF (m_node);
+unsigned int nargs = params_summary
+		       ? ipa_get_param_count (params_summary) : 0;
+if (m_inline_param_summary.exists () || ctx.m_inline_param_summary.exists ())
+{
+for (unsigned int i = 0; i < nargs; i++)
+	{
+	  if (!ipa_is_param_used_by_ipa_predicates (params_summary, i))
+	    continue;
+	  if (i >= m_inline_param_summary.length ()
+	      || m_inline_param_summary[i].useless_p ())
+	    {
+	      if (i < ctx.m_inline_param_summary.length ()
+		  && !ctx.m_inline_param_summary[i].useless_p ())
+		return false;
+	      continue;
+	    }
+	  if (i >= ctx.m_inline_param_summary.length ()
+	      || ctx.m_inline_param_summary[i].useless_p ())
+	    {
+	      if (i < m_inline_param_summary.length ()
+		  && !m_inline_param_summary[i].useless_p ())
+		return false;
+	      continue;
+	    }
+	  if (!m_inline_param_summary[i].equal_to
+	     	 (ctx.m_inline_param_summary[i]))
+	    return false;
+	}
+}
+if (m_known_vals.exists () || ctx.m_known_vals.exists ())
+{
+for (unsigned int i = 0; i < nargs; i++)
+	{
+	  if (!ipa_is_param_used_by_indirect_call (params_summary, i))
+	    continue;
+	  if (i >= m_known_vals.length () || !m_known_vals[i])
+	    {
+	      if (i < ctx.m_known_vals.length () && ctx.m_known_vals[i])
+		return false;
+	      continue;
+	    }
+	  if (i >= ctx.m_known_vals.length () || !ctx.m_known_vals[i])
+	    {
+	      if (i < m_known_vals.length () && m_known_vals[i])
+		return false;
+	      continue;
+	    }
+	  if (m_known_vals[i] != ctx.m_known_vals[i])
+	    return false;
+	}
+}
+if (m_known_contexts.exists () || ctx.m_known_contexts.exists ())
+{
+for (unsigned int i = 0; i < nargs; i++)
+	{
+	  if (!ipa_is_param_used_by_polymorphic_call (params_summary, i))
+	    continue;
+	  if (i >= m_known_contexts.length ()
+	      || m_known_contexts[i].useless_p ())
+	    {
+	      if (i < ctx.m_known_contexts.length ()
+		  && !ctx.m_known_contexts[i].useless_p ())
+		return false;
+	      continue;
+	    }
+	  if (i >= ctx.m_known_contexts.length ()
+	      || ctx.m_known_contexts[i].useless_p ())
+	    {
+	      if (i < m_known_contexts.length ()
+		  && !m_known_contexts[i].useless_p ())
+		return false;
+	      continue;
+	    }
+	  if (!m_known_contexts[i].equal_to
+	     	 (ctx.m_known_contexts[i]))
+	    return false;
+	}
+}
+if (m_known_aggs.exists () || ctx.m_known_aggs.exists ())
+{
+for (unsigned int i = 0; i < nargs; i++)
+	{
+	  if (!ipa_is_param_used_by_indirect_call (params_summary, i))
+	    continue;
+	  if (i >= m_known_aggs.length () || m_known_aggs[i].is_empty ())
+	    {
+	      if (i < ctx.m_known_aggs.length ()
+		  && !ctx.m_known_aggs[i].is_empty ())
+		return false;
+	      continue;
+	    }
+	  if (i >= ctx.m_known_aggs.length ()
+	      || ctx.m_known_aggs[i].is_empty ())
+	    {
+	      if (i < m_known_aggs.length ()
+		  && !m_known_aggs[i].is_empty ())
+		return false;
+	      continue;
+	    }
+	  if (!m_known_aggs[i].equal_to (ctx.m_known_aggs[i]))
+	    return false;
+	}
+}
+return true;
+}
+/* Estimate size and time needed to execute call in the given context.
+Additionally determine hints determined by the context.  Finally compute
 minimal size needed for the call that is independent on the call context and
 can be used for fast estimates.  Return the values in RET_SIZE,
 RET_MIN_SIZE, RET_TIME and RET_HINTS.  */
 void
-estimate_node_size_and_time (struct cgraph_node *node,
+ipa_call_context::estimate_size_and_time (int *ret_size,
-			     clause_t possible_truths,
+					  int *ret_min_size,
-			     clause_t nonspec_possible_truths,
+					  sreal *ret_time,
-			     vec<tree> known_vals,
+					  sreal *ret_nonspecialized_time,
-			     vec<ipa_polymorphic_call_context> known_contexts,
+					  ipa_hints *ret_hints)
-			     vec<ipa_agg_jump_function_p> known_aggs,
+{
-			     int *ret_size, int *ret_min_size,
+class ipa_fn_summary *info = ipa_fn_summaries->get (m_node);
-			     sreal *ret_time,
-			     sreal *ret_nonspecialized_time,
-			     ipa_hints *ret_hints,
-			     vec<inline_param_summary>
-			     inline_param_summary)
-{
-struct ipa_fn_summary *info = ipa_fn_summaries->get_create (node);
 size_time_entry *e;
 int size = 0;
 sreal time = 0;
 int min_size = 0;
 ipa_hints hints = 0;
 int i;
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 bool found = false;
-fprintf (dump_file, "   Estimating body: %s/%i\n"
+fprintf (dump_file, "   Estimating body: %s\n"
-	       "   Known to be false: ", node->name (),
+	       "   Known to be false: ", m_node->dump_name ());
-	       node->order);
 for (i = predicate::not_inlined_condition;
 	   i < (predicate::first_dynamic_condition
 		+ (int) vec_safe_length (info->conds)); i++)
-	if (!(possible_truths & (1 << i)))
+	if (!(m_possible_truths & (1 << i)))
 	  {
 	    if (found)
 	      fprintf (dump_file, ", ");
 	    found = true;
 	    dump_condition (dump_file, info->conds, i);
 	  }
 }
-estimate_calls_size_and_time (node, &size, &min_size, &time, &hints, possible_truths,
+if (m_node->callees || m_node->indirect_calls)
-				known_vals, known_contexts, known_aggs);
+estimate_calls_size_and_time (m_node, &size, &min_size,
+				  ret_time ? &time : NULL,
+				  ret_hints ? &hints : NULL, m_possible_truths,
+				  m_known_vals, m_known_contexts, m_known_aggs);
 sreal nonspecialized_time = time;
+min_size += (*info->size_time_table)[0].size;
 for (i = 0; vec_safe_iterate (info->size_time_table, i, &e); i++)
 {
-bool exec = e->exec_predicate.evaluate (nonspec_possible_truths);
+bool exec = e->exec_predicate.evaluate (m_nonspec_possible_truths);
 /* Because predicates are conservative, it can happen that nonconst is 1
 	 but exec is 0.  */
 if (exec)
 {
-bool nonconst = e->nonconst_predicate.evaluate (possible_truths);
+bool nonconst = e->nonconst_predicate.evaluate (m_possible_truths);
 	  gcc_checking_assert (e->time >= 0);
 	  gcc_checking_assert (time >= 0);
 	  /* We compute specialized size only because size of nonspecialized
 	     The difference between nonspecialized execution and specialized is
 	     that nonspecialized is not going to have optimized out computations
 	     known to be constant in a specialized setting.  */
 	  if (nonconst)
 	    size += e->size;
+	  if (!ret_time)
+	    continue;
 	  nonspecialized_time += e->time;
 	  if (!nonconst)
 	    ;
-	  else if (!inline_param_summary.exists ())
+	  else if (!m_inline_param_summary.exists ())
 	    {
 	      if (nonconst)
 	        time += e->time;
 	    }
 	  else
 	    {
 	      int prob = e->nonconst_predicate.probability
-					       (info->conds, possible_truths,
+					       (info->conds, m_possible_truths,
-					        inline_param_summary);
+					        m_inline_param_summary);
 	      gcc_checking_assert (prob >= 0);
 	      gcc_checking_assert (prob <= REG_BR_PROB_BASE);
-	      time += e->time * prob / REG_BR_PROB_BASE;
+	      if (prob == REG_BR_PROB_BASE)
+	        time += e->time;
+	      else
+	        time += e->time * prob / REG_BR_PROB_BASE;
 	    }
 	  gcc_checking_assert (time >= 0);
 }
 }
 gcc_checking_assert ((*info->size_time_table)[0].exec_predicate == true);
 gcc_checking_assert ((*info->size_time_table)[0].nonconst_predicate == true);
-min_size = (*info->size_time_table)[0].size;
+gcc_checking_assert (min_size >= 0);
 gcc_checking_assert (size >= 0);
 gcc_checking_assert (time >= 0);
 /* nonspecialized_time should be always bigger than specialized time.
 Roundoff issues however may get into the way.  */
 gcc_checking_assert ((nonspecialized_time - time * 99 / 100) >= -1);
 /* Roundoff issues may make specialized time bigger than nonspecialized
-time.  We do not really want that to happen because some heurstics
+time.  We do not really want that to happen because some heuristics
 may get confused by seeing negative speedups.  */
 if (time > nonspecialized_time)
 time = nonspecialized_time;
-if (info->loop_iterations
+if (ret_hints)
-&& !info->loop_iterations->evaluate (possible_truths))
+{
-hints |= INLINE_HINT_loop_iterations;
+if (info->loop_iterations
-if (info->loop_stride
+	  && !info->loop_iterations->evaluate (m_possible_truths))
-&& !info->loop_stride->evaluate (possible_truths))
+	hints |= INLINE_HINT_loop_iterations;
-hints |= INLINE_HINT_loop_stride;
+if (info->loop_stride
-if (info->array_index
+	  && !info->loop_stride->evaluate (m_possible_truths))
-&& !info->array_index->evaluate (possible_truths))
+	hints |= INLINE_HINT_loop_stride;
-hints |= INLINE_HINT_array_index;
+if (info->scc_no)
-if (info->scc_no)
+	hints |= INLINE_HINT_in_scc;
-hints |= INLINE_HINT_in_scc;
+if (DECL_DECLARED_INLINE_P (m_node->decl))
-if (DECL_DECLARED_INLINE_P (node->decl))
+	hints |= INLINE_HINT_declared_inline;
-hints |= INLINE_HINT_declared_inline;
+}
 size = RDIV (size, ipa_fn_summary::size_scale);
 min_size = RDIV (min_size, ipa_fn_summary::size_scale);
 if (dump_file && (dump_flags & TDF_DETAILS))
 void
 estimate_ipcp_clone_size_and_time (struct cgraph_node *node,
 				   vec<tree> known_vals,
 				   vec<ipa_polymorphic_call_context>
 				   known_contexts,
-				   vec<ipa_agg_jump_function_p> known_aggs,
+				   vec<ipa_agg_value_set> known_aggs,
 				   int *ret_size, sreal *ret_time,
 				   sreal *ret_nonspec_time,
 				   ipa_hints *hints)
 {
 clause_t clause, nonspec_clause;
-evaluate_conditions_for_known_args (node, false, known_vals, known_aggs,
+/* TODO: Also pass known value ranges.  */
-				      &clause, &nonspec_clause);
+evaluate_conditions_for_known_args (node, false, known_vals, vNULL,
-estimate_node_size_and_time (node, clause, nonspec_clause,
+				      known_aggs, &clause, &nonspec_clause);
-			       known_vals, known_contexts,
+ipa_call_context ctx (node, clause, nonspec_clause,
-			       known_aggs, ret_size, NULL, ret_time,
+		        known_vals, known_contexts,
-			       ret_nonspec_time, hints, vNULL);
+		        known_aggs, vNULL);
+ctx.estimate_size_and_time (ret_size, NULL, ret_time,
+			      ret_nonspec_time, hints);
+}
+/* Return stack frame offset where frame of NODE is supposed to start inside
+of the function it is inlined to.
+Return 0 for functions that are not inlined.  */
+HOST_WIDE_INT
+ipa_get_stack_frame_offset (struct cgraph_node *node)
+{
+HOST_WIDE_INT offset = 0;
+if (!node->inlined_to)
+return 0;
+node = node->callers->caller;
+while (true)
+{
+offset += ipa_size_summaries->get (node)->estimated_self_stack_size;
+if (!node->inlined_to)
+	return offset;
+node = node->callers->caller;
+}
 }
 /* Update summary information of inline clones after inlining.
 Compute peak stack usage.  */
 static void
 inline_update_callee_summaries (struct cgraph_node *node, int depth)
 {
 struct cgraph_edge *e;
-ipa_fn_summary *callee_info = ipa_fn_summaries->get (node);
-ipa_fn_summary *caller_info = ipa_fn_summaries->get (node->callers->caller);
-HOST_WIDE_INT peak;
-callee_info->stack_frame_offset
-= caller_info->stack_frame_offset
-+ caller_info->estimated_self_stack_size;
-peak = callee_info->stack_frame_offset
-+ callee_info->estimated_self_stack_size;
-ipa_fn_summary *s = ipa_fn_summaries->get (node->global.inlined_to);
-if (s->estimated_stack_size < peak)
-s->estimated_stack_size = peak;
 ipa_propagate_frequency (node);
 for (e = node->callees; e; e = e->next_callee)
 {
 if (!e->inline_failed)
 	inline_update_callee_summaries (e->callee, depth);
-ipa_call_summaries->get (e)->loop_depth += depth;
+else
+	ipa_call_summaries->get (e)->loop_depth += depth;
 }
 for (e = node->indirect_calls; e; e = e->next_callee)
 ipa_call_summaries->get (e)->loop_depth += depth;
 }
 /* Update change_prob of EDGE after INLINED_EDGE has been inlined.
-When functoin A is inlined in B and A calls C with parameter that
+When function A is inlined in B and A calls C with parameter that
-changes with probability PROB1 and C is known to be passthroug
+changes with probability PROB1 and C is known to be passthrough
 of argument if B that change with probability PROB2, the probability
 of change is now PROB1*PROB2.  */
 static void
 remap_edge_change_prob (struct cgraph_edge *inlined_edge,
 			struct cgraph_edge *edge)
 {
 if (ipa_node_params_sum)
 {
 int i;
-struct ipa_edge_args *args = IPA_EDGE_REF (edge);
+class ipa_edge_args *args = IPA_EDGE_REF (edge);
-struct ipa_call_summary *es = ipa_call_summaries->get (edge);
+if (!args)
-struct ipa_call_summary *inlined_es
+	return;
+class ipa_call_summary *es = ipa_call_summaries->get (edge);
+class ipa_call_summary *inlined_es
 	= ipa_call_summaries->get (inlined_edge);
+if (es->param.length () == 0)
+	return;
 for (i = 0; i < ipa_get_cs_argument_count (args); i++)
 	{
 	  struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, i);
 	  if (jfunc->type == IPA_JF_PASS_THROUGH
 Also update change probabilities.  */
 static void
 remap_edge_summaries (struct cgraph_edge *inlined_edge,
 		      struct cgraph_node *node,
-		      struct ipa_fn_summary *info,
+		      class ipa_fn_summary *info,
-		      struct ipa_fn_summary *callee_info,
+		      class ipa_node_params *params_summary,
+		      class ipa_fn_summary *callee_info,
 		      vec<int> operand_map,
 		      vec<int> offset_map,
 		      clause_t possible_truths,
 		      predicate *toplev_predicate)
 {
 struct cgraph_edge *e, *next;
 for (e = node->callees; e; e = next)
 {
-struct ipa_call_summary *es = ipa_call_summaries->get (e);
 predicate p;
 next = e->next_callee;
 if (e->inline_failed)
 	{
+class ipa_call_summary *es = ipa_call_summaries->get (e);
 	  remap_edge_change_prob (inlined_edge, e);
 	  if (es->predicate)
 	    {
 	      p = es->predicate->remap_after_inlining
-				     (info, callee_info, operand_map,
+				     (info, params_summary,
+				      callee_info, operand_map,
 				      offset_map, possible_truths,
 				      *toplev_predicate);
 	      edge_set_predicate (e, &p);
 	    }
 	  else
 	    edge_set_predicate (e, toplev_predicate);
 	}
 else
-	remap_edge_summaries (inlined_edge, e->callee, info, callee_info,
+	remap_edge_summaries (inlined_edge, e->callee, info,
+		              params_summary, callee_info,
 			      operand_map, offset_map, possible_truths,
 			      toplev_predicate);
 }
 for (e = node->indirect_calls; e; e = next)
 {
-struct ipa_call_summary *es = ipa_call_summaries->get (e);
+class ipa_call_summary *es = ipa_call_summaries->get (e);
 predicate p;
 next = e->next_callee;
 remap_edge_change_prob (inlined_edge, e);
 if (es->predicate)
 	{
 	  p = es->predicate->remap_after_inlining
-				 (info, callee_info, operand_map, offset_map,
+				 (info, params_summary,
+				  callee_info, operand_map, offset_map,
 			          possible_truths, *toplev_predicate);
 	  edge_set_predicate (e, &p);
 	}
 else
 	edge_set_predicate (e, toplev_predicate);
 }
 /* Same as remap_predicate, but set result into hint *HINT.  */
 static void
-remap_hint_predicate (struct ipa_fn_summary *info,
+remap_hint_predicate (class ipa_fn_summary *info,
-		      struct ipa_fn_summary *callee_info,
+		      class ipa_node_params *params_summary,
+		      class ipa_fn_summary *callee_info,
 		      predicate **hint,
 		      vec<int> operand_map,
 		      vec<int> offset_map,
 		      clause_t possible_truths,
 		      predicate *toplev_predicate)
 predicate p;
 if (!*hint)
 return;
 p = (*hint)->remap_after_inlining
-			 (info, callee_info,
+			 (info, params_summary, callee_info,
 			  operand_map, offset_map,
 			  possible_truths, *toplev_predicate);
 if (p != false && p != true)
 {
 if (!*hint)
 void
 ipa_merge_fn_summary_after_inlining (struct cgraph_edge *edge)
 {
 ipa_fn_summary *callee_info = ipa_fn_summaries->get (edge->callee);
-struct cgraph_node *to = (edge->caller->global.inlined_to
+struct cgraph_node *to = (edge->caller->inlined_to
-			    ? edge->caller->global.inlined_to : edge->caller);
+			    ? edge->caller->inlined_to : edge->caller);
-struct ipa_fn_summary *info = ipa_fn_summaries->get (to);
+class ipa_fn_summary *info = ipa_fn_summaries->get (to);
 clause_t clause = 0;	/* not_inline is known to be false.  */
 size_time_entry *e;
-vec<int> operand_map = vNULL;
+auto_vec<int, 8> operand_map;
-vec<int> offset_map = vNULL;
+auto_vec<int, 8> offset_map;
 int i;
 predicate toplev_predicate;
-predicate true_p = true;
+class ipa_call_summary *es = ipa_call_summaries->get (edge);
-struct ipa_call_summary *es = ipa_call_summaries->get (edge);
+class ipa_node_params *params_summary = (ipa_node_params_sum
+		 			   ? IPA_NODE_REF (to) : NULL);
 if (es->predicate)
 toplev_predicate = *es->predicate;
 else
 toplev_predicate = true;
 info->fp_expressions |= callee_info->fp_expressions;
 if (callee_info->conds)
-evaluate_properties_for_edge (edge, true, &clause, NULL, NULL, NULL, NULL);
+{
+auto_vec<tree, 32> known_vals;
+auto_vec<ipa_agg_value_set, 32> known_aggs;
+evaluate_properties_for_edge (edge, true, &clause, NULL,
+				    &known_vals, NULL, &known_aggs);
+}
 if (ipa_node_params_sum && callee_info->conds)
 {
-struct ipa_edge_args *args = IPA_EDGE_REF (edge);
+class ipa_edge_args *args = IPA_EDGE_REF (edge);
-int count = ipa_get_cs_argument_count (args);
+int count = args ? ipa_get_cs_argument_count (args) : 0;
 int i;
 if (count)
 	{
 	  operand_map.safe_grow_cleared (count);
 		    offset = -1;
 		  offset_map[i] = offset;
 		}
 	    }
 	  operand_map[i] = map;
-	  gcc_assert (map < ipa_get_param_count (IPA_NODE_REF (to)));
+	  gcc_assert (map < ipa_get_param_count (params_summary));
 	}
 }
+sreal freq =  edge->sreal_frequency ();
 for (i = 0; vec_safe_iterate (callee_info->size_time_table, i, &e); i++)
 {
 predicate p;
 p = e->exec_predicate.remap_after_inlining
-			     (info, callee_info, operand_map,
+			     (info, params_summary,
+			      callee_info, operand_map,
 			      offset_map, clause,
 			      toplev_predicate);
 predicate nonconstp;
 nonconstp = e->nonconst_predicate.remap_after_inlining
-				     (info, callee_info, operand_map,
+				     (info, params_summary,
+				      callee_info, operand_map,
 				      offset_map, clause,
 				      toplev_predicate);
 if (p != false && nonconstp != false)
 	{
-	  sreal add_time = ((sreal)e->time * edge->sreal_frequency ());
+	  sreal add_time = ((sreal)e->time * freq);
 	  int prob = e->nonconst_predicate.probability (callee_info->conds,
 							clause, es->param);
-	  add_time = add_time * prob / REG_BR_PROB_BASE;
+	  if (prob != REG_BR_PROB_BASE)
+	    add_time = add_time * prob / REG_BR_PROB_BASE;
 	  if (prob != REG_BR_PROB_BASE
 	      && dump_file && (dump_flags & TDF_DETAILS))
 	    {
 	      fprintf (dump_file, "\t\tScaling time by probability:%f\n",
 		       (double) prob / REG_BR_PROB_BASE);
 	    }
 	  info->account_size_time (e->size, add_time, p, nonconstp);
 	}
 }
-remap_edge_summaries (edge, edge->callee, info, callee_info, operand_map,
+remap_edge_summaries (edge, edge->callee, info, params_summary,
+		 	callee_info, operand_map,
 			offset_map, clause, &toplev_predicate);
-remap_hint_predicate (info, callee_info,
+remap_hint_predicate (info, params_summary, callee_info,
 			&callee_info->loop_iterations,
 			operand_map, offset_map, clause, &toplev_predicate);
-remap_hint_predicate (info, callee_info,
+remap_hint_predicate (info, params_summary, callee_info,
 			&callee_info->loop_stride,
 			operand_map, offset_map, clause, &toplev_predicate);
-remap_hint_predicate (info, callee_info,
-			&callee_info->array_index,
+HOST_WIDE_INT stack_frame_offset = ipa_get_stack_frame_offset (edge->callee);
-			operand_map, offset_map, clause, &toplev_predicate);
+HOST_WIDE_INT peak = stack_frame_offset + callee_info->estimated_stack_size;
-ipa_call_summary *s = ipa_call_summaries->get (edge);
+if (info->estimated_stack_size < peak)
-inline_update_callee_summaries (edge->callee, s->loop_depth);
+info->estimated_stack_size = peak;
-/* We do not maintain predicates of inlined edges, free it.  */
+inline_update_callee_summaries (edge->callee, es->loop_depth);
-edge_set_predicate (edge, &true_p);
+if (info->call_size_time_table)
-/* Similarly remove param summaries.  */
+{
-es->param.release ();
+int edge_size = 0;
-operand_map.release ();
+sreal edge_time = 0;
-offset_map.release ();
-}
+estimate_edge_size_and_time (edge, &edge_size, NULL, &edge_time, vNULL,
+		      		   vNULL, vNULL, 0);
-/* For performance reasons ipa_merge_fn_summary_after_inlining is not updating overall size
+/* Unaccount size and time of the optimized out call.  */
-and time.  Recompute it.  */
+info->account_size_time (-edge_size, -edge_time,
+	 		       es->predicate ? *es->predicate : true,
+	 		       es->predicate ? *es->predicate : true,
+			       true);
+/* Account new calls.  */
+summarize_calls_size_and_time (edge->callee, info);
+}
+/* Free summaries that are not maintained for inline clones/edges.  */
+ipa_call_summaries->remove (edge);
+ipa_fn_summaries->remove (edge->callee);
+ipa_remove_from_growth_caches (edge);
+}
+/* For performance reasons ipa_merge_fn_summary_after_inlining is not updating
+overall size and time.  Recompute it.
+If RESET is true also recompute call_time_size_table.  */
 void
-ipa_update_overall_fn_summary (struct cgraph_node *node)
+ipa_update_overall_fn_summary (struct cgraph_node *node, bool reset)
 {
-struct ipa_fn_summary *info = ipa_fn_summaries->get_create (node);
+class ipa_fn_summary *info = ipa_fn_summaries->get (node);
+class ipa_size_summary *size_info = ipa_size_summaries->get (node);
 size_time_entry *e;
 int i;
-info->size = 0;
+size_info->size = 0;
 info->time = 0;
 for (i = 0; vec_safe_iterate (info->size_time_table, i, &e); i++)
 {
-info->size += e->size;
+size_info->size += e->size;
 info->time += e->time;
 }
-estimate_calls_size_and_time (node, &info->size, &info->min_size,
+info->min_size = (*info->size_time_table)[0].size;
-				&info->time, NULL,
+if (reset)
-				~(clause_t) (1 << predicate::false_condition),
+vec_free (info->call_size_time_table);
-				vNULL, vNULL, vNULL);
+if (node->callees || node->indirect_calls)
-info->size = (info->size + ipa_fn_summary::size_scale / 2) / ipa_fn_summary::size_scale;
+estimate_calls_size_and_time (node, &size_info->size, &info->min_size,
+				  &info->time, NULL,
+				  ~(clause_t) (1 << predicate::false_condition),
+				  vNULL, vNULL, vNULL);
+size_info->size = RDIV (size_info->size, ipa_fn_summary::size_scale);
+info->min_size = RDIV (info->min_size, ipa_fn_summary::size_scale);
 }
 /* This function performs intraprocedural analysis in NODE that is required to
 inline indirect calls.  */
 inline_analyze_function (struct cgraph_node *node)
 {
 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 if (dump_file)
-fprintf (dump_file, "\nAnalyzing function: %s/%u\n",
+fprintf (dump_file, "\nAnalyzing function: %s\n", node->dump_name ());
-	     node->name (), node->order);
 if (opt_for_fn (node->decl, optimize) && !node->thunk.thunk_p)
 inline_indirect_intraprocedural_analysis (node);
 compute_fn_summary (node, false);
 if (!optimize)
 {
 {
 struct cgraph_node *node;
 FOR_EACH_DEFINED_FUNCTION (node)
 if (DECL_STRUCT_FUNCTION (node->decl))
-node->local.versionable = tree_versionable_function_p (node->decl);
+node->versionable = tree_versionable_function_p (node->decl);
 ipa_fn_summary_alloc ();
 ipa_fn_summaries->enable_insertion_hook ();
 /* Write inline summary for edge E to OB.  */
 static void
-read_ipa_call_summary (struct lto_input_block *ib, struct cgraph_edge *e)
+read_ipa_call_summary (class lto_input_block *ib, struct cgraph_edge *e,
-{
+		       bool prevails)
-struct ipa_call_summary *es = ipa_call_summaries->get_create (e);
+{
+class ipa_call_summary *es = prevails
+				? ipa_call_summaries->get_create (e) : NULL;
 predicate p;
 int length, i;
-es->call_stmt_size = streamer_read_uhwi (ib);
+int size = streamer_read_uhwi (ib);
-es->call_stmt_time = streamer_read_uhwi (ib);
+int time = streamer_read_uhwi (ib);
-es->loop_depth = streamer_read_uhwi (ib);
+int depth = streamer_read_uhwi (ib);
+if (es)
+{
+es->call_stmt_size = size;
+es->call_stmt_time = time;
+es->loop_depth = depth;
+}
 bitpack_d bp = streamer_read_bitpack (ib);
-es->is_return_callee_uncaptured = bp_unpack_value (&bp, 1);
+if (es)
+es->is_return_callee_uncaptured = bp_unpack_value (&bp, 1);
+else
+bp_unpack_value (&bp, 1);
 p.stream_in (ib);
-edge_set_predicate (e, &p);
+if (es)
+edge_set_predicate (e, &p);
 length = streamer_read_uhwi (ib);
-if (length)
+if (length && es && e->possibly_call_in_translation_unit_p ())
 {
 es->param.safe_grow_cleared (length);
 for (i = 0; i < length; i++)
 	es->param[i].change_prob = streamer_read_uhwi (ib);
+}
+else
+{
+for (i = 0; i < length; i++)
+	streamer_read_uhwi (ib);
 }
 }
 /* Stream in inline summaries from the section.  */
 const struct lto_function_header *header =
 (const struct lto_function_header *) data;
 const int cfg_offset = sizeof (struct lto_function_header);
 const int main_offset = cfg_offset + header->cfg_size;
 const int string_offset = main_offset + header->main_size;
-struct data_in *data_in;
+class data_in *data_in;
 unsigned int i, count2, j;
 unsigned int f_count;
 lto_input_block ib ((const char *) data + main_offset, header->main_size,
 		      file_data->mode_table);
 f_count = streamer_read_uhwi (&ib);
 for (i = 0; i < f_count; i++)
 {
 unsigned int index;
 struct cgraph_node *node;
-struct ipa_fn_summary *info;
+class ipa_fn_summary *info;
+class ipa_node_params *params_summary;
+class ipa_size_summary *size_info;
 lto_symtab_encoder_t encoder;
 struct bitpack_d bp;
 struct cgraph_edge *e;
 predicate p;
 index = streamer_read_uhwi (&ib);
 encoder = file_data->symtab_node_encoder;
 node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
 								index));
-info = ipa_fn_summaries->get_create (node);
+info = node->prevailing_p () ? ipa_fn_summaries->get_create (node) : NULL;
+params_summary = node->prevailing_p () ? IPA_NODE_REF (node) : NULL;
-info->estimated_stack_size
+size_info = node->prevailing_p ()
-	= info->estimated_self_stack_size = streamer_read_uhwi (&ib);
+		  ? ipa_size_summaries->get_create (node) : NULL;
-info->size = info->self_size = streamer_read_uhwi (&ib);
-info->time = sreal::stream_in (&ib);
+int stack_size = streamer_read_uhwi (&ib);
+int size = streamer_read_uhwi (&ib);
+sreal time = sreal::stream_in (&ib);
+if (info)
+	{
+	  info->estimated_stack_size
+	    = size_info->estimated_self_stack_size = stack_size;
+	  size_info->size = size_info->self_size = size;
+	  info->time = time;
+	}
 bp = streamer_read_bitpack (&ib);
-info->inlinable = bp_unpack_value (&bp, 1);
+if (info)
-info->fp_expressions = bp_unpack_value (&bp, 1);
+	{
+info->inlinable = bp_unpack_value (&bp, 1);
+info->fp_expressions = bp_unpack_value (&bp, 1);
+	}
+else
+	{
+bp_unpack_value (&bp, 1);
+bp_unpack_value (&bp, 1);
+	}
 count2 = streamer_read_uhwi (&ib);
-gcc_assert (!info->conds);
+gcc_assert (!info || !info->conds);
+if (info)
+vec_safe_reserve_exact (info->conds, count2);
 for (j = 0; j < count2; j++)
 	{
 	  struct condition c;
+	  unsigned int k, count3;
 	  c.operand_num = streamer_read_uhwi (&ib);
-	  c.size = streamer_read_uhwi (&ib);
 	  c.code = (enum tree_code) streamer_read_uhwi (&ib);
+	  c.type = stream_read_tree (&ib, data_in);
 	  c.val = stream_read_tree (&ib, data_in);
 	  bp = streamer_read_bitpack (&ib);
 	  c.agg_contents = bp_unpack_value (&bp, 1);
 	  c.by_ref = bp_unpack_value (&bp, 1);
 	  if (c.agg_contents)
 	    c.offset = streamer_read_uhwi (&ib);
-	  vec_safe_push (info->conds, c);
+	  count3 = streamer_read_uhwi (&ib);
+	  c.param_ops = NULL;
+	  if (info)
+	    vec_safe_reserve_exact (c.param_ops, count3);
+	  if (params_summary)
+	    ipa_set_param_used_by_ipa_predicates
+		    (params_summary, c.operand_num, true);
+	  for (k = 0; k < count3; k++)
+	    {
+	      struct expr_eval_op op;
+	      enum gimple_rhs_class rhs_class;
+	      op.code = (enum tree_code) streamer_read_uhwi (&ib);
+	      op.type = stream_read_tree (&ib, data_in);
+	      switch (rhs_class = get_gimple_rhs_class (op.code))
+		{
+		case GIMPLE_UNARY_RHS:
+		  op.index = 0;
+		  op.val[0] = NULL_TREE;
+		  op.val[1] = NULL_TREE;
+		  break;
+		case GIMPLE_BINARY_RHS:
+		case GIMPLE_TERNARY_RHS:
+		  bp = streamer_read_bitpack (&ib);
+		  op.index = bp_unpack_value (&bp, 2);
+		  op.val[0] = stream_read_tree (&ib, data_in);
+		  if (rhs_class == GIMPLE_BINARY_RHS)
+		    op.val[1] = NULL_TREE;
+		  else
+		    op.val[1] = stream_read_tree (&ib, data_in);
+		  break;
+		default:
+		  fatal_error (UNKNOWN_LOCATION,
+			       "invalid fnsummary in LTO stream");
+		}
+	      if (info)
+	        c.param_ops->quick_push (op);
+	    }
+	  if (info)
+	    info->conds->quick_push (c);
 	}
 count2 = streamer_read_uhwi (&ib);
-gcc_assert (!info->size_time_table);
+gcc_assert (!info || !info->size_time_table);
+if (info && count2)
+vec_safe_reserve_exact (info->size_time_table, count2);
 for (j = 0; j < count2; j++)
 	{
-	  struct size_time_entry e;
+	  class size_time_entry e;
 	  e.size = streamer_read_uhwi (&ib);
 	  e.time = sreal::stream_in (&ib);
 	  e.exec_predicate.stream_in (&ib);
 	  e.nonconst_predicate.stream_in (&ib);
-	  vec_safe_push (info->size_time_table, e);
+	  if (info)
+	    info->size_time_table->quick_push (e);
 	}
 p.stream_in (&ib);
-set_hint_predicate (&info->loop_iterations, p);
+if (info)
+set_hint_predicate (&info->loop_iterations, p);
 p.stream_in (&ib);
-set_hint_predicate (&info->loop_stride, p);
+if (info)
-p.stream_in (&ib);
+set_hint_predicate (&info->loop_stride, p);
-set_hint_predicate (&info->array_index, p);
 for (e = node->callees; e; e = e->next_callee)
-	read_ipa_call_summary (&ib, e);
+	read_ipa_call_summary (&ib, e, info != NULL);
 for (e = node->indirect_calls; e; e = e->next_callee)
-	read_ipa_call_summary (&ib, e);
+	read_ipa_call_summary (&ib, e, info != NULL);
 }
 lto_free_section_data (file_data, LTO_section_ipa_fn_summary, NULL, data,
 			 len);
 lto_data_in_delete (data_in);
 ipa_fn_summary_alloc ();
 while ((file_data = file_data_vec[j++]))
 {
 size_t len;
-const char *data = lto_get_section_data (file_data,
+const char *data
-					       LTO_section_ipa_fn_summary,
+	= lto_get_summary_section_data (file_data, LTO_section_ipa_fn_summary,
-					       NULL, &len);
+					&len);
 if (data)
 	inline_read_section (file_data, data, len);
 else
 	/* Fatal error here.  We do not want to support compiling ltrans units
 	   with different version of compiler or different flags than the WPA
 /* Write inline summary for edge E to OB.  */
 static void
 write_ipa_call_summary (struct output_block *ob, struct cgraph_edge *e)
 {
-struct ipa_call_summary *es = ipa_call_summaries->get (e);
+class ipa_call_summary *es = ipa_call_summaries->get (e);
 int i;
 streamer_write_uhwi (ob, es->call_stmt_size);
 streamer_write_uhwi (ob, es->call_stmt_time);
 streamer_write_uhwi (ob, es->loop_depth);
 static void
 ipa_fn_summary_write (void)
 {
 struct output_block *ob = create_output_block (LTO_section_ipa_fn_summary);
+lto_symtab_encoder_iterator lsei;
 lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
 unsigned int count = 0;
-int i;
+for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
-for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
+lsei_next_function_in_partition (&lsei))
 {
-symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
+cgraph_node *cnode = lsei_cgraph_node (lsei);
-cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
+if (cnode->definition && !cnode->alias)
-if (cnode && cnode->definition && !cnode->alias)
 	count++;
 }
 streamer_write_uhwi (ob, count);
-for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
+for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
-{
+lsei_next_function_in_partition (&lsei))
-symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
+{
-cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
+cgraph_node *cnode = lsei_cgraph_node (lsei);
-if (cnode && cnode->definition && !cnode->alias)
+if (cnode->definition && !cnode->alias)
 	{
-	  struct ipa_fn_summary *info = ipa_fn_summaries->get (cnode);
+	  class ipa_fn_summary *info = ipa_fn_summaries->get (cnode);
+	  class ipa_size_summary *size_info = ipa_size_summaries->get (cnode);
 	  struct bitpack_d bp;
 	  struct cgraph_edge *edge;
 	  int i;
 	  size_time_entry *e;
 	  struct condition *c;
 	  streamer_write_uhwi (ob, lto_symtab_encoder_encode (encoder, cnode));
-	  streamer_write_hwi (ob, info->estimated_self_stack_size);
+	  streamer_write_hwi (ob, size_info->estimated_self_stack_size);
-	  streamer_write_hwi (ob, info->self_size);
+	  streamer_write_hwi (ob, size_info->self_size);
 	  info->time.stream_out (ob);
 	  bp = bitpack_create (ob->main_stream);
 	  bp_pack_value (&bp, info->inlinable, 1);
 	  bp_pack_value (&bp, false, 1);
 	  bp_pack_value (&bp, info->fp_expressions, 1);
 	  streamer_write_bitpack (&bp);
 	  streamer_write_uhwi (ob, vec_safe_length (info->conds));
 	  for (i = 0; vec_safe_iterate (info->conds, i, &c); i++)
 	    {
+	      int j;
+	      struct expr_eval_op *op;
 	      streamer_write_uhwi (ob, c->operand_num);
-	      streamer_write_uhwi (ob, c->size);
 	      streamer_write_uhwi (ob, c->code);
+	      stream_write_tree (ob, c->type, true);
 	      stream_write_tree (ob, c->val, true);
 	      bp = bitpack_create (ob->main_stream);
 	      bp_pack_value (&bp, c->agg_contents, 1);
 	      bp_pack_value (&bp, c->by_ref, 1);
 	      streamer_write_bitpack (&bp);
 	      if (c->agg_contents)
 		streamer_write_uhwi (ob, c->offset);
+	      streamer_write_uhwi (ob, vec_safe_length (c->param_ops));
+	      for (j = 0; vec_safe_iterate (c->param_ops, j, &op); j++)
+		{
+		  streamer_write_uhwi (ob, op->code);
+		  stream_write_tree (ob, op->type, true);
+		  if (op->val[0])
+		    {
+		      bp = bitpack_create (ob->main_stream);
+		      bp_pack_value (&bp, op->index, 2);
+		      streamer_write_bitpack (&bp);
+		      stream_write_tree (ob, op->val[0], true);
+		      if (op->val[1])
+			stream_write_tree (ob, op->val[1], true);
+		    }
+		}
 	    }
 	  streamer_write_uhwi (ob, vec_safe_length (info->size_time_table));
 	  for (i = 0; vec_safe_iterate (info->size_time_table, i, &e); i++)
 	    {
 	      streamer_write_uhwi (ob, e->size);
 	    streamer_write_uhwi (ob, 0);
 	  if (info->loop_stride)
 	    info->loop_stride->stream_out (ob);
 	  else
 	    streamer_write_uhwi (ob, 0);
-	  if (info->array_index)
-	    info->array_index->stream_out (ob);
-	  else
-	    streamer_write_uhwi (ob, 0);
 	  for (edge = cnode->callees; edge; edge = edge->next_callee)
 	    write_ipa_call_summary (ob, edge);
 	  for (edge = cnode->indirect_calls; edge; edge = edge->next_callee)
 	    write_ipa_call_summary (ob, edge);
 	}
 if (!flag_ipa_cp)
 ipa_prop_write_jump_functions ();
 }
-/* Release inline summary.  */
+/* Release function summary.  */
 void
 ipa_free_fn_summary (void)
 {
-struct cgraph_node *node;
 if (!ipa_call_summaries)
 return;
-FOR_EACH_DEFINED_FUNCTION (node)
+ggc_delete (ipa_fn_summaries);
-if (!node->alias)
-ipa_fn_summaries->remove (node);
-ipa_fn_summaries->release ();
 ipa_fn_summaries = NULL;
-ipa_call_summaries->release ();
 delete ipa_call_summaries;
 ipa_call_summaries = NULL;
 edge_predicate_pool.release ();
+/* During IPA this is one of largest datastructures to release.  */
+if (flag_wpa)
+ggc_trim ();
+}
+/* Release function summary.  */
+void
+ipa_free_size_summary (void)
+{
+if (!ipa_size_summaries)
+return;
+delete ipa_size_summaries;
+ipa_size_summaries = NULL;
 }
 namespace {
 const pass_data pass_data_local_fn_summary =
 void set_pass_param (unsigned int n, bool param)
 {
 gcc_assert (n == 0);
 small_p = param;
 }
-virtual bool gate (function *) { return small_p || !flag_wpa; }
+virtual bool gate (function *) { return true; }
 virtual unsigned int execute (function *)
 {
 ipa_free_fn_summary ();
-/* Early optimizations may make function unreachable.  We can not
+if (!flag_wpa)
-	 remove unreachable functions as part of the early opts pass because
+	ipa_free_size_summary ();
-	 TODOs are run before subpasses.  Do it here.  */
+return 0;
-return small_p ? TODO_remove_functions | TODO_dump_symtab : 0;
 }
 private:
 bool small_p;
 }; // class pass_ipa_free_fn_summary

Mercurial > hg > CbC > CbC_gcc

comparison gcc/ipa-fnsummary.c @ 145:1830386684a0