Patchwork Fix formatting in ipa-inline-analysis.c

login
register
mail settings
Submitter Jan Hubicka
Date Jan. 1, 2013, 4:25 p.m.
Message ID <20130101162503.GA11030@kam.mff.cuni.cz>
Download mbox | patch
Permalink /patch/208951/
State New
Headers show

Comments

Jan Hubicka - Jan. 1, 2013, 4:25 p.m.
Hi,
a while ago I promised Martin to fix overly long lines in ipa-inline-analysis.c
This patch does that and also fixes number of indentation errors across the file.

Regtested x86_64-linux and comitted.

Honza

	* ipa-inline-analysis.c: Fix formatting.

Patch

Index: ipa-inline-analysis.c
===================================================================
--- ipa-inline-analysis.c	(revision 194768)
+++ ipa-inline-analysis.c	(working copy)
@@ -127,8 +127,7 @@  static void inline_node_duplication_hook
 					  struct cgraph_node *, void *);
 static void inline_edge_removal_hook (struct cgraph_edge *, void *);
 static void inline_edge_duplication_hook (struct cgraph_edge *,
-					  struct cgraph_edge *,
-				          void *);
+					  struct cgraph_edge *, void *);
 
 /* VECtor holding inline summaries.  
    In GGC memory because conditions might point to constant trees.  */
@@ -200,6 +199,7 @@  false_predicate_p (struct predicate *p)
 
 
 /* Return predicate that is set true when function is not inlined.  */
+
 static inline struct predicate
 not_inlined_predicate (void)
 {
@@ -254,7 +254,7 @@  add_condition (struct inline_summary *su
 	  && c->val == val
 	  && c->agg_contents == agg_contents
 	  && (!agg_contents || (c->offset == offset && c->by_ref == by_ref)))
-        return single_cond_predicate (i + predicate_first_dynamic_condition);
+	return single_cond_predicate (i + predicate_first_dynamic_condition);
     }
   /* Too many conditions.  Give up and return constant true.  */
   if (i == NUM_CONDITIONS - predicate_first_dynamic_condition)
@@ -321,7 +321,7 @@  add_clause (conditions conditions, struc
 	insert_here = i2;
 
       /* If clause implies p->clause[i], then p->clause[i] becomes redundant.
-	 Otherwise the p->clause[i] has to stay.  */
+         Otherwise the p->clause[i] has to stay.  */
       if ((p->clause[i] & clause) != clause)
 	i2++;
     }
@@ -335,26 +335,27 @@  add_clause (conditions conditions, struc
 	continue;
       cc1 = &(*conditions)[c1 - predicate_first_dynamic_condition];
       /* We have no way to represent !CHANGED and !IS_NOT_CONSTANT
-	 and thus there is no point for looking for them.  */
-      if (cc1->code == CHANGED
-	  || cc1->code == IS_NOT_CONSTANT)
+         and thus there is no point for looking for them.  */
+      if (cc1->code == CHANGED || cc1->code == IS_NOT_CONSTANT)
 	continue;
       for (c2 = c1 + 1; c2 <= NUM_CONDITIONS; c2++)
 	if (clause & (1 << c2))
 	  {
-	    condition *cc1 = &(*conditions)[c1 - predicate_first_dynamic_condition];
-	    condition *cc2 = &(*conditions)[c2 - predicate_first_dynamic_condition];
+	    condition *cc1 =
+	      &(*conditions)[c1 - predicate_first_dynamic_condition];
+	    condition *cc2 =
+	      &(*conditions)[c2 - predicate_first_dynamic_condition];
 	    if (cc1->operand_num == cc2->operand_num
 		&& cc1->val == cc2->val
 		&& cc2->code != IS_NOT_CONSTANT
 		&& cc2->code != CHANGED
-		&& cc1->code == invert_tree_comparison 
-		    (cc2->code,
-		     HONOR_NANS (TYPE_MODE (TREE_TYPE (cc1->val)))))
+		&& cc1->code == invert_tree_comparison
+				(cc2->code,
+				 HONOR_NANS (TYPE_MODE (TREE_TYPE (cc1->val)))))
 	      return;
 	  }
     }
-	
+
 
   /* We run out of variants.  Be conservative in positive direction.  */
   if (i2 == MAX_CLAUSES)
@@ -362,7 +363,7 @@  add_clause (conditions conditions, struc
   /* Keep clauses in decreasing order. This makes equivalence testing easy.  */
   p->clause[i2 + 1] = 0;
   if (insert_here >= 0)
-    for (;i2 > insert_here; i2--)
+    for (; i2 > insert_here; i2--)
       p->clause[i2] = p->clause[i2 - 1];
   else
     insert_here = i2;
@@ -390,7 +391,7 @@  and_predicates (conditions conditions,
     {
       gcc_checking_assert (i < MAX_CLAUSES);
     }
-    
+
   /* Combine the predicates rest.  */
   for (; p2->clause[i]; i++)
     {
@@ -410,11 +411,11 @@  predicates_equal_p (struct predicate *p,
   for (i = 0; p->clause[i]; i++)
     {
       gcc_checking_assert (i < MAX_CLAUSES);
-      gcc_checking_assert (p->clause [i] > p->clause[i + 1]);
+      gcc_checking_assert (p->clause[i] > p->clause[i + 1]);
       gcc_checking_assert (!p2->clause[i]
-			   || p2->clause [i] > p2->clause[i + 1]);
+			   || p2->clause[i] > p2->clause[i + 1]);
       if (p->clause[i] != p2->clause[i])
-        return false;
+	return false;
     }
   return !p2->clause[i];
 }
@@ -423,10 +424,11 @@  predicates_equal_p (struct predicate *p,
 /* Return P | P2.  */
 
 static struct predicate
-or_predicates (conditions conditions, struct predicate *p, struct predicate *p2)
+or_predicates (conditions conditions,
+	       struct predicate *p, struct predicate *p2)
 {
   struct predicate out = true_predicate ();
-  int i,j;
+  int i, j;
 
   /* Avoid busy work.  */
   if (false_predicate_p (p2) || true_predicate_p (p))
@@ -440,8 +442,8 @@  or_predicates (conditions conditions, st
   for (i = 0; p->clause[i]; i++)
     for (j = 0; p2->clause[j]; j++)
       {
-        gcc_checking_assert (i < MAX_CLAUSES && j < MAX_CLAUSES);
-        add_clause (conditions, &out, p->clause[i] | p2->clause[j]);
+	gcc_checking_assert (i < MAX_CLAUSES && j < MAX_CLAUSES);
+	add_clause (conditions, &out, p->clause[i] | p2->clause[j]);
       }
   return out;
 }
@@ -466,7 +468,7 @@  evaluate_predicate (struct predicate *p,
     {
       gcc_checking_assert (i < MAX_CLAUSES);
       if (!(p->clause[i] & possible_truths))
-        return false;
+	return false;
     }
   return true;
 }
@@ -508,23 +510,25 @@  predicate_probability (conditions conds,
 	      {
 		if (i2 >= predicate_first_dynamic_condition)
 		  {
-		    condition *c = &(*conds)[i2 - predicate_first_dynamic_condition];
+		    condition *c =
+		      &(*conds)[i2 - predicate_first_dynamic_condition];
 		    if (c->code == CHANGED
-			&& (c->operand_num
-			    < (int) inline_param_summary.length ()))
+			&& (c->operand_num <
+			    (int) inline_param_summary.length ()))
 		      {
-			int iprob = inline_param_summary[c->operand_num].change_prob;
+			int iprob =
+			  inline_param_summary[c->operand_num].change_prob;
 			this_prob = MAX (this_prob, iprob);
 		      }
 		    else
 		      this_prob = REG_BR_PROB_BASE;
-		   }
-		 else
-		   this_prob = REG_BR_PROB_BASE;
+		  }
+		else
+		  this_prob = REG_BR_PROB_BASE;
 	      }
 	  combined_prob = MIN (this_prob, combined_prob);
 	  if (!combined_prob)
-            return 0;
+	    return 0;
 	}
     }
   return combined_prob;
@@ -580,7 +584,7 @@  dump_clause (FILE *f, conditions conds,
 	if (found)
 	  fprintf (f, " || ");
 	found = true;
-        dump_condition (f, conds, i);
+	dump_condition (f, conds, i);
       }
   fprintf (f, ")");
 }
@@ -599,7 +603,7 @@  dump_predicate (FILE *f, conditions cond
       {
 	if (i)
 	  fprintf (f, " && ");
-        dump_clause (f, conds, pred->clause[i]);
+	dump_clause (f, conds, pred->clause[i]);
       }
   fprintf (f, "\n");
 }
@@ -683,7 +687,7 @@  account_size_time (struct inline_summary
     if (predicates_equal_p (&e->predicate, pred))
       {
 	found = true;
-        break;
+	break;
       }
   if (i == 256)
     {
@@ -692,14 +696,16 @@  account_size_time (struct inline_summary
       e = &(*summary->entry)[0];
       gcc_assert (!e->predicate.clause[0]);
       if (dump_file && (dump_flags & TDF_DETAILS))
-	fprintf (dump_file, "\t\tReached limit on number of entries, ignoring the predicate.");
+	fprintf (dump_file,
+		 "\t\tReached limit on number of entries, "
+		 "ignoring the predicate.");
     }
   if (dump_file && (dump_flags & TDF_DETAILS) && (time || size))
     {
-      fprintf (dump_file, "\t\tAccounting size:%3.2f, time:%3.2f on %spredicate:",
-	       ((double)size) / INLINE_SIZE_SCALE,
-	       ((double)time) / INLINE_TIME_SCALE,
-	       found ? "" : "new ");
+      fprintf (dump_file,
+	       "\t\tAccounting size:%3.2f, time:%3.2f on %spredicate:",
+	       ((double) size) / INLINE_SIZE_SCALE,
+	       ((double) time) / INLINE_TIME_SCALE, found ? "" : "new ");
       dump_predicate (dump_file, summary->conds, pred);
     }
   if (!found)
@@ -728,13 +734,13 @@  edge_set_predicate (struct cgraph_edge *
   if (predicate && !true_predicate_p (predicate))
     {
       if (!es->predicate)
-        es->predicate = (struct predicate *)pool_alloc (edge_predicate_pool);
+	es->predicate = (struct predicate *) pool_alloc (edge_predicate_pool);
       *es->predicate = *predicate;
     }
   else
     {
       if (es->predicate)
-        pool_free (edge_predicate_pool, es->predicate);
+	pool_free (edge_predicate_pool, es->predicate);
       es->predicate = NULL;
     }
 }
@@ -744,8 +750,7 @@  edge_set_predicate (struct cgraph_edge *
 static void
 set_hint_predicate (struct predicate **p, struct predicate new_predicate)
 {
-  if (false_predicate_p (&new_predicate)
-      || true_predicate_p (&new_predicate))
+  if (false_predicate_p (&new_predicate) || true_predicate_p (&new_predicate))
     {
       if (*p)
 	pool_free (edge_predicate_pool, *p);
@@ -754,7 +759,7 @@  set_hint_predicate (struct predicate **p
   else
     {
       if (!*p)
-	*p = (struct predicate *)pool_alloc (edge_predicate_pool);
+	*p = (struct predicate *) pool_alloc (edge_predicate_pool);
       **p = new_predicate;
     }
 }
@@ -769,9 +774,10 @@  set_hint_predicate (struct predicate **p
 
 static clause_t
 evaluate_conditions_for_known_args (struct cgraph_node *node,
-				bool inline_p,
-				vec<tree> known_vals,
-				vec<ipa_agg_jump_function_p> known_aggs)
+				    bool inline_p,
+				    vec<tree> known_vals,
+				    vec<ipa_agg_jump_function_p>
+				    known_aggs)
 {
   clause_t clause = inline_p ? 0 : 1 << predicate_not_inlined_condition;
   struct inline_summary *info = inline_summary (node);
@@ -784,9 +790,9 @@  evaluate_conditions_for_known_args (stru
       tree res;
 
       /* 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).  */
+         (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 ()
 			   || (known_vals.length () == known_aggs.length ()));
       if (c->operand_num >= (int) known_vals.length ())
@@ -801,8 +807,7 @@  evaluate_conditions_for_known_args (stru
 
 	  if (c->code == CHANGED
 	      && !c->by_ref
-	      && (known_vals[c->operand_num]
-		  == error_mark_node))
+	      && (known_vals[c->operand_num] == error_mark_node))
 	    continue;
 
 	  if (known_aggs.exists ())
@@ -828,8 +833,7 @@  evaluate_conditions_for_known_args (stru
       if (c->code == IS_NOT_CONSTANT || c->code == CHANGED)
 	continue;
       res = fold_binary_to_constant (c->code, boolean_type_node, val, c->val);
-      if (res
-	  && integer_zerop (res))
+      if (res && integer_zerop (res))
 	continue;
       clause |= 1 << (i + predicate_first_dynamic_condition);
     }
@@ -841,12 +845,13 @@  evaluate_conditions_for_known_args (stru
 
 static void
 evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
-			clause_t *clause_ptr,
-			vec<tree> *known_vals_ptr,
-			vec<tree> *known_binfos_ptr,
-			vec<ipa_agg_jump_function_p> *known_aggs_ptr)
+			      clause_t *clause_ptr,
+			      vec<tree> *known_vals_ptr,
+			      vec<tree> *known_binfos_ptr,
+			      vec<ipa_agg_jump_function_p> *known_aggs_ptr)
 {
-  struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
+  struct cgraph_node *callee =
+    cgraph_function_or_thunk_node (e->callee, NULL);
   struct inline_summary *info = inline_summary (callee);
   vec<tree> known_vals = vNULL;
   vec<ipa_agg_jump_function_p> known_aggs = vNULL;
@@ -860,8 +865,7 @@  evaluate_properties_for_edge (struct cgr
 
   if (ipa_node_params_vector.exists ()
       && !e->call_stmt_cannot_inline_p
-      && ((clause_ptr && info->conds)
-	  || known_vals_ptr || known_binfos_ptr))
+      && ((clause_ptr && info->conds) || known_vals_ptr || known_binfos_ptr))
     {
       struct ipa_node_params *parms_info;
       struct ipa_edge_args *args = IPA_EDGE_REF (e);
@@ -869,9 +873,9 @@  evaluate_properties_for_edge (struct cgr
       int i, count = ipa_get_cs_argument_count (args);
 
       if (e->caller->global.inlined_to)
-        parms_info = IPA_NODE_REF (e->caller->global.inlined_to);
+	parms_info = IPA_NODE_REF (e->caller->global.inlined_to);
       else
-        parms_info = IPA_NODE_REF (e->caller);
+	parms_info = IPA_NODE_REF (e->caller);
 
       if (count && (info->conds || known_vals_ptr))
 	known_vals.safe_grow_cleared (count);
@@ -888,7 +892,8 @@  evaluate_properties_for_edge (struct cgr
 	    {
 	      if (known_vals.exists () && TREE_CODE (cst) != TREE_BINFO)
 		known_vals[i] = cst;
-	      else if (known_binfos_ptr != NULL && TREE_CODE (cst) == TREE_BINFO)
+	      else if (known_binfos_ptr != NULL
+		       && TREE_CODE (cst) == TREE_BINFO)
 		(*known_binfos_ptr)[i] = cst;
 	    }
 	  else if (inline_p && !es->param[i].change_prob)
@@ -940,8 +945,7 @@  inline_summary_alloc (void)
     inline_edge_summary_vec.safe_grow_cleared (cgraph_edge_max_uid + 1);
   if (!edge_predicate_pool)
     edge_predicate_pool = create_alloc_pool ("edge predicates",
-					     sizeof (struct predicate),
-					     10);
+					     sizeof (struct predicate), 10);
 }
 
 /* We are called multiple time for given function; clear
@@ -950,7 +954,7 @@  inline_summary_alloc (void)
 static void
 reset_inline_edge_summary (struct cgraph_edge *e)
 {
-  if (e->uid < (int)inline_edge_summary_vec.length ())
+  if (e->uid < (int) inline_edge_summary_vec.length ())
     {
       struct inline_edge_summary *es = inline_edge_summary (e);
 
@@ -1005,10 +1009,11 @@  reset_inline_summary (struct cgraph_node
 /* Hook that is called by cgraph.c when a node is removed.  */
 
 static void
-inline_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
+inline_node_removal_hook (struct cgraph_node *node,
+			  void *data ATTRIBUTE_UNUSED)
 {
   struct inline_summary *info;
-  if (vec_safe_length (inline_summary_vec) <= (unsigned)node->uid)
+  if (vec_safe_length (inline_summary_vec) <= (unsigned) node->uid)
     return;
   info = inline_summary (node);
   reset_inline_summary (node);
@@ -1054,8 +1059,7 @@  remap_hint_predicate_after_duplication (
     return;
 
   new_predicate = remap_predicate_after_duplication (*p,
-						     possible_truths,
-						     info);
+						     possible_truths, info);
   /* We do not want to free previous predicate; it is used by node origin.  */
   *p = NULL;
   set_hint_predicate (p, new_predicate);
@@ -1065,29 +1069,28 @@  remap_hint_predicate_after_duplication (
 /* Hook that is called by cgraph.c when a node is duplicated.  */
 
 static void
-inline_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
+inline_node_duplication_hook (struct cgraph_node *src,
+			      struct cgraph_node *dst,
 			      ATTRIBUTE_UNUSED void *data)
 {
   struct inline_summary *info;
   inline_summary_alloc ();
   info = inline_summary (dst);
-  memcpy (info, inline_summary (src),
-	  sizeof (struct inline_summary));
+  memcpy (info, inline_summary (src), sizeof (struct inline_summary));
   /* TODO: as an optimization, we may avoid copying conditions
      that are known to be false or true.  */
   info->conds = vec_safe_copy (info->conds);
 
   /* When there are any replacements in the function body, see if we can figure
      out that something was optimized out.  */
-  if (ipa_node_params_vector.exists ()
-      && dst->clone.tree_map)
+  if (ipa_node_params_vector.exists () && dst->clone.tree_map)
     {
       vec<size_time_entry, va_gc> *entry = info->entry;
       /* Use SRC parm info since it may not be copied yet.  */
       struct 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;
+      int i, j;
       clause_t possible_truths;
       struct predicate true_pred = true_predicate ();
       size_time_entry *e;
@@ -1098,15 +1101,13 @@  inline_node_duplication_hook (struct cgr
       info->entry = 0;
       known_vals.safe_grow_cleared (count);
       for (i = 0; i < count; i++)
-        {
+	{
 	  tree t = ipa_get_param (parms_info, i);
 	  struct ipa_replace_map *r;
 
 	  for (j = 0; vec_safe_iterate (dst->clone.tree_map, j, &r); j++)
 	    {
-	      if (r->old_tree == t
-		  && r->replace_p
-		  && !r->ref_p)
+	      if (r->old_tree == t && r->replace_p && !r->ref_p)
 		{
 		  known_vals[i] = r->new_tree;
 		  break;
@@ -1114,16 +1115,17 @@  inline_node_duplication_hook (struct cgr
 	    }
 	}
       possible_truths = evaluate_conditions_for_known_args (dst, false,
-				    known_vals, vNULL);
+							    known_vals,
+							    vNULL);
       known_vals.release ();
 
       account_size_time (info, 0, 0, &true_pred);
 
       /* Remap size_time vectors.
-	 Simplify the predicate by prunning out alternatives that are known
-	 to be false.
-	 TODO: as on optimization, we can also eliminate conditions known
-	 to be true.  */
+         Simplify the predicate by prunning 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++)
 	{
 	  struct predicate new_predicate;
@@ -1137,7 +1139,7 @@  inline_node_duplication_hook (struct cgr
 	}
 
       /* Remap edge predicates with the same simplification as above.
-	 Also copy constantness arrays.   */
+         Also copy constantness arrays.   */
       for (edge = dst->callees; edge; edge = edge->next_callee)
 	{
 	  struct predicate new_predicate;
@@ -1160,7 +1162,7 @@  inline_node_duplication_hook (struct cgr
 	}
 
       /* Remap indirect edge predicates with the same simplificaiton as above. 
-	 Also copy constantness arrays.   */
+         Also copy constantness arrays.   */
       for (edge = dst->indirect_calls; edge; edge = edge->next_callee)
 	{
 	  struct predicate new_predicate;
@@ -1181,21 +1183,17 @@  inline_node_duplication_hook (struct cgr
 	  edge_set_predicate (edge, &new_predicate);
 	}
       remap_hint_predicate_after_duplication (&info->loop_iterations,
-					      possible_truths,
-					      info);
+					      possible_truths, info);
       remap_hint_predicate_after_duplication (&info->loop_stride,
-					      possible_truths,
-					      info);
+					      possible_truths, info);
       remap_hint_predicate_after_duplication (&info->array_index,
-					      possible_truths,
-					      info);
+					      possible_truths, info);
 
       /* 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.  */
-      gcc_assert (!inlined_to_p 
-		  || !optimized_out_size);
+         non-trivial clones, we will get trouble with lack of information
+         about updating self sizes, because size vectors already contains
+         sizes of the calees.  */
+      gcc_assert (!inlined_to_p || !optimized_out_size);
     }
   else
     {
@@ -1226,7 +1224,8 @@  inline_node_duplication_hook (struct cgr
 /* Hook that is called by cgraph.c when a node is duplicated.  */
 
 static void
-inline_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
+inline_edge_duplication_hook (struct cgraph_edge *src,
+			      struct cgraph_edge *dst,
 			      ATTRIBUTE_UNUSED void *data)
 {
   struct inline_edge_summary *info;
@@ -1234,8 +1233,7 @@  inline_edge_duplication_hook (struct cgr
   inline_summary_alloc ();
   info = inline_edge_summary (dst);
   srcinfo = inline_edge_summary (src);
-  memcpy (info, srcinfo,
-	  sizeof (struct inline_edge_summary));
+  memcpy (info, srcinfo, sizeof (struct inline_edge_summary));
   info->predicate = NULL;
   edge_set_predicate (dst, srcinfo->predicate);
   info->param = srcinfo->param.copy ();
@@ -1245,7 +1243,8 @@  inline_edge_duplication_hook (struct cgr
 /* Keep edge cache consistent across edge removal.  */
 
 static void
-inline_edge_removal_hook (struct cgraph_edge *edge, void *data ATTRIBUTE_UNUSED)
+inline_edge_removal_hook (struct cgraph_edge *edge,
+			  void *data ATTRIBUTE_UNUSED)
 {
   if (edge_growth_cache.exists ())
     reset_edge_growth_cache (edge);
@@ -1279,28 +1278,27 @@  free_growth_caches (void)
    Indent by INDENT.  */
 
 static void
-dump_inline_edge_summary (FILE * f, int indent, struct cgraph_node *node,
+dump_inline_edge_summary (FILE *f, int indent, struct cgraph_node *node,
 			  struct inline_summary *info)
 {
   struct cgraph_edge *edge;
   for (edge = node->callees; edge; edge = edge->next_callee)
     {
       struct inline_edge_summary *es = inline_edge_summary (edge);
-      struct cgraph_node *callee = cgraph_function_or_thunk_node (edge->callee, NULL);
+      struct cgraph_node *callee =
+	cgraph_function_or_thunk_node (edge->callee, NULL);
       int i;
 
-      fprintf (f, "%*s%s/%i %s\n%*s  loop depth:%2i freq:%4i size:%2i time: %2i callee size:%2i stack:%2i",
-	       indent, "", cgraph_node_name (callee),
-	       callee->uid, 
-	       !edge->inline_failed ? "inlined"
-	       : cgraph_inline_failed_string (edge->inline_failed),
-	       indent, "",
-	       es->loop_depth,	
-               edge->frequency,
-	       es->call_stmt_size,
-	       es->call_stmt_time,
-	       (int)inline_summary (callee)->size / INLINE_SIZE_SCALE,
-	       (int)inline_summary (callee)->estimated_stack_size);
+      fprintf (f,
+	       "%*s%s/%i %s\n%*s  loop depth:%2i freq:%4i size:%2i"
+	       " time: %2i callee size:%2i stack:%2i",
+	       indent, "", cgraph_node_name (callee), callee->uid,
+	       !edge->inline_failed
+	       ? "inlined" : cgraph_inline_failed_string (edge-> inline_failed),
+	       indent, "", es->loop_depth, edge->frequency,
+	       es->call_stmt_size, es->call_stmt_time,
+	       (int) inline_summary (callee)->size / INLINE_SIZE_SCALE,
+	       (int) inline_summary (callee)->estimated_stack_size);
 
       if (es->predicate)
 	{
@@ -1308,9 +1306,9 @@  dump_inline_edge_summary (FILE * f, int
 	  dump_predicate (f, info->conds, es->predicate);
 	}
       else
-	  fprintf (f, "\n");
+	fprintf (f, "\n");
       if (es->param.exists ())
-        for (i = 0; i < (int)es->param.length (); i++)
+	for (i = 0; i < (int) es->param.length (); i++)
 	  {
 	    int prob = es->param[i].change_prob;
 
@@ -1323,13 +1321,13 @@  dump_inline_edge_summary (FILE * f, int
 	  }
       if (!edge->inline_failed)
 	{
-          fprintf (f, "%*sStack frame offset %i, callee self size %i,"
+	  fprintf (f, "%*sStack frame offset %i, callee self size %i,"
 		   " callee size %i\n",
-		   indent+2, "",
-		   (int)inline_summary (callee)->stack_frame_offset,
-		   (int)inline_summary (callee)->estimated_self_stack_size,
-		   (int)inline_summary (callee)->estimated_stack_size);
-	  dump_inline_edge_summary (f, indent+2, callee, info);
+		   indent + 2, "",
+		   (int) inline_summary (callee)->stack_frame_offset,
+		   (int) inline_summary (callee)->estimated_self_stack_size,
+		   (int) inline_summary (callee)->estimated_stack_size);
+	  dump_inline_edge_summary (f, indent + 2, callee, info);
 	}
     }
   for (edge = node->indirect_calls; edge; edge = edge->next_callee)
@@ -1338,10 +1336,8 @@  dump_inline_edge_summary (FILE * f, int
       fprintf (f, "%*sindirect call loop depth:%2i freq:%4i size:%2i"
 	       " time: %2i",
 	       indent, "",
-	       es->loop_depth,	
-               edge->frequency,
-	       es->call_stmt_size,
-	       es->call_stmt_time);
+	       es->loop_depth,
+	       edge->frequency, es->call_stmt_size, es->call_stmt_time);
       if (es->predicate)
 	{
 	  fprintf (f, "predicate: ");
@@ -1354,7 +1350,7 @@  dump_inline_edge_summary (FILE * f, int
 
 
 void
-dump_inline_summary (FILE * f, struct cgraph_node *node)
+dump_inline_summary (FILE *f, struct cgraph_node *node)
 {
   if (node->analyzed)
     {
@@ -1367,22 +1363,17 @@  dump_inline_summary (FILE * f, struct cg
 	fprintf (f, " always_inline");
       if (s->inlinable)
 	fprintf (f, " inlinable");
-      fprintf (f, "\n  self time:       %i\n",
-	       s->self_time);
+      fprintf (f, "\n  self time:       %i\n", s->self_time);
       fprintf (f, "  global time:     %i\n", s->time);
-      fprintf (f, "  self size:       %i\n",
-	       s->self_size);
+      fprintf (f, "  self size:       %i\n", s->self_size);
       fprintf (f, "  global size:     %i\n", s->size);
       fprintf (f, "  self stack:      %i\n",
 	       (int) s->estimated_self_stack_size);
-      fprintf (f, "  global stack:    %i\n",
-	       (int) s->estimated_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);
+	fprintf (f, "  estimated growth:%i\n", (int) s->growth);
       if (s->scc_no)
-        fprintf (f, "  In SCC:          %i\n",
-	         (int) s->scc_no);
+	fprintf (f, "  In SCC:          %i\n", (int) s->scc_no);
       for (i = 0; vec_safe_iterate (s->entry, i, &e); i++)
 	{
 	  fprintf (f, "    size:%f, time:%f, predicate:",
@@ -1452,7 +1443,7 @@  initialize_inline_failed (struct cgraph_
 
 static bool
 mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
-		     void *data)
+	       void *data)
 {
   bool *b = (bool *) data;
   *b = true;
@@ -1563,116 +1554,117 @@  eliminated_by_inlining_prob (gimple stmt
 
   switch (code)
     {
-      case GIMPLE_RETURN:
-        return 2;
-      case GIMPLE_ASSIGN:
-	if (gimple_num_ops (stmt) != 2)
-	  return 0;
-
-	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.
-	   Assume that half of statements goes away.  */
-	if (rhs_code == CONVERT_EXPR
-	    || rhs_code == NOP_EXPR
-	    || rhs_code == VIEW_CONVERT_EXPR
-	    || rhs_code == ADDR_EXPR
-	    || gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
-	  {
-	    tree rhs = gimple_assign_rhs1 (stmt);
-            tree lhs = gimple_assign_lhs (stmt);
-	    tree inner_rhs = get_base_address (rhs);
-	    tree inner_lhs = get_base_address (lhs);
-	    bool rhs_free = false;
-	    bool lhs_free = false;
-
-	    if (!inner_rhs)
-	      inner_rhs = rhs;
-	    if (!inner_lhs)
-	      inner_lhs = lhs;
-
-	    /* Reads of parameter are expected to be free.  */
-	    if (unmodified_parm (stmt, inner_rhs))
-	      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)))
-		  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
-	       free after inlining (we will copy propagate backward).   */
-	    if (rhs_free && is_gimple_reg (lhs))
-	      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)))
-	      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.  
-
-	       TODO: We ought to handle testcase like
-	       struct a {int a,b;};
-	       struct a
-	       retrurnsturct (void)
-		 {
-		   struct a a ={1,2};
-		   return a;
-		 }
-
-	       This translate into:
-
-	       retrurnsturct ()
-		 {
-		   int a$b;
-		   int a$a;
-		   struct a a;
-		   struct a D.2739;
-
-		 <bb 2>:
-		   D.2739.a = 1;
-		   D.2739.b = 2;
-		   return 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))
-			 || (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))))
-	      lhs_free = true;
-	    if (lhs_free
-		&& (is_gimple_reg (rhs) || is_gimple_min_invariant (rhs)))
-	      rhs_free = true;
-	    if (lhs_free && rhs_free)
-	      return 1;
-	  }
-	return 0;
-      default:
+    case GIMPLE_RETURN:
+      return 2;
+    case GIMPLE_ASSIGN:
+      if (gimple_num_ops (stmt) != 2)
 	return 0;
+
+      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.
+         Assume that half of statements goes away.  */
+      if (rhs_code == CONVERT_EXPR
+	  || rhs_code == NOP_EXPR
+	  || rhs_code == VIEW_CONVERT_EXPR
+	  || rhs_code == ADDR_EXPR
+	  || gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
+	{
+	  tree rhs = gimple_assign_rhs1 (stmt);
+	  tree lhs = gimple_assign_lhs (stmt);
+	  tree inner_rhs = get_base_address (rhs);
+	  tree inner_lhs = get_base_address (lhs);
+	  bool rhs_free = false;
+	  bool lhs_free = false;
+
+	  if (!inner_rhs)
+	    inner_rhs = rhs;
+	  if (!inner_lhs)
+	    inner_lhs = lhs;
+
+	  /* Reads of parameter are expected to be free.  */
+	  if (unmodified_parm (stmt, inner_rhs))
+	    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)))
+		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
+	     free after inlining (we will copy propagate backward).   */
+	  if (rhs_free && is_gimple_reg (lhs))
+	    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)))
+	    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.  
+
+	     TODO: We ought to handle testcase like
+	     struct a {int a,b;};
+	     struct a
+	     retrurnsturct (void)
+	     {
+	     struct a a ={1,2};
+	     return a;
+	     }
+
+	     This translate into:
+
+	     retrurnsturct ()
+	     {
+	     int a$b;
+	     int a$a;
+	     struct a a;
+	     struct a D.2739;
+
+	     <bb 2>:
+	     D.2739.a = 1;
+	     D.2739.b = 2;
+	     return 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))
+		      || (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))))
+	    lhs_free = true;
+	  if (lhs_free
+	      && (is_gimple_reg (rhs) || is_gimple_min_invariant (rhs)))
+	    rhs_free = true;
+	  if (lhs_free && rhs_free)
+	    return 1;
+	}
+      return 0;
+    default:
+      return 0;
     }
 }
 
@@ -1682,8 +1674,8 @@  eliminated_by_inlining_prob (gimple stmt
 
 static void
 set_cond_stmt_execution_predicate (struct ipa_node_params *info,
-			           struct inline_summary *summary,
-			           basic_block bb)
+				   struct inline_summary *summary,
+				   basic_block bb)
 {
   gimple last;
   tree op;
@@ -1696,8 +1688,7 @@  set_cond_stmt_execution_predicate (struc
   tree op2;
 
   last = last_stmt (bb);
-  if (!last
-      || gimple_code (last) != GIMPLE_COND)
+  if (!last || gimple_code (last) != GIMPLE_COND)
     return;
   if (!is_gimple_ip_invariant (gimple_cond_rhs (last)))
     return;
@@ -1709,8 +1700,8 @@  set_cond_stmt_execution_predicate (struc
     {
       code = gimple_cond_code (last);
       inverted_code
-	 = invert_tree_comparison (code,
-				   HONOR_NANS (TYPE_MODE (TREE_TYPE (op))));
+	= invert_tree_comparison (code,
+				  HONOR_NANS (TYPE_MODE (TREE_TYPE (op))));
 
       FOR_EACH_EDGE (e, ei, bb->succs)
 	{
@@ -1719,7 +1710,7 @@  set_cond_stmt_execution_predicate (struc
 					      ? code : inverted_code,
 					      gimple_cond_rhs (last));
 	  e->aux = pool_alloc (edge_predicate_pool);
-	  *(struct predicate *)e->aux = p;
+	  *(struct predicate *) e->aux = p;
 	}
     }
 
@@ -1727,9 +1718,9 @@  set_cond_stmt_execution_predicate (struc
     return;
   /* Special case
      if (builtin_constant_p (op))
-       constant_code
+     constant_code
      else
-       nonconstant_code.
+     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
@@ -1743,16 +1734,16 @@  set_cond_stmt_execution_predicate (struc
       || gimple_call_num_args (set_stmt) != 1)
     return;
   op2 = gimple_call_arg (set_stmt, 0);
-  if (!unmodified_parm_or_parm_agg_item (info, set_stmt, op2, &index, &aggpos))
+  if (!unmodified_parm_or_parm_agg_item
+      (info, set_stmt, op2, &index, &aggpos))
     return;
-  FOR_EACH_EDGE (e, ei, bb->succs)
-    if (e->flags & EDGE_FALSE_VALUE)
-      {
-	struct predicate p = add_condition (summary, index, &aggpos,
-					    IS_NOT_CONSTANT, NULL_TREE);
-	e->aux = pool_alloc (edge_predicate_pool);
-	*(struct predicate *)e->aux = p;
-      }
+  FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_FALSE_VALUE)
+    {
+      struct predicate p = add_condition (summary, index, &aggpos,
+					  IS_NOT_CONSTANT, NULL_TREE);
+      e->aux = pool_alloc (edge_predicate_pool);
+      *(struct predicate *) e->aux = p;
+    }
 }
 
 
@@ -1761,8 +1752,8 @@  set_cond_stmt_execution_predicate (struc
 
 static void
 set_switch_stmt_execution_predicate (struct ipa_node_params *info,
-			           struct inline_summary *summary,
-			           basic_block bb)
+				     struct inline_summary *summary,
+				     basic_block bb)
 {
   gimple last;
   tree op;
@@ -1774,8 +1765,7 @@  set_switch_stmt_execution_predicate (str
   size_t case_idx;
 
   last = last_stmt (bb);
-  if (!last
-      || gimple_code (last) != GIMPLE_SWITCH)
+  if (!last || gimple_code (last) != GIMPLE_SWITCH)
     return;
   op = gimple_switch_index (last);
   if (!unmodified_parm_or_parm_agg_item (info, last, op, &index, &aggpos))
@@ -1784,9 +1774,9 @@  set_switch_stmt_execution_predicate (str
   FOR_EACH_EDGE (e, ei, bb->succs)
     {
       e->aux = pool_alloc (edge_predicate_pool);
-      *(struct predicate *)e->aux = false_predicate ();
+      *(struct predicate *) e->aux = false_predicate ();
     }
-  n = gimple_switch_num_labels(last);
+  n = gimple_switch_num_labels (last);
   for (case_idx = 0; case_idx < n; ++case_idx)
     {
       tree cl = gimple_switch_label (last, case_idx);
@@ -1798,8 +1788,8 @@  set_switch_stmt_execution_predicate (str
       max = CASE_HIGH (cl);
 
       /* For default we might want to construct predicate that none
-	 of cases is met, but it is bit hard to do not having negations
-	 of conditionals handy.  */
+         of cases is met, but it is bit hard to do not having negations
+         of conditionals handy.  */
       if (!min && !max)
 	p = true_predicate ();
       else if (!max)
@@ -1811,8 +1801,8 @@  set_switch_stmt_execution_predicate (str
 	  p2 = add_condition (summary, index, &aggpos, LE_EXPR, max);
 	  p = and_predicates (summary->conds, &p1, &p2);
 	}
-      *(struct predicate *)e->aux
-	= or_predicates (summary->conds, &p, (struct predicate *)e->aux);
+      *(struct predicate *) e->aux
+	= or_predicates (summary->conds, &p, (struct predicate *) e->aux);
     }
 }
 
@@ -1838,7 +1828,7 @@  compute_bb_predicates (struct cgraph_nod
   /* Entry block is always executable.  */
   ENTRY_BLOCK_PTR_FOR_FUNCTION (my_function)->aux
     = pool_alloc (edge_predicate_pool);
-  *(struct predicate *)ENTRY_BLOCK_PTR_FOR_FUNCTION (my_function)->aux
+  *(struct predicate *) ENTRY_BLOCK_PTR_FOR_FUNCTION (my_function)->aux
     = true_predicate ();
 
   /* A simple dataflow propagation of predicates forward in the CFG.
@@ -1848,19 +1838,19 @@  compute_bb_predicates (struct cgraph_nod
       done = true;
       FOR_EACH_BB_FN (bb, my_function)
 	{
-          struct predicate p = false_predicate ();
-          edge e;
-          edge_iterator ei;
+	  struct predicate p = false_predicate ();
+	  edge e;
+	  edge_iterator ei;
 	  FOR_EACH_EDGE (e, ei, bb->preds)
 	    {
 	      if (e->src->aux)
 		{
 		  struct predicate this_bb_predicate
-		     = *(struct predicate *)e->src->aux;
+		    = *(struct predicate *) e->src->aux;
 		  if (e->aux)
 		    this_bb_predicate
-		       = and_predicates (summary->conds, &this_bb_predicate,
-					 (struct predicate *)e->aux);
+		      = and_predicates (summary->conds, &this_bb_predicate,
+					(struct predicate *) e->aux);
 		  p = or_predicates (summary->conds, &p, &this_bb_predicate);
 		  if (true_predicate_p (&p))
 		    break;
@@ -1874,12 +1864,12 @@  compute_bb_predicates (struct cgraph_nod
 		{
 		  done = false;
 		  bb->aux = pool_alloc (edge_predicate_pool);
-		  *((struct predicate *)bb->aux) = p;
+		  *((struct predicate *) bb->aux) = p;
 		}
-	      else if (!predicates_equal_p (&p, (struct predicate *)bb->aux))
+	      else if (!predicates_equal_p (&p, (struct predicate *) bb->aux))
 		{
 		  done = false;
-		  *((struct predicate *)bb->aux) = p;
+		  *((struct predicate *) bb->aux) = p;
 		}
 	    }
 	}
@@ -1895,9 +1885,9 @@  typedef struct predicate predicate_t;
 
 static struct predicate
 will_be_nonconstant_expr_predicate (struct ipa_node_params *info,
-			            struct inline_summary *summary,
-			            tree expr,
-			            vec<predicate_t> nonconstant_names)
+				    struct inline_summary *summary,
+				    tree expr,
+				    vec<predicate_t> nonconstant_names)
 {
   tree parm;
   int index;
@@ -1906,19 +1896,17 @@  will_be_nonconstant_expr_predicate (stru
     expr = TREE_OPERAND (expr, 0);
 
   parm = unmodified_parm (NULL, expr);
-  if (parm
-      && (index = ipa_get_param_decl_index (info, parm)) >= 0)
+  if (parm && (index = ipa_get_param_decl_index (info, parm)) >= 0)
     return add_condition (summary, index, NULL, CHANGED, NULL_TREE);
   if (is_gimple_min_invariant (expr))
     return false_predicate ();
   if (TREE_CODE (expr) == SSA_NAME)
     return nonconstant_names[SSA_NAME_VERSION (expr)];
-  if (BINARY_CLASS_P (expr)
-      || COMPARISON_CLASS_P (expr))
+  if (BINARY_CLASS_P (expr) || COMPARISON_CLASS_P (expr))
     {
       struct predicate p1 = will_be_nonconstant_expr_predicate
-			      (info, summary, TREE_OPERAND (expr, 0),
-			       nonconstant_names);
+	(info, summary, TREE_OPERAND (expr, 0),
+	 nonconstant_names);
       struct predicate p2;
       if (true_predicate_p (&p1))
 	return p1;
@@ -1930,8 +1918,8 @@  will_be_nonconstant_expr_predicate (stru
   else if (TREE_CODE (expr) == COND_EXPR)
     {
       struct predicate p1 = will_be_nonconstant_expr_predicate
-			      (info, summary, TREE_OPERAND (expr, 0),
-			       nonconstant_names);
+	(info, summary, TREE_OPERAND (expr, 0),
+	 nonconstant_names);
       struct predicate p2;
       if (true_predicate_p (&p1))
 	return p1;
@@ -2018,7 +2006,8 @@  will_be_nonconstant_predicate (struct ip
     }
 
   if (is_load)
-    op_non_const = add_condition (summary, base_index, &aggpos, CHANGED, NULL);
+    op_non_const =
+      add_condition (summary, base_index, &aggpos, CHANGED, NULL);
   else
     op_non_const = false_predicate ();
   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
@@ -2026,8 +2015,7 @@  will_be_nonconstant_predicate (struct ip
       tree parm = unmodified_parm (stmt, use);
       int index;
 
-      if (parm
-	  && (index = ipa_get_param_decl_index (info, parm)) >= 0)
+      if (parm && (index = ipa_get_param_decl_index (info, parm)) >= 0)
 	{
 	  if (index != base_index)
 	    p = add_condition (summary, index, NULL, CHANGED, NULL_TREE);
@@ -2041,7 +2029,7 @@  will_be_nonconstant_predicate (struct ip
   if (gimple_code (stmt) == GIMPLE_ASSIGN
       && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME)
     nonconstant_names[SSA_NAME_VERSION (gimple_assign_lhs (stmt))]
-	= op_non_const;
+      = op_non_const;
   return op_non_const;
 }
 
@@ -2055,15 +2043,16 @@  struct record_modified_bb_info
    set except for info->stmt.  */
 
 static bool
-record_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef,
-	         void *data)
+record_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
 {
-  struct record_modified_bb_info *info = (struct record_modified_bb_info *) data;
+  struct record_modified_bb_info *info =
+    (struct record_modified_bb_info *) data;
   if (SSA_NAME_DEF_STMT (vdef) == info->stmt)
     return false;
   bitmap_set_bit (info->bb_set,
 		  SSA_NAME_IS_DEFAULT_DEF (vdef)
-		  ? ENTRY_BLOCK_PTR->index : gimple_bb (SSA_NAME_DEF_STMT (vdef))->index);
+		  ? ENTRY_BLOCK_PTR->index
+		  : gimple_bb (SSA_NAME_DEF_STMT (vdef))->index);
   return false;
 }
 
@@ -2081,6 +2070,7 @@  param_change_prob (gimple stmt, int i)
   basic_block bb = gimple_bb (stmt);
   tree base;
 
+  /* Global invariants neve change.  */
   if (is_gimple_min_invariant (op))
     return 0;
   /* We would have to do non-trivial analysis to really work out what
@@ -2104,10 +2094,10 @@  param_change_prob (gimple stmt, int i)
       if (!init_freq)
 	init_freq = 1;
       if (init_freq < bb->frequency)
-        return MAX ((init_freq * REG_BR_PROB_BASE +
-		    bb->frequency / 2) / bb->frequency, 1);
+	return MAX ((init_freq * REG_BR_PROB_BASE +
+		     bb->frequency / 2) / bb->frequency, 1);
       else
-        return REG_BR_PROB_BASE;
+	return REG_BR_PROB_BASE;
     }
 
   base = get_base_address (op);
@@ -2130,13 +2120,13 @@  param_change_prob (gimple stmt, int i)
 			  NULL);
       if (bitmap_bit_p (info.bb_set, bb->index))
 	{
-          BITMAP_FREE (info.bb_set);
+	  BITMAP_FREE (info.bb_set);
 	  return REG_BR_PROB_BASE;
 	}
 
       /* Assume that every memory is initialized at entry.
-	 TODO: Can we easilly determine if value is always defined
-	 and thus we may skip entry block?  */
+         TODO: Can we easilly determine if value is always defined
+         and thus we may skip entry block?  */
       if (ENTRY_BLOCK_PTR->frequency)
 	max = ENTRY_BLOCK_PTR->frequency;
       else
@@ -2144,13 +2134,13 @@  param_change_prob (gimple stmt, int i)
 
       EXECUTE_IF_SET_IN_BITMAP (info.bb_set, 0, index, bi)
 	max = MIN (max, BASIC_BLOCK (index)->frequency);
-      
+
       BITMAP_FREE (info.bb_set);
       if (max < bb->frequency)
-        return MAX ((max * REG_BR_PROB_BASE +
+	return MAX ((max * REG_BR_PROB_BASE +
 		     bb->frequency / 2) / bb->frequency, 1);
       else
-        return REG_BR_PROB_BASE;
+	return REG_BR_PROB_BASE;
     }
   return REG_BR_PROB_BASE;
 }
@@ -2251,19 +2241,18 @@  predicate_for_phi_result (struct inline_
 
 static struct predicate
 array_index_predicate (struct inline_summary *info,
-		       vec<predicate_t> nonconstant_names, tree op)
+		       vec< predicate_t> nonconstant_names, tree op)
 {
   struct predicate p = false_predicate ();
   while (handled_component_p (op))
     {
-      if (TREE_CODE (op) == ARRAY_REF
-	  || TREE_CODE (op) == ARRAY_RANGE_REF)
-        {
+      if (TREE_CODE (op) == ARRAY_REF || TREE_CODE (op) == ARRAY_RANGE_REF)
+	{
 	  if (TREE_CODE (TREE_OPERAND (op, 1)) == SSA_NAME)
-	     p = or_predicates (info->conds, &p,
-				&nonconstant_names[
-				      SSA_NAME_VERSION (TREE_OPERAND (op, 1))]);
-        }
+	    p = or_predicates (info->conds, &p,
+			       &nonconstant_names[SSA_NAME_VERSION
+						  (TREE_OPERAND (op, 1))]);
+	}
       op = TREE_OPERAND (op, 0);
     }
   return p;
@@ -2304,7 +2293,8 @@  estimate_function_body_sizes (struct cgr
       if (ipa_node_params_vector.exists ())
 	{
 	  parms_info = IPA_NODE_REF (node);
-	  nonconstant_names.safe_grow_cleared(SSANAMES (my_function)->length());
+	  nonconstant_names.safe_grow_cleared
+	    (SSANAMES (my_function)->length ());
 	}
     }
 
@@ -2335,7 +2325,7 @@  estimate_function_body_sizes (struct cgr
       if (parms_info)
 	{
 	  if (bb->aux)
-	    bb_predicate = *(struct predicate *)bb->aux;
+	    bb_predicate = *(struct predicate *) bb->aux;
 	  else
 	    bb_predicate = false_predicate ();
 	}
@@ -2384,26 +2374,33 @@  estimate_function_body_sizes (struct cgr
 	      fprintf (dump_file, "  ");
 	      print_gimple_stmt (dump_file, stmt, 0, 0);
 	      fprintf (dump_file, "\t\tfreq:%3.2f size:%3i time:%3i\n",
-		       ((double)freq)/CGRAPH_FREQ_BASE, this_size, this_time);
+		       ((double) freq) / CGRAPH_FREQ_BASE, this_size,
+		       this_time);
 	    }
 
 	  if (gimple_assign_load_p (stmt) && nonconstant_names.exists ())
 	    {
 	      struct predicate this_array_index;
-	      this_array_index = array_index_predicate (info, nonconstant_names,
-						        gimple_assign_rhs1 (stmt));
+	      this_array_index =
+		array_index_predicate (info, nonconstant_names,
+				       gimple_assign_rhs1 (stmt));
 	      if (!false_predicate_p (&this_array_index))
-	        array_index = and_predicates (info->conds, &array_index, &this_array_index);
+		array_index =
+		  and_predicates (info->conds, &array_index,
+				  &this_array_index);
 	    }
 	  if (gimple_store_p (stmt) && nonconstant_names.exists ())
 	    {
 	      struct predicate this_array_index;
-	      this_array_index = array_index_predicate (info, nonconstant_names,
-						        gimple_get_lhs (stmt));
+	      this_array_index =
+		array_index_predicate (info, nonconstant_names,
+				       gimple_get_lhs (stmt));
 	      if (!false_predicate_p (&this_array_index))
-	        array_index = and_predicates (info->conds, &array_index, &this_array_index);
+		array_index =
+		  and_predicates (info->conds, &array_index,
+				  &this_array_index);
 	    }
-	   
+
 
 	  if (is_gimple_call (stmt))
 	    {
@@ -2411,8 +2408,8 @@  estimate_function_body_sizes (struct cgr
 	      struct inline_edge_summary *es = inline_edge_summary (edge);
 
 	      /* Special case: results of BUILT_IN_CONSTANT_P will be always
-		 resolved as constant.  We however don't want to optimize
-		 out the cgraph edges.  */
+	         resolved as constant.  We however don't want to optimize
+	         out the cgraph edges.  */
 	      if (nonconstant_names.exists ()
 		  && gimple_call_builtin_p (stmt, BUILT_IN_CONSTANT_P)
 		  && gimple_call_lhs (stmt)
@@ -2420,11 +2417,11 @@  estimate_function_body_sizes (struct cgr
 		{
 		  struct predicate false_p = false_predicate ();
 		  nonconstant_names[SSA_NAME_VERSION (gimple_call_lhs (stmt))]
-		      = false_p;
+		    = false_p;
 		}
 	      if (ipa_node_params_vector.exists ())
 		{
-	          int count = gimple_call_num_args (stmt);
+		  int count = gimple_call_num_args (stmt);
 		  int i;
 
 		  if (count)
@@ -2444,12 +2441,12 @@  estimate_function_body_sizes (struct cgr
 	    }
 
 	  /* TODO: When conditional jump or swithc is known to be constant, but
- 	     we did not translate it into the predicates, we really can account
+	     we did not translate it into the predicates, we really can account
 	     just maximum of the possible paths.  */
 	  if (parms_info)
 	    will_be_nonconstant
-	       = will_be_nonconstant_predicate (parms_info, info,
-						stmt, nonconstant_names);
+	      = will_be_nonconstant_predicate (parms_info, info,
+					       stmt, nonconstant_names);
 	  if (this_time || this_size)
 	    {
 	      struct predicate p;
@@ -2458,7 +2455,8 @@  estimate_function_body_sizes (struct cgr
 
 	      prob = eliminated_by_inlining_prob (stmt);
 	      if (prob == 1 && dump_file && (dump_flags & TDF_DETAILS))
-		fprintf (dump_file, "\t\t50%% will be eliminated by inlining\n");
+		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");
 
@@ -2477,8 +2475,8 @@  estimate_function_body_sizes (struct cgr
 		}
 
 	      /* We account everything but the calls.  Calls have their own
-		 size/time info attached to cgraph edges.  This is necessary
-		 in order to make the cost disappear after inlining.  */
+	         size/time info attached to cgraph edges.  This is necessary
+	         in order to make the cost disappear after inlining.  */
 	      if (!is_gimple_call (stmt))
 		{
 		  if (prob)
@@ -2516,38 +2514,42 @@  estimate_function_body_sizes (struct cgr
       scev_initialize ();
       FOR_EACH_LOOP (li, loop, 0)
 	{
-          vec<edge> exits;
-          edge ex;
+	  vec<edge> exits;
+	  edge ex;
 	  unsigned int j, i;
 	  struct tree_niter_desc niter_desc;
 	  basic_block *body = get_loop_body (loop);
-	  bb_predicate = *(struct predicate *)loop->header->aux;
+	  bb_predicate = *(struct predicate *) loop->header->aux;
 
 	  exits = get_loop_exit_edges (loop);
-          FOR_EACH_VEC_ELT (exits, j, ex)
+	  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 (parms_info, info,
-						       niter_desc.niter, nonconstant_names);
-	        if (!true_predicate_p (&will_be_nonconstant))
-		  will_be_nonconstant = and_predicates (info->conds,
-							&bb_predicate,
-							&will_be_nonconstant);
-		if (!true_predicate_p (&will_be_nonconstant)
-		    && !false_predicate_p (&will_be_nonconstant))
-		  /* This is slightly inprecise.  We may want to represent each loop with
-		     independent predicate.  */
-		  loop_iterations = and_predicates (info->conds, &loop_iterations, &will_be_nonconstant);
-	      }
-          exits.release ();
+	    {
+	      predicate will_be_nonconstant
+		= will_be_nonconstant_expr_predicate (parms_info, info,
+						      niter_desc.niter,
+						      nonconstant_names);
+	      if (!true_predicate_p (&will_be_nonconstant))
+		will_be_nonconstant = and_predicates (info->conds,
+						      &bb_predicate,
+						      &will_be_nonconstant);
+	      if (!true_predicate_p (&will_be_nonconstant)
+		  && !false_predicate_p (&will_be_nonconstant))
+		/* This is slightly inprecise.  We may want to represent each
+		   loop with independent predicate.  */
+		loop_iterations =
+		  and_predicates (info->conds, &loop_iterations,
+				  &will_be_nonconstant);
+	    }
+	  exits.release ();
 
-          for (i = 0; i < loop->num_nodes; i++)
+	  for (i = 0; i < loop->num_nodes; i++)
 	    {
 	      gimple_stmt_iterator gsi;
-	      bb_predicate = *(struct predicate *)body[i]->aux;
-	      for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi); gsi_next (&gsi))
+	      bb_predicate = *(struct predicate *) body[i]->aux;
+	      for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi);
+		   gsi_next (&gsi))
 		{
 		  gimple stmt = gsi_stmt (gsi);
 		  affine_iv iv;
@@ -2555,30 +2557,36 @@  estimate_function_body_sizes (struct cgr
 		  tree use;
 
 		  FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
-		    {
-		      predicate will_be_nonconstant;
+		  {
+		    predicate will_be_nonconstant;
 
-		      if (!simple_iv (loop, loop_containing_stmt (stmt), use, &iv, true)
-			  || is_gimple_min_invariant (iv.step))
-			continue;
+		    if (!simple_iv
+			(loop, loop_containing_stmt (stmt), use, &iv, true)
+			|| is_gimple_min_invariant (iv.step))
+		      continue;
+		    will_be_nonconstant
+		      = will_be_nonconstant_expr_predicate (parms_info, info,
+							    iv.step,
+							    nonconstant_names);
+		    if (!true_predicate_p (&will_be_nonconstant))
 		      will_be_nonconstant
-		       = will_be_nonconstant_expr_predicate (parms_info, info,
-							     iv.step, nonconstant_names);
-		      if (!true_predicate_p (&will_be_nonconstant))
-			will_be_nonconstant = and_predicates (info->conds,
-							      &bb_predicate,
-							      &will_be_nonconstant);
-		      if (!true_predicate_p (&will_be_nonconstant)
-			  && !false_predicate_p (&will_be_nonconstant))
-			/* This is slightly inprecise.  We may want to represent each loop with
-			   independent predicate.  */
-			loop_stride = and_predicates (info->conds, &loop_stride, &will_be_nonconstant);
-		    }
+			 = and_predicates (info->conds,
+					   &bb_predicate,
+					   &will_be_nonconstant);
+		    if (!true_predicate_p (&will_be_nonconstant)
+			&& !false_predicate_p (&will_be_nonconstant))
+		      /* This is slightly inprecise.  We may want to represent
+			 each loop with independent predicate.  */
+		      loop_stride =
+			and_predicates (info->conds, &loop_stride,
+					&will_be_nonconstant);
+		  }
 		}
 	    }
 	  free (body);
 	}
-      set_hint_predicate (&inline_summary (node)->loop_iterations, loop_iterations);
+      set_hint_predicate (&inline_summary (node)->loop_iterations,
+			  loop_iterations);
       set_hint_predicate (&inline_summary (node)->loop_stride, loop_stride);
       scev_finalize ();
     }
@@ -2691,8 +2699,7 @@  compute_inline_parameters (struct cgraph
   info->estimated_stack_size = info->estimated_self_stack_size;
 #ifdef ENABLE_CHECKING
   inline_update_overall_summary (node);
-  gcc_assert (info->time == info->self_time
-	      && info->size == info->self_size);
+  gcc_assert (info->time == info->self_time && info->size == info->self_size);
 #endif
 
   pop_cfun ();
@@ -2709,24 +2716,24 @@  compute_inline_parameters_for_current (v
   return 0;
 }
 
-struct gimple_opt_pass pass_inline_parameters =
+struct gimple_opt_pass pass_inline_parameters = 
 {
  {
   GIMPLE_PASS,
-  "inline_param",			/* name */
-  OPTGROUP_INLINE,                      /* optinfo_flags */
-  NULL,					/* gate */
-  compute_inline_parameters_for_current,/* execute */
-  NULL,					/* sub */
-  NULL,					/* next */
-  0,					/* static_pass_number */
-  TV_INLINE_PARAMETERS,			/* tv_id */
-  0,	                                /* properties_required */
-  0,					/* properties_provided */
-  0,					/* properties_destroyed */
-  0,					/* todo_flags_start */
-  0					/* todo_flags_finish */
- }
+  "inline_param",		/* name */
+  OPTGROUP_INLINE,		/* optinfo_flags */
+  NULL,			/* gate */
+  compute_inline_parameters_for_current,	/* execute */
+  NULL,			/* sub */
+  NULL,			/* next */
+  0,				/* static_pass_number */
+  TV_INLINE_PARAMETERS,	/* tv_id */
+  0,				/* properties_required */
+  0,				/* properties_provided */
+  0,				/* properties_destroyed */
+  0,				/* todo_flags_start */
+  0				/* todo_flags_finish */
+  }
 };
 
 
@@ -2776,7 +2783,6 @@  estimate_edge_size_and_time (struct cgra
 			     vec<tree> known_binfos,
 			     vec<ipa_agg_jump_function_p> known_aggs,
 			     inline_hints *hints)
-	
 {
   struct inline_edge_summary *es = inline_edge_summary (e);
   int call_size = es->call_stmt_size;
@@ -2784,12 +2790,11 @@  estimate_edge_size_and_time (struct cgra
   if (!e->callee
       && estimate_edge_devirt_benefit (e, &call_size, &call_time,
 				       known_vals, known_binfos, known_aggs)
-      && hints
-      && cgraph_maybe_hot_edge_p (e))
+      && hints && cgraph_maybe_hot_edge_p (e))
     *hints |= INLINE_HINT_indirect_call;
   *size += call_size * INLINE_SIZE_SCALE;
   *time += call_time * prob / REG_BR_PROB_BASE
-	    * e->frequency * (INLINE_TIME_SCALE / CGRAPH_FREQ_BASE);
+    * e->frequency * (INLINE_TIME_SCALE / CGRAPH_FREQ_BASE);
   if (*time > MAX_TIME * INLINE_TIME_SCALE)
     *time = MAX_TIME * INLINE_TIME_SCALE;
 }
@@ -2812,26 +2817,29 @@  estimate_calls_size_and_time (struct cgr
   for (e = node->callees; e; e = e->next_callee)
     {
       struct inline_edge_summary *es = inline_edge_summary (e);
-      if (!es->predicate || evaluate_predicate (es->predicate, possible_truths))
+      if (!es->predicate
+	  || evaluate_predicate (es->predicate, possible_truths))
 	{
 	  if (e->inline_failed)
 	    {
 	      /* Predicates of calls shall not use NOT_CHANGED codes,
-		 sowe do not need to compute probabilities.  */
+	         sowe do not need to compute probabilities.  */
 	      estimate_edge_size_and_time (e, size, time, REG_BR_PROB_BASE,
-					   known_vals, known_binfos, known_aggs,
-					   hints);
+					   known_vals, known_binfos,
+					   known_aggs, hints);
 	    }
 	  else
 	    estimate_calls_size_and_time (e->callee, size, time, hints,
 					  possible_truths,
-					  known_vals, known_binfos, known_aggs);
+					  known_vals, known_binfos,
+					  known_aggs);
 	}
     }
   for (e = node->indirect_calls; e; e = e->next_callee)
     {
       struct inline_edge_summary *es = inline_edge_summary (e);
-      if (!es->predicate || evaluate_predicate (es->predicate, possible_truths))
+      if (!es->predicate
+	  || evaluate_predicate (es->predicate, possible_truths))
 	estimate_edge_size_and_time (e, size, time, REG_BR_PROB_BASE,
 				     known_vals, known_binfos, known_aggs,
 				     hints);
@@ -2849,10 +2857,10 @@  estimate_node_size_and_time (struct cgra
 			     vec<tree> known_vals,
 			     vec<tree> known_binfos,
 			     vec<ipa_agg_jump_function_p> known_aggs,
-		       	     int *ret_size, int *ret_time,
+			     int *ret_size, int *ret_time,
 			     inline_hints *ret_hints,
 			     vec<inline_param_summary_t>
-			       inline_param_summary)
+			     inline_param_summary)
 {
   struct inline_summary *info = inline_summary (node);
   size_time_entry *e;
@@ -2861,24 +2869,21 @@  estimate_node_size_and_time (struct cgra
   inline_hints hints = 0;
   int i;
 
-  if (dump_file
-      && (dump_flags & TDF_DETAILS))
+  if (dump_file && (dump_flags & TDF_DETAILS))
     {
       bool found = false;
       fprintf (dump_file, "   Estimating body: %s/%i\n"
-			  "   Known to be false: ",
-	       cgraph_node_name (node),
-	       node->uid);
+	       "   Known to be false: ", cgraph_node_name (node), node->uid);
 
       for (i = predicate_not_inlined_condition;
 	   i < (predicate_first_dynamic_condition
-		+ (int)vec_safe_length (info->conds)); i++)
+		+ (int) vec_safe_length (info->conds)); i++)
 	if (!(possible_truths & (1 << i)))
 	  {
 	    if (found)
 	      fprintf (dump_file, ", ");
 	    found = true;
-            dump_condition (dump_file, info->conds, i);
+	    dump_condition (dump_file, info->conds, i);
 	  }
     }
 
@@ -2887,7 +2892,7 @@  estimate_node_size_and_time (struct cgra
       {
 	size += e->size;
 	gcc_checking_assert (e->time >= 0);
-        gcc_checking_assert (time >= 0);
+	gcc_checking_assert (time >= 0);
 	if (!inline_param_summary.exists ())
 	  time += e->time;
 	else
@@ -2898,25 +2903,25 @@  estimate_node_size_and_time (struct cgra
 					      inline_param_summary);
 	    gcc_checking_assert (prob >= 0);
 	    gcc_checking_assert (prob <= REG_BR_PROB_BASE);
-	    time += ((gcov_type)e->time * prob) / REG_BR_PROB_BASE;
+	    time += ((gcov_type) e->time * prob) / REG_BR_PROB_BASE;
 	  }
-        if (time > MAX_TIME * INLINE_TIME_SCALE)
-            time = MAX_TIME * INLINE_TIME_SCALE;
-        gcc_checking_assert (time >= 0);
-					         
+	if (time > MAX_TIME * INLINE_TIME_SCALE)
+	  time = MAX_TIME * INLINE_TIME_SCALE;
+	gcc_checking_assert (time >= 0);
+
       }
   gcc_checking_assert (size >= 0);
   gcc_checking_assert (time >= 0);
 
   if (info->loop_iterations
       && !evaluate_predicate (info->loop_iterations, possible_truths))
-    hints |=INLINE_HINT_loop_iterations;
+    hints |= INLINE_HINT_loop_iterations;
   if (info->loop_stride
       && !evaluate_predicate (info->loop_stride, possible_truths))
-    hints |=INLINE_HINT_loop_stride;
+    hints |= INLINE_HINT_loop_stride;
   if (info->array_index
       && !evaluate_predicate (info->array_index, possible_truths))
-    hints |=INLINE_HINT_array_index;
+    hints |= INLINE_HINT_array_index;
   if (info->scc_no)
     hints |= INLINE_HINT_in_scc;
   if (DECL_DECLARED_INLINE_P (node->symbol.decl))
@@ -2929,9 +2934,8 @@  estimate_node_size_and_time (struct cgra
   time = RDIV (time, INLINE_TIME_SCALE);
   size = RDIV (size, INLINE_SIZE_SCALE);
 
-  if (dump_file
-      && (dump_flags & TDF_DETAILS))
-    fprintf (dump_file, "\n   size:%i time:%i\n", (int)size, (int)time);
+  if (dump_file && (dump_flags & TDF_DETAILS))
+    fprintf (dump_file, "\n   size:%i time:%i\n", (int) size, (int) time);
   if (ret_time)
     *ret_time = time;
   if (ret_size)
@@ -2949,11 +2953,11 @@  estimate_node_size_and_time (struct cgra
 
 void
 estimate_ipcp_clone_size_and_time (struct cgraph_node *node,
-				vec<tree> known_vals,
-				vec<tree> known_binfos,
-				vec<ipa_agg_jump_function_p> known_aggs,
-				int *ret_size, int *ret_time,
-				inline_hints *hints)
+				   vec<tree> known_vals,
+				   vec<tree> known_binfos,
+				   vec<ipa_agg_jump_function_p> known_aggs,
+				   int *ret_size, int *ret_time,
+				   inline_hints *hints)
 {
   clause_t clause;
 
@@ -2982,8 +2986,7 @@  remap_predicate (struct inline_summary *
 		 struct predicate *p,
 		 vec<int> operand_map,
 		 vec<int> offset_map,
-		 clause_t possible_truths,
-		 struct predicate *toplev_predicate)
+		 clause_t possible_truths, struct predicate *toplev_predicate)
 {
   int i;
   struct predicate out = true_predicate ();
@@ -2999,7 +3002,7 @@  remap_predicate (struct inline_summary *
 
       gcc_assert (i < MAX_CLAUSES);
 
-      for (cond = 0; cond < NUM_CONDITIONS; cond ++)
+      for (cond = 0; cond < NUM_CONDITIONS; cond++)
 	/* Do we have condition we can't disprove?   */
 	if (clause & possible_truths & (1 << cond))
 	  {
@@ -3008,42 +3011,42 @@  remap_predicate (struct inline_summary *
 	       inlined function.  */
 	    if (cond >= predicate_first_dynamic_condition)
 	      {
-		 struct condition *c;
+		struct condition *c;
 
-		 c = &(*callee_info->conds)[cond
-					    - predicate_first_dynamic_condition];
-		 /* See if we can remap condition operand to caller's operand.
-		    Otherwise give up.  */
-		 if (!operand_map.exists ()
-		     || (int)operand_map.length () <= c->operand_num
-		     || operand_map[c->operand_num] == -1
-		     /* TODO: For non-aggregate conditions, adding an offset is
-			basically an arithmetic jump function processing which
-			we should support in future.  */
-		     || ((!c->agg_contents || !c->by_ref)
-			 && offset_map[c->operand_num] > 0)
-		     || (c->agg_contents && c->by_ref
-			 && offset_map[c->operand_num] < 0))
-		   cond_predicate = true_predicate ();
-		 else
-		   {
-		     struct agg_position_info ap;
-		     HOST_WIDE_INT offset_delta = offset_map[c->operand_num];
-		     if (offset_delta < 0)
-		       {
-			 gcc_checking_assert (!c->agg_contents || !c->by_ref);
-			 offset_delta = 0;
-		       }
-		     gcc_assert (!c->agg_contents
-				 || c->by_ref
-				 || offset_delta == 0);
-		     ap.offset = c->offset + offset_delta;
-		     ap.agg_contents = c->agg_contents;
-		     ap.by_ref = c->by_ref;
-		     cond_predicate = add_condition (info,
-						     operand_map[c->operand_num],
-						     &ap, c->code, c->val);
-		   }
+		c = &(*callee_info->conds)[cond
+					   -
+					   predicate_first_dynamic_condition];
+		/* See if we can remap condition operand to caller's operand.
+		   Otherwise give up.  */
+		if (!operand_map.exists ()
+		    || (int) operand_map.length () <= c->operand_num
+		    || operand_map[c->operand_num] == -1
+		    /* TODO: For non-aggregate conditions, adding an offset is
+		       basically an arithmetic jump function processing which
+		       we should support in future.  */
+		    || ((!c->agg_contents || !c->by_ref)
+			&& offset_map[c->operand_num] > 0)
+		    || (c->agg_contents && c->by_ref
+			&& offset_map[c->operand_num] < 0))
+		  cond_predicate = true_predicate ();
+		else
+		  {
+		    struct agg_position_info ap;
+		    HOST_WIDE_INT offset_delta = offset_map[c->operand_num];
+		    if (offset_delta < 0)
+		      {
+			gcc_checking_assert (!c->agg_contents || !c->by_ref);
+			offset_delta = 0;
+		      }
+		    gcc_assert (!c->agg_contents
+				|| c->by_ref || offset_delta == 0);
+		    ap.offset = c->offset + offset_delta;
+		    ap.agg_contents = c->agg_contents;
+		    ap.by_ref = c->by_ref;
+		    cond_predicate = add_condition (info,
+						    operand_map[c->operand_num],
+						    &ap, c->code, c->val);
+		  }
 	      }
 	    /* Fixed conditions remains same, construct single
 	       condition predicate.  */
@@ -3065,8 +3068,7 @@  remap_predicate (struct inline_summary *
    Compute peak stack usage.  */
 
 static void
-inline_update_callee_summaries (struct cgraph_node *node,
-			        int depth)
+inline_update_callee_summaries (struct cgraph_node *node, int depth)
 {
   struct cgraph_edge *e;
   struct inline_summary *callee_info = inline_summary (node);
@@ -3075,12 +3077,11 @@  inline_update_callee_summaries (struct c
 
   callee_info->stack_frame_offset
     = caller_info->stack_frame_offset
-      + caller_info->estimated_self_stack_size;
+    + caller_info->estimated_self_stack_size;
   peak = callee_info->stack_frame_offset
-      + callee_info->estimated_self_stack_size;
-  if (inline_summary (node->global.inlined_to)->estimated_stack_size
-      < peak)
-    inline_summary (node->global.inlined_to)->estimated_stack_size = peak;
+    + callee_info->estimated_self_stack_size;
+  if (inline_summary (node->global.inlined_to)->estimated_stack_size < peak)
+      inline_summary (node->global.inlined_to)->estimated_stack_size = peak;
   cgraph_propagate_frequency (node);
   for (e = node->callees; e; e = e->next_callee)
     {
@@ -3108,7 +3109,7 @@  remap_edge_change_prob (struct cgraph_ed
       struct ipa_edge_args *args = IPA_EDGE_REF (edge);
       struct inline_edge_summary *es = inline_edge_summary (edge);
       struct inline_edge_summary *inlined_es
-				    = inline_edge_summary (inlined_edge);
+	= inline_edge_summary (inlined_edge);
 
       for (i = 0; i < ipa_get_cs_argument_count (args); i++)
 	{
@@ -3129,7 +3130,7 @@  remap_edge_change_prob (struct cgraph_ed
 	      es->param[i].change_prob = prob;
 	    }
 	}
-  }
+    }
 }
 
 /* Update edge summaries of NODE after INLINED_EDGE has been inlined.
@@ -3140,14 +3141,14 @@  remap_edge_change_prob (struct cgraph_ed
    Also update change probabilities.  */
 
 static void
-remap_edge_summaries  (struct cgraph_edge *inlined_edge,
-		       struct cgraph_node *node,
-		       struct inline_summary *info,
-		       struct inline_summary *callee_info,
-		       vec<int> operand_map,
-		       vec<int> offset_map,
-		       clause_t possible_truths,
-		       struct predicate *toplev_predicate)
+remap_edge_summaries (struct cgraph_edge *inlined_edge,
+		      struct cgraph_node *node,
+		      struct inline_summary *info,
+		      struct inline_summary *callee_info,
+		      vec<int> operand_map,
+		      vec<int> offset_map,
+		      clause_t possible_truths,
+		      struct predicate *toplev_predicate)
 {
   struct cgraph_edge *e;
   for (e = node->callees; e; e = e->next_callee)
@@ -3163,12 +3164,11 @@  remap_edge_summaries  (struct cgraph_edg
 	    {
 	      p = remap_predicate (info, callee_info,
 				   es->predicate, operand_map, offset_map,
-				   possible_truths,
-				   toplev_predicate);
+				   possible_truths, toplev_predicate);
 	      edge_set_predicate (e, &p);
 	      /* TODO: We should remove the edge for code that will be
-		 optimized out, but we need to keep verifiers and tree-inline
-		 happy.  Make it cold for now.  */
+	         optimized out, but we need to keep verifiers and tree-inline
+	         happy.  Make it cold for now.  */
 	      if (false_predicate_p (&p))
 		{
 		  e->count = 0;
@@ -3227,17 +3227,13 @@  remap_hint_predicate (struct inline_summ
   p = remap_predicate (info, callee_info,
 		       *hint,
 		       operand_map, offset_map,
-		       possible_truths,
-		       toplev_predicate);
-  if (!false_predicate_p (&p)
-      && !true_predicate_p (&p))
+		       possible_truths, toplev_predicate);
+  if (!false_predicate_p (&p) && !true_predicate_p (&p))
     {
       if (!*hint)
 	set_hint_predicate (hint, p);
       else
-	**hint = and_predicates (info->conds, 
-				 *hint,
-				 &p);
+	**hint = and_predicates (info->conds, *hint, &p);
     }
 }
 
@@ -3312,19 +3308,19 @@  inline_merge_summary (struct cgraph_edge
 					    &toplev_predicate);
       if (!false_predicate_p (&p))
 	{
-	  gcov_type add_time = ((gcov_type)e->time * edge->frequency
+	  gcov_type add_time = ((gcov_type) e->time * edge->frequency
 				+ CGRAPH_FREQ_BASE / 2) / CGRAPH_FREQ_BASE;
 	  int prob = predicate_probability (callee_info->conds,
 					    &e->predicate,
 					    clause, es->param);
-	  add_time = ((gcov_type)add_time * prob) / REG_BR_PROB_BASE;
+	  add_time = ((gcov_type) add_time * prob) / REG_BR_PROB_BASE;
 	  if (add_time > MAX_TIME * INLINE_TIME_SCALE)
 	    add_time = MAX_TIME * INLINE_TIME_SCALE;
 	  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);
+		       (double) prob / REG_BR_PROB_BASE);
 	    }
 	  account_size_time (info, e->size, add_time, &p);
 	}
@@ -3333,16 +3329,13 @@  inline_merge_summary (struct cgraph_edge
 			offset_map, clause, &toplev_predicate);
   remap_hint_predicate (info, callee_info,
 			&callee_info->loop_iterations,
-			operand_map, offset_map,
-			clause, &toplev_predicate);
+			operand_map, offset_map, clause, &toplev_predicate);
   remap_hint_predicate (info, callee_info,
 			&callee_info->loop_stride,
-			operand_map, offset_map,
-			clause, &toplev_predicate);
+			operand_map, offset_map, clause, &toplev_predicate);
   remap_hint_predicate (info, callee_info,
 			&callee_info->array_index,
-			operand_map, offset_map,
-			clause, &toplev_predicate);
+			operand_map, offset_map, clause, &toplev_predicate);
 
   inline_update_callee_summaries (edge->callee,
 				  inline_edge_summary (edge)->loop_depth);
@@ -3371,10 +3364,10 @@  inline_update_overall_summary (struct cg
     {
       info->size += e->size, info->time += e->time;
       if (info->time > MAX_TIME * INLINE_TIME_SCALE)
-        info->time = MAX_TIME * INLINE_TIME_SCALE;
+	info->time = MAX_TIME * INLINE_TIME_SCALE;
     }
   estimate_calls_size_and_time (node, &info->size, &info->time, NULL,
-				~(clause_t)(1 << predicate_false_condition),
+				~(clause_t) (1 << predicate_false_condition),
 				vNULL, vNULL, vNULL);
   info->time = (info->time + INLINE_TIME_SCALE / 2) / INLINE_TIME_SCALE;
   info->size = (info->size + INLINE_SIZE_SCALE / 2) / INLINE_SIZE_SCALE;
@@ -3386,8 +3379,7 @@  simple_edge_hints (struct cgraph_edge *e
 {
   int hints = 0;
   struct cgraph_node *to = (edge->caller->global.inlined_to
-			    ? edge->caller->global.inlined_to
-			    : edge->caller);
+			    ? edge->caller->global.inlined_to : edge->caller);
   if (inline_summary (to)->scc_no
       && inline_summary (to)->scc_no == inline_summary (edge->callee)->scc_no
       && !cgraph_edge_recursive_p (edge))
@@ -3437,7 +3429,7 @@  do_estimate_edge_time (struct cgraph_edg
   /* When caching, update the cache entry.  */
   if (edge_growth_cache.exists ())
     {
-      if ((int)edge_growth_cache.length () <= edge->uid)
+      if ((int) edge_growth_cache.length () <= edge->uid)
 	edge_growth_cache.safe_grow_cleared (cgraph_edge_max_uid);
       edge_growth_cache[edge->uid].time = time + (time >= 0);
 
@@ -3537,7 +3529,8 @@  estimate_time_after_inlining (struct cgr
   struct inline_edge_summary *es = inline_edge_summary (edge);
   if (!es->predicate || !false_predicate_p (es->predicate))
     {
-      gcov_type time = inline_summary (node)->time + estimate_edge_time (edge);
+      gcov_type time =
+	inline_summary (node)->time + estimate_edge_time (edge);
       if (time < 0)
 	time = 0;
       if (time > MAX_TIME)
@@ -3588,7 +3581,7 @@  do_estimate_growth_1 (struct cgraph_node
       if (e->caller == node
 	  || (e->caller->global.inlined_to
 	      && e->caller->global.inlined_to == node))
-        d->self_recursive = true;
+	d->self_recursive = true;
       d->growth += estimate_edge_growth (e);
     }
   return false;
@@ -3600,7 +3593,7 @@  do_estimate_growth_1 (struct cgraph_node
 int
 do_estimate_growth (struct cgraph_node *node)
 {
-  struct growth_data d = {0, false};
+  struct growth_data d = { 0, false };
   struct inline_summary *info = inline_summary (node);
 
   cgraph_for_node_and_aliases (node, do_estimate_growth_1, &d, true);
@@ -3618,10 +3611,10 @@  do_estimate_growth (struct cgraph_node *
       if (cgraph_will_be_removed_from_program_if_no_direct_calls (node))
 	d.growth -= info->size;
       /* COMDAT functions are very often not shared across multiple units
-	 since they come from various template instantiations.
-	 Take this into account.  */
-      else  if (DECL_COMDAT (node->symbol.decl)
-		&& cgraph_can_remove_if_no_direct_calls_p (node))
+         since they come from various template instantiations.
+         Take this into account.  */
+      else if (DECL_COMDAT (node->symbol.decl)
+	       && cgraph_can_remove_if_no_direct_calls_p (node))
 	d.growth -= (info->size
 		     * (100 - PARAM_VALUE (PARAM_COMDAT_SHARING_PROBABILITY))
 		     + 50) / 100;
@@ -3629,7 +3622,7 @@  do_estimate_growth (struct cgraph_node *
 
   if (node_growth_cache.exists ())
     {
-      if ((int)node_growth_cache.length () <= node->uid)
+      if ((int) node_growth_cache.length () <= node->uid)
 	node_growth_cache.safe_grow_cleared (cgraph_max_uid);
       node_growth_cache[node->uid] = d.growth + (d.growth >= 0);
     }
@@ -3687,7 +3680,7 @@  inline_generate_summary (void)
   struct cgraph_node *node;
 
   function_insertion_hook_holder =
-      cgraph_add_function_insertion_hook (&add_new_function, NULL);
+    cgraph_add_function_insertion_hook (&add_new_function, NULL);
 
   ipa_register_cgraph_hooks ();
   inline_free_summary ();
@@ -3707,7 +3700,7 @@  read_predicate (struct lto_input_block *
   clause_t clause;
   int k = 0;
 
-  do 
+  do
     {
       gcc_assert (k <= MAX_CLAUSES);
       clause = out.clause[k++] = streamer_read_uhwi (ib);
@@ -3741,8 +3734,7 @@  read_inline_edge_summary (struct lto_inp
     {
       es->param.safe_grow_cleared (length);
       for (i = 0; i < length; i++)
-	es->param[i].change_prob
-	  = streamer_read_uhwi (ib);
+	es->param[i].change_prob = streamer_read_uhwi (ib);
     }
 }
 
@@ -3820,7 +3812,7 @@  inline_read_section (struct lto_file_dec
 
 	  vec_safe_push (info->entry, e);
 	}
-     
+
       p = read_predicate (&ib);
       set_hint_predicate (&info->loop_iterations, p);
       p = read_predicate (&ib);
@@ -3859,7 +3851,7 @@  inline_read_summary (void)
 					       LTO_section_inline_summary,
 					       NULL, &len);
       if (data)
-        inline_read_section (file_data, data, len);
+	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
@@ -3870,10 +3862,10 @@  inline_read_summary (void)
     {
       ipa_register_cgraph_hooks ();
       if (!flag_ipa_cp)
-        ipa_prop_read_jump_functions ();
+	ipa_prop_read_jump_functions ();
     }
   function_insertion_hook_holder =
-      cgraph_add_function_insertion_hook (&add_new_function, NULL);
+    cgraph_add_function_insertion_hook (&add_new_function, NULL);
 }
 
 
@@ -3886,8 +3878,8 @@  write_predicate (struct output_block *ob
   if (p)
     for (j = 0; p->clause[j]; j++)
       {
-	 gcc_assert (j < MAX_CLAUSES);
-	 streamer_write_uhwi (ob, p->clause[j]);
+	gcc_assert (j < MAX_CLAUSES);
+	streamer_write_uhwi (ob, p->clause[j]);
       }
   streamer_write_uhwi (ob, 0);
 }
@@ -3906,7 +3898,7 @@  write_inline_edge_summary (struct output
   streamer_write_uhwi (ob, es->loop_depth);
   write_predicate (ob, es->predicate);
   streamer_write_uhwi (ob, es->param.length ());
-  for (i = 0; i < (int)es->param.length (); i++)
+  for (i = 0; i < (int) es->param.length (); i++)
     streamer_write_uhwi (ob, es->param[i].change_prob);
 }
 
@@ -3945,8 +3937,11 @@  inline_write_summary (void)
 	  int i;
 	  size_time_entry *e;
 	  struct condition *c;
-  
-	  streamer_write_uhwi (ob, lto_symtab_encoder_encode (encoder, (symtab_node)node));
+
+	  streamer_write_uhwi (ob,
+			       lto_symtab_encoder_encode (encoder,
+							  (symtab_node)
+							  node));
 	  streamer_write_hwi (ob, info->estimated_self_stack_size);
 	  streamer_write_hwi (ob, info->self_size);
 	  streamer_write_hwi (ob, info->self_time);
@@ -3964,7 +3959,7 @@  inline_write_summary (void)
 	      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, c->offset);
 	    }
 	  streamer_write_uhwi (ob, vec_safe_length (info->entry));
 	  for (i = 0; vec_safe_iterate (info->entry, i, &e); i++)