LCOV - code coverage report
Current view: top level - gcc - ipa-fnsummary.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2152 2275 94.6 %
Date: 2020-04-04 11:58:09 Functions: 79 80 98.8 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Function summary pass.
       2                 :            :    Copyright (C) 2003-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Jan Hubicka
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : /* Analysis of function bodies used by inter-procedural passes
      22                 :            : 
      23                 :            :    We estimate for each function
      24                 :            :      - function body size and size after specializing into given context
      25                 :            :      - average function execution time in a given context
      26                 :            :      - function frame size
      27                 :            :    For each call
      28                 :            :      - call statement size, time and how often the parameters change
      29                 :            : 
      30                 :            :    ipa_fn_summary data structures store above information locally (i.e.
      31                 :            :    parameters of the function itself) and globally (i.e. parameters of
      32                 :            :    the function created by applying all the inline decisions already
      33                 :            :    present in the callgraph).
      34                 :            : 
      35                 :            :    We provide access to the ipa_fn_summary data structure and
      36                 :            :    basic logic updating the parameters when inlining is performed. 
      37                 :            : 
      38                 :            :    The summaries are context sensitive.  Context means
      39                 :            :      1) partial assignment of known constant values of operands
      40                 :            :      2) whether function is inlined into the call or not.
      41                 :            :    It is easy to add more variants.  To represent function size and time
      42                 :            :    that depends on context (i.e. it is known to be optimized away when
      43                 :            :    context is known either by inlining or from IP-CP and cloning),
      44                 :            :    we use predicates.
      45                 :            : 
      46                 :            :    estimate_edge_size_and_time can be used to query
      47                 :            :    function size/time in the given context.  ipa_merge_fn_summary_after_inlining merges
      48                 :            :    properties of caller and callee after inlining.
      49                 :            : 
      50                 :            :    Finally pass_inline_parameters is exported.  This is used to drive
      51                 :            :    computation of function parameters used by the early inliner. IPA
      52                 :            :    inlined performs analysis via its analyze_function method. */
      53                 :            : 
      54                 :            : #include "config.h"
      55                 :            : #include "system.h"
      56                 :            : #include "coretypes.h"
      57                 :            : #include "backend.h"
      58                 :            : #include "tree.h"
      59                 :            : #include "gimple.h"
      60                 :            : #include "alloc-pool.h"
      61                 :            : #include "tree-pass.h"
      62                 :            : #include "ssa.h"
      63                 :            : #include "tree-streamer.h"
      64                 :            : #include "cgraph.h"
      65                 :            : #include "diagnostic.h"
      66                 :            : #include "fold-const.h"
      67                 :            : #include "print-tree.h"
      68                 :            : #include "tree-inline.h"
      69                 :            : #include "gimple-pretty-print.h"
      70                 :            : #include "cfganal.h"
      71                 :            : #include "gimple-iterator.h"
      72                 :            : #include "tree-cfg.h"
      73                 :            : #include "tree-ssa-loop-niter.h"
      74                 :            : #include "tree-ssa-loop.h"
      75                 :            : #include "symbol-summary.h"
      76                 :            : #include "ipa-prop.h"
      77                 :            : #include "ipa-fnsummary.h"
      78                 :            : #include "cfgloop.h"
      79                 :            : #include "tree-scalar-evolution.h"
      80                 :            : #include "ipa-utils.h"
      81                 :            : #include "cfgexpand.h"
      82                 :            : #include "gimplify.h"
      83                 :            : #include "stringpool.h"
      84                 :            : #include "attribs.h"
      85                 :            : #include "tree-into-ssa.h"
      86                 :            : 
      87                 :            : /* Summaries.  */
      88                 :            : fast_function_summary <ipa_fn_summary *, va_gc> *ipa_fn_summaries;
      89                 :            : fast_function_summary <ipa_size_summary *, va_heap> *ipa_size_summaries;
      90                 :            : fast_call_summary <ipa_call_summary *, va_heap> *ipa_call_summaries;
      91                 :            : 
      92                 :            : /* Edge predicates goes here.  */
      93                 :            : static object_allocator<predicate> edge_predicate_pool ("edge predicates");
      94                 :            : 
      95                 :            : 
      96                 :            : /* Dump IPA hints.  */
      97                 :            : void
      98                 :        194 : ipa_dump_hints (FILE *f, ipa_hints hints)
      99                 :            : {
     100                 :        194 :   if (!hints)
     101                 :            :     return;
     102                 :        155 :   fprintf (f, "IPA hints:");
     103                 :        155 :   if (hints & INLINE_HINT_indirect_call)
     104                 :            :     {
     105                 :         26 :       hints &= ~INLINE_HINT_indirect_call;
     106                 :         26 :       fprintf (f, " indirect_call");
     107                 :            :     }
     108                 :        155 :   if (hints & INLINE_HINT_loop_iterations)
     109                 :            :     {
     110                 :          2 :       hints &= ~INLINE_HINT_loop_iterations;
     111                 :          2 :       fprintf (f, " loop_iterations");
     112                 :            :     }
     113                 :        155 :   if (hints & INLINE_HINT_loop_stride)
     114                 :            :     {
     115                 :          2 :       hints &= ~INLINE_HINT_loop_stride;
     116                 :          2 :       fprintf (f, " loop_stride");
     117                 :            :     }
     118                 :        155 :   if (hints & INLINE_HINT_same_scc)
     119                 :            :     {
     120                 :          4 :       hints &= ~INLINE_HINT_same_scc;
     121                 :          4 :       fprintf (f, " same_scc");
     122                 :            :     }
     123                 :        155 :   if (hints & INLINE_HINT_in_scc)
     124                 :            :     {
     125                 :         11 :       hints &= ~INLINE_HINT_in_scc;
     126                 :         11 :       fprintf (f, " in_scc");
     127                 :            :     }
     128                 :        155 :   if (hints & INLINE_HINT_cross_module)
     129                 :            :     {
     130                 :          1 :       hints &= ~INLINE_HINT_cross_module;
     131                 :          1 :       fprintf (f, " cross_module");
     132                 :            :     }
     133                 :        155 :   if (hints & INLINE_HINT_declared_inline)
     134                 :            :     {
     135                 :        130 :       hints &= ~INLINE_HINT_declared_inline;
     136                 :        130 :       fprintf (f, " declared_inline");
     137                 :            :     }
     138                 :        155 :   if (hints & INLINE_HINT_known_hot)
     139                 :            :     {
     140                 :          0 :       hints &= ~INLINE_HINT_known_hot;
     141                 :          0 :       fprintf (f, " known_hot");
     142                 :            :     }
     143                 :        155 :   gcc_assert (!hints);
     144                 :            : }
     145                 :            : 
     146                 :            : 
     147                 :            : /* Record SIZE and TIME to SUMMARY.
     148                 :            :    The accounted code will be executed when EXEC_PRED is true.
     149                 :            :    When NONCONST_PRED is false the code will evaluate to constant and
     150                 :            :    will get optimized out in specialized clones of the function.
     151                 :            :    If CALL is true account to call_size_time_table rather than
     152                 :            :    size_time_table.   */
     153                 :            : 
     154                 :            : void
     155                 :   86266900 : ipa_fn_summary::account_size_time (int size, sreal time,
     156                 :            :                                    const predicate &exec_pred,
     157                 :            :                                    const predicate &nonconst_pred_in,
     158                 :            :                                    bool call)
     159                 :            : {
     160                 :   86266900 :   size_time_entry *e;
     161                 :   86266900 :   bool found = false;
     162                 :   86266900 :   int i;
     163                 :   86266900 :   predicate nonconst_pred;
     164                 :  172534000 :   vec<size_time_entry, va_gc> *table = call
     165                 :   86266900 :                                        ? call_size_time_table : size_time_table;
     166                 :            : 
     167                 :   86266900 :   if (exec_pred == false)
     168                 :    2039010 :     return;
     169                 :            : 
     170                 :   86207600 :   nonconst_pred = nonconst_pred_in & exec_pred;
     171                 :            : 
     172                 :   88246700 :   if (nonconst_pred == false)
     173                 :            :     return;
     174                 :            : 
     175                 :            :   /* We need to create initial empty unconditional clause, but otherwise
     176                 :            :      we don't need to account empty times and sizes.  */
     177                 :   99936300 :   if (!size && time == 0 && table)
     178                 :    1584120 :     return;
     179                 :            : 
     180                 :            :   /* Only for calls we are unaccounting what we previously recorded.  */
     181                 :   84227900 :   gcc_checking_assert (time >= 0 || call);
     182                 :            : 
     183                 :  276681000 :   for (i = 0; vec_safe_iterate (table, i, &e); i++)
     184                 :  260712000 :     if (e->exec_predicate == exec_pred
     185                 :  260712000 :         && e->nonconst_predicate == nonconst_pred)
     186                 :            :       {
     187                 :            :         found = true;
     188                 :            :         break;
     189                 :            :       }
     190                 :   84227900 :   if (i == max_size_time_table_size)
     191                 :            :     {
     192                 :          0 :       i = 0;
     193                 :          0 :       found = true;
     194                 :          0 :       e = &(*table)[0];
     195                 :          0 :       if (dump_file && (dump_flags & TDF_DETAILS))
     196                 :          0 :         fprintf (dump_file,
     197                 :            :                  "\t\tReached limit on number of entries, "
     198                 :            :                  "ignoring the predicate.");
     199                 :            :     }
     200                 :   84232300 :   if (dump_file && (dump_flags & TDF_DETAILS) && (time != 0 || size))
     201                 :            :     {
     202                 :       4009 :       fprintf (dump_file,
     203                 :            :                "\t\tAccounting size:%3.2f, time:%3.2f on %spredicate exec:",
     204                 :       3808 :                ((double) size) / ipa_fn_summary::size_scale,
     205                 :            :                (time.to_double ()), found ? "" : "new ");
     206                 :       3808 :       exec_pred.dump (dump_file, conds, 0);
     207                 :       3808 :       if (exec_pred != nonconst_pred)
     208                 :            :         {
     209                 :         91 :           fprintf (dump_file, " nonconst:");
     210                 :         91 :           nonconst_pred.dump (dump_file, conds);
     211                 :            :         }
     212                 :            :       else
     213                 :       3717 :         fprintf (dump_file, "\n");
     214                 :            :     }
     215                 :   84227900 :   if (!found)
     216                 :            :     {
     217                 :   15968900 :       class size_time_entry new_entry;
     218                 :   15968900 :       new_entry.size = size;
     219                 :   15968900 :       new_entry.time = time;
     220                 :   15968900 :       new_entry.exec_predicate = exec_pred;
     221                 :   15968900 :       new_entry.nonconst_predicate = nonconst_pred;
     222                 :   15968900 :       if (call)
     223                 :    1098130 :         vec_safe_push (call_size_time_table, new_entry);
     224                 :            :       else
     225                 :   14870800 :         vec_safe_push (size_time_table, new_entry);
     226                 :            :     }
     227                 :            :   else
     228                 :            :     {
     229                 :   68259000 :       e->size += size;
     230                 :   68259000 :       e->time += time;
     231                 :            :       /* FIXME: PR bootstrap/92653 gcc_checking_assert (e->time >= -1); */
     232                 :            :       /* Tolerate small roundoff issues.  */
     233                 :  136518000 :       if (e->time < 0)
     234                 :         24 :         e->time = 0;
     235                 :            :     }
     236                 :            : }
     237                 :            : 
     238                 :            : /* We proved E to be unreachable, redirect it to __builtin_unreachable.  */
     239                 :            : 
     240                 :            : static struct cgraph_edge *
     241                 :      64628 : redirect_to_unreachable (struct cgraph_edge *e)
     242                 :            : {
     243                 :      64628 :   struct cgraph_node *callee = !e->inline_failed ? e->callee : NULL;
     244                 :      64628 :   struct cgraph_node *target = cgraph_node::get_create
     245                 :      64628 :                       (builtin_decl_implicit (BUILT_IN_UNREACHABLE));
     246                 :            : 
     247                 :      64628 :   if (e->speculative)
     248                 :        145 :     e = cgraph_edge::resolve_speculation (e, target->decl);
     249                 :      64483 :   else if (!e->callee)
     250                 :        425 :     e = cgraph_edge::make_direct (e, target);
     251                 :            :   else
     252                 :      64058 :     e->redirect_callee (target);
     253                 :      64628 :   class ipa_call_summary *es = ipa_call_summaries->get (e);
     254                 :      64628 :   e->inline_failed = CIF_UNREACHABLE;
     255                 :      64628 :   e->count = profile_count::zero ();
     256                 :      64628 :   es->call_stmt_size = 0;
     257                 :      64628 :   es->call_stmt_time = 0;
     258                 :      64628 :   if (callee)
     259                 :          0 :     callee->remove_symbol_and_inline_clones ();
     260                 :      64628 :   return e;
     261                 :            : }
     262                 :            : 
     263                 :            : /* Set predicate for edge E.  */
     264                 :            : 
     265                 :            : static void
     266                 :   18017100 : edge_set_predicate (struct cgraph_edge *e, predicate *predicate)
     267                 :            : {
     268                 :            :   /* If the edge is determined to be never executed, redirect it
     269                 :            :      to BUILTIN_UNREACHABLE to make it clear to IPA passes the call will
     270                 :            :      be optimized out.  */
     271                 :   36099000 :   if (predicate && *predicate == false
     272                 :            :       /* When handling speculative edges, we need to do the redirection
     273                 :            :          just once.  Do it always on the direct edge, so we do not
     274                 :            :          attempt to resolve speculation while duplicating the edge.  */
     275                 :   18081900 :       && (!e->speculative || e->callee))
     276                 :      64628 :     e = redirect_to_unreachable (e);
     277                 :            : 
     278                 :   18017100 :   class ipa_call_summary *es = ipa_call_summaries->get (e);
     279                 :   34722500 :   if (predicate && *predicate != true)
     280                 :            :     {
     281                 :    1988750 :       if (!es->predicate)
     282                 :    1857200 :         es->predicate = edge_predicate_pool.allocate ();
     283                 :    1988750 :       *es->predicate = *predicate;
     284                 :            :     }
     285                 :            :   else
     286                 :            :     {
     287                 :   16028400 :       if (es->predicate)
     288                 :     202585 :         edge_predicate_pool.remove (es->predicate);
     289                 :   16028400 :       es->predicate = NULL;
     290                 :            :     }
     291                 :   18017100 : }
     292                 :            : 
     293                 :            : /* Set predicate for hint *P.  */
     294                 :            : 
     295                 :            : static void
     296                 :    1945220 : set_hint_predicate (predicate **p, predicate new_predicate)
     297                 :            : {
     298                 :    1945220 :   if (new_predicate == false || new_predicate == true)
     299                 :            :     {
     300                 :    1904870 :       if (*p)
     301                 :          0 :         edge_predicate_pool.remove (*p);
     302                 :    1904870 :       *p = NULL;
     303                 :            :     }
     304                 :            :   else
     305                 :            :     {
     306                 :      40352 :       if (!*p)
     307                 :      40352 :         *p = edge_predicate_pool.allocate ();
     308                 :      40352 :       **p = new_predicate;
     309                 :            :     }
     310                 :    1945220 : }
     311                 :            : 
     312                 :            : 
     313                 :            : /* Compute what conditions may or may not hold given information about
     314                 :            :    parameters.  RET_CLAUSE returns truths that may hold in a specialized copy,
     315                 :            :    while RET_NONSPEC_CLAUSE returns truths that may hold in an nonspecialized
     316                 :            :    copy when called in a given context.  It is a bitmask of conditions. Bit
     317                 :            :    0 means that condition is known to be false, while bit 1 means that condition
     318                 :            :    may or may not be true.  These differs - for example NOT_INLINED condition
     319                 :            :    is always false in the second and also builtin_constant_p tests cannot use
     320                 :            :    the fact that parameter is indeed a constant.
     321                 :            : 
     322                 :            :    KNOWN_VALS is partial mapping of parameters of NODE to constant values.
     323                 :            :    KNOWN_AGGS is a vector of aggregate known offset/value set for each
     324                 :            :    parameter.  Return clause of possible truths.  When INLINE_P is true, assume
     325                 :            :    that we are inlining.
     326                 :            : 
     327                 :            :    ERROR_MARK means compile time invariant.  */
     328                 :            : 
     329                 :            : static void
     330                 :   11270700 : evaluate_conditions_for_known_args (struct cgraph_node *node,
     331                 :            :                                     bool inline_p,
     332                 :            :                                     vec<tree> known_vals,
     333                 :            :                                     vec<value_range> known_value_ranges,
     334                 :            :                                     vec<ipa_agg_value_set> known_aggs,
     335                 :            :                                     clause_t *ret_clause,
     336                 :            :                                     clause_t *ret_nonspec_clause)
     337                 :            : {
     338                 :   11270700 :   clause_t clause = inline_p ? 0 : 1 << predicate::not_inlined_condition;
     339                 :   11270700 :   clause_t nonspec_clause = 1 << predicate::not_inlined_condition;
     340                 :   11270700 :   class ipa_fn_summary *info = ipa_fn_summaries->get (node);
     341                 :   11270700 :   int i;
     342                 :   11270700 :   struct condition *c;
     343                 :            : 
     344                 :   30103300 :   for (i = 0; vec_safe_iterate (info->conds, i, &c); i++)
     345                 :            :     {
     346                 :   18832600 :       tree val = NULL;
     347                 :   18832600 :       tree res;
     348                 :   18832600 :       int j;
     349                 :   18832600 :       struct expr_eval_op *op;
     350                 :            : 
     351                 :            :       /* We allow call stmt to have fewer arguments than the callee function
     352                 :            :          (especially for K&R style programs).  So bound check here (we assume
     353                 :            :          known_aggs vector, if non-NULL, has the same length as
     354                 :            :          known_vals).  */
     355                 :   18832600 :       gcc_checking_assert (!known_aggs.length () || !known_vals.length ()
     356                 :            :                            || (known_vals.length () == known_aggs.length ()));
     357                 :            : 
     358                 :   18832600 :       if (c->agg_contents)
     359                 :            :         {
     360                 :    9710540 :           struct ipa_agg_value_set *agg;
     361                 :            : 
     362                 :    9713740 :           if (c->code == predicate::changed
     363                 :    9710540 :               && !c->by_ref
     364                 :    2243190 :               && c->operand_num < (int)known_vals.length ()
     365                 :    9918420 :               && (known_vals[c->operand_num] == error_mark_node))
     366                 :   18832600 :             continue;
     367                 :            : 
     368                 :   19404300 :           if (c->operand_num < (int)known_aggs.length ())
     369                 :            :             {
     370                 :     866541 :               agg = &known_aggs[c->operand_num];
     371                 :     866541 :               val = ipa_find_agg_cst_for_param (agg,
     372                 :            :                                                 c->operand_num
     373                 :    1733080 :                                                    < (int) known_vals.length ()
     374                 :     505407 :                                                 ? known_vals[c->operand_num]
     375                 :            :                                                 : NULL,
     376                 :            :                                                 c->offset, c->by_ref);
     377                 :            :             }
     378                 :            :           else
     379                 :            :             val = NULL_TREE;
     380                 :            :         }
     381                 :   18244000 :       else if (c->operand_num < (int) known_vals.length ())
     382                 :            :         {
     383                 :    4951480 :           val = known_vals[c->operand_num];
     384                 :    4951480 :           if (val == error_mark_node && c->code != predicate::changed)
     385                 :            :             val = NULL_TREE;
     386                 :            :         }
     387                 :            : 
     388                 :    5745230 :       if (!val
     389                 :   14491600 :           && (c->code == predicate::changed
     390                 :            :               || c->code == predicate::is_not_constant))
     391                 :            :         {
     392                 :   11215600 :           clause |= 1 << (i + predicate::first_dynamic_condition);
     393                 :   11215600 :           nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
     394                 :   11215600 :           continue;
     395                 :            :         }
     396                 :    7613790 :       if (c->code == predicate::changed)
     397                 :            :         {
     398                 :    2840980 :           nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
     399                 :    2840980 :           continue;
     400                 :            :         }
     401                 :            : 
     402                 :    4772810 :       if (c->code == predicate::is_not_constant)
     403                 :            :         {
     404                 :       2308 :           nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
     405                 :       2308 :           continue;
     406                 :            :         }
     407                 :            : 
     408                 :    4770500 :       if (val && TYPE_SIZE (c->type) == TYPE_SIZE (TREE_TYPE (val)))
     409                 :            :         {
     410                 :    1454980 :           if (c->type != TREE_TYPE (val))
     411                 :     511596 :             val = fold_unary (VIEW_CONVERT_EXPR, c->type, val);
     412                 :    1547160 :           for (j = 0; vec_safe_iterate (c->param_ops, j, &op); j++)
     413                 :            :             {
     414                 :      92772 :               if (!val)
     415                 :            :                 break;
     416                 :      92175 :               if (!op->val[0])
     417                 :      33476 :                 val = fold_unary (op->code, op->type, val);
     418                 :      58699 :               else if (!op->val[1])
     419                 :     117398 :                 val = fold_binary (op->code, op->type,
     420                 :            :                                    op->index ? op->val[0] : val,
     421                 :            :                                    op->index ? val : op->val[0]);
     422                 :          0 :               else if (op->index == 0)
     423                 :          0 :                 val = fold_ternary (op->code, op->type,
     424                 :            :                                     val, op->val[0], op->val[1]);
     425                 :          0 :               else if (op->index == 1)
     426                 :          0 :                 val = fold_ternary (op->code, op->type,
     427                 :            :                                     op->val[0], val, op->val[1]);
     428                 :          0 :               else if (op->index == 2)
     429                 :          0 :                 val = fold_ternary (op->code, op->type,
     430                 :            :                                     op->val[0], op->val[1], val);
     431                 :            :               else
     432                 :            :                 val = NULL_TREE;
     433                 :            :             }
     434                 :            : 
     435                 :    3667230 :           res = val
     436                 :    1454980 :             ? fold_binary_to_constant (c->code, boolean_type_node, val, c->val)
     437                 :            :             : NULL;
     438                 :            : 
     439                 :    1454380 :           if (res && integer_zerop (res))
     440                 :     697105 :             continue;
     441                 :     757875 :           if (res && integer_onep (res))
     442                 :            :             {
     443                 :     746453 :               clause |= 1 << (i + predicate::first_dynamic_condition);
     444                 :     746453 :               nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
     445                 :     746453 :               continue;
     446                 :            :             }
     447                 :            :         }
     448                 :    3326940 :       if (c->operand_num < (int) known_value_ranges.length ()
     449                 :          0 :           && !c->agg_contents
     450                 :          0 :           && !known_value_ranges[c->operand_num].undefined_p ()
     451                 :          0 :           && !known_value_ranges[c->operand_num].varying_p ()
     452                 :          0 :           && TYPE_SIZE (c->type)
     453                 :          0 :                  == TYPE_SIZE (known_value_ranges[c->operand_num].type ())
     454                 :    3326940 :           && (!val || TREE_CODE (val) != INTEGER_CST))
     455                 :            :         {
     456                 :          0 :           value_range vr = known_value_ranges[c->operand_num];
     457                 :          0 :           if (!useless_type_conversion_p (c->type, vr.type ()))
     458                 :            :             {
     459                 :          0 :               value_range res;
     460                 :          0 :               range_fold_unary_expr (&res, NOP_EXPR,
     461                 :            :                                      c->type, &vr, vr.type ());
     462                 :          0 :               vr = res;
     463                 :            :             }
     464                 :          0 :           tree type = c->type;
     465                 :            : 
     466                 :          0 :           for (j = 0; vec_safe_iterate (c->param_ops, j, &op); j++)
     467                 :            :             {
     468                 :          0 :               if (vr.varying_p () || vr.undefined_p ())
     469                 :            :                 break;
     470                 :            : 
     471                 :          0 :               value_range res;
     472                 :          0 :               if (!op->val[0])
     473                 :          0 :                 range_fold_unary_expr (&res, op->code, op->type, &vr, type);
     474                 :          0 :               else if (!op->val[1])
     475                 :            :                 {
     476                 :          0 :                   value_range op0 (op->val[0], op->val[0]);
     477                 :          0 :                   range_fold_binary_expr (&res, op->code, op->type,
     478                 :            :                                           op->index ? &op0 : &vr,
     479                 :          0 :                                           op->index ? &vr : &op0);
     480                 :            :                 }
     481                 :            :               else
     482                 :          0 :                 gcc_unreachable ();
     483                 :          0 :               type = op->type;
     484                 :          0 :               vr = res;
     485                 :            :             }
     486                 :          0 :           if (!vr.varying_p () && !vr.undefined_p ())
     487                 :            :             {
     488                 :          0 :               value_range res;
     489                 :          0 :               value_range val_vr (c->val, c->val);
     490                 :          0 :               range_fold_binary_expr (&res, c->code, boolean_type_node,
     491                 :            :                                       &vr,
     492                 :            :                                       &val_vr);
     493                 :          0 :               if (res.zero_p ())
     494                 :          0 :                 continue;
     495                 :            :             }
     496                 :            :         }
     497                 :            : 
     498                 :    3326940 :       clause |= 1 << (i + predicate::first_dynamic_condition);
     499                 :    3326940 :       nonspec_clause |= 1 << (i + predicate::first_dynamic_condition);
     500                 :            :     }
     501                 :   11270700 :   *ret_clause = clause;
     502                 :   11270700 :   if (ret_nonspec_clause)
     503                 :    9944480 :     *ret_nonspec_clause = nonspec_clause;
     504                 :   11270700 : }
     505                 :            : 
     506                 :            : 
     507                 :            : /* Work out what conditions might be true at invocation of E.
     508                 :            :    Compute costs for inlined edge if INLINE_P is true.
     509                 :            : 
     510                 :            :    Return in CLAUSE_PTR the evaluated conditions and in NONSPEC_CLAUSE_PTR
     511                 :            :    (if non-NULL) conditions evaluated for nonspecialized clone called
     512                 :            :    in a given context.
     513                 :            : 
     514                 :            :    KNOWN_VALS_PTR and KNOWN_AGGS_PTR must be non-NULL and will be filled by
     515                 :            :    known constant and aggregate values of parameters.
     516                 :            : 
     517                 :            :    KNOWN_CONTEXT_PTR, if non-NULL, will be filled by polymorphic call contexts
     518                 :            :    of parameter used by a polymorphic call.  */
     519                 :            : 
     520                 :            : void
     521                 :   11132400 : evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
     522                 :            :                               clause_t *clause_ptr,
     523                 :            :                               clause_t *nonspec_clause_ptr,
     524                 :            :                               vec<tree> *known_vals_ptr,
     525                 :            :                               vec<ipa_polymorphic_call_context>
     526                 :            :                               *known_contexts_ptr,
     527                 :            :                               vec<ipa_agg_value_set> *known_aggs_ptr)
     528                 :            : {
     529                 :   11132400 :   struct cgraph_node *callee = e->callee->ultimate_alias_target ();
     530                 :   11132400 :   class ipa_fn_summary *info = ipa_fn_summaries->get (callee);
     531                 :   11132400 :   auto_vec<value_range, 32> known_value_ranges;
     532                 :   11132400 :   class ipa_edge_args *args;
     533                 :            : 
     534                 :   11132400 :   if (clause_ptr)
     535                 :   11132400 :     *clause_ptr = inline_p ? 0 : 1 << predicate::not_inlined_condition;
     536                 :            : 
     537                 :   11132400 :   if (ipa_node_params_sum
     538                 :    3974420 :       && !e->call_stmt_cannot_inline_p
     539                 :    3974420 :       && (info->conds || known_contexts_ptr)
     540                 :   19081300 :       && (args = IPA_EDGE_REF (e)) != NULL)
     541                 :            :     {
     542                 :    3929350 :       struct cgraph_node *caller;
     543                 :    3929350 :       class ipa_node_params *caller_parms_info, *callee_pi = NULL;
     544                 :    3929350 :       class ipa_call_summary *es = ipa_call_summaries->get (e);
     545                 :    3929350 :       int i, count = ipa_get_cs_argument_count (args);
     546                 :            : 
     547                 :    3929350 :       if (count)
     548                 :            :         {
     549                 :    3584620 :           if (e->caller->inlined_to)
     550                 :            :             caller = e->caller->inlined_to;
     551                 :            :           else
     552                 :    3003280 :             caller = e->caller;
     553                 :    3584620 :           caller_parms_info = IPA_NODE_REF (caller);
     554                 :    3584620 :           callee_pi = IPA_NODE_REF (callee);
     555                 :            : 
     556                 :            :           /* Watch for thunks.  */
     557                 :    3584620 :           if (callee_pi)
     558                 :            :             /* Watch for variadic functions.  */
     559                 :    3584270 :             count = MIN (count, ipa_get_param_count (callee_pi));
     560                 :            :         }
     561                 :            : 
     562                 :    3929350 :       if (callee_pi)
     563                 :   10790600 :         for (i = 0; i < count; i++)
     564                 :            :           {
     565                 :    7206330 :             struct ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);
     566                 :            : 
     567                 :    7206330 :             if (ipa_is_param_used_by_indirect_call (callee_pi, i)
     568                 :    7206330 :                 || ipa_is_param_used_by_ipa_predicates (callee_pi, i))
     569                 :            :               {
     570                 :            :                 /* Determine if we know constant value of the parameter.  */
     571                 :    4584300 :                 tree cst = ipa_value_from_jfunc (caller_parms_info, jf,
     572                 :            :                                                  ipa_get_type (callee_pi, i));
     573                 :            : 
     574                 :    3748470 :                 if (!cst && e->call_stmt
     575                 :    8312890 :                     && i < (int)gimple_call_num_args (e->call_stmt))
     576                 :            :                   {
     577                 :    3728580 :                     cst = gimple_call_arg (e->call_stmt, i);
     578                 :    3728580 :                     if (!is_gimple_min_invariant (cst))
     579                 :            :                       cst = NULL;
     580                 :            :                   }
     581                 :     937675 :                 if (cst)
     582                 :            :                   {
     583                 :     917794 :                     gcc_checking_assert (TREE_CODE (cst) != TREE_BINFO);
     584                 :     917794 :                     if (!known_vals_ptr->length ())
     585                 :     585813 :                       vec_safe_grow_cleared (known_vals_ptr, count);
     586                 :     917794 :                     (*known_vals_ptr)[i] = cst;
     587                 :            :                   }
     588                 :    3666510 :                 else if (inline_p && !es->param[i].change_prob)
     589                 :            :                   {
     590                 :    1204690 :                     if (!known_vals_ptr->length ())
     591                 :    1067150 :                       vec_safe_grow_cleared (known_vals_ptr, count);
     592                 :    1204690 :                     (*known_vals_ptr)[i] = error_mark_node;
     593                 :            :                   }
     594                 :            : 
     595                 :            :                 /* If we failed to get simple constant, try value range.  */
     596                 :     917794 :                 if ((!cst || TREE_CODE (cst) != INTEGER_CST)
     597                 :    4994530 :                     && ipa_is_param_used_by_ipa_predicates (callee_pi, i))
     598                 :            :                   {
     599                 :    4063580 :                     value_range vr 
     600                 :            :                        = ipa_value_range_from_jfunc (caller_parms_info, e, jf,
     601                 :            :                                                      ipa_get_type (callee_pi,
     602                 :    4063580 :                                                                    i));
     603                 :    4063580 :                     if (!vr.undefined_p () && !vr.varying_p ())
     604                 :            :                       {
     605                 :          0 :                         if (!known_value_ranges.length ())
     606                 :          0 :                           known_value_ranges.safe_grow_cleared (count);
     607                 :          0 :                         known_value_ranges[i] = vr;
     608                 :            :                       }
     609                 :            :                   }
     610                 :            : 
     611                 :            :                 /* Determine known aggregate values.  */
     612                 :    4584300 :                 ipa_agg_value_set agg
     613                 :            :                     = ipa_agg_value_set_from_jfunc (caller_parms_info,
     614                 :    4584300 :                                                     caller, &jf->agg);
     615                 :    4584300 :                 if (agg.items.length ())
     616                 :            :                   {
     617                 :     210557 :                     if (!known_aggs_ptr->length ())
     618                 :     182308 :                       vec_safe_grow_cleared (known_aggs_ptr, count);
     619                 :     210557 :                     (*known_aggs_ptr)[i] = agg;
     620                 :            :                   }
     621                 :            :               }
     622                 :            : 
     623                 :            :             /* For calls used in polymorphic calls we further determine
     624                 :            :                polymorphic call context.  */
     625                 :    7206330 :             if (known_contexts_ptr
     626                 :    7206330 :                 && ipa_is_param_used_by_polymorphic_call (callee_pi, i))
     627                 :            :               {
     628                 :      45893 :                 ipa_polymorphic_call_context
     629                 :      45893 :                    ctx = ipa_context_from_jfunc (caller_parms_info, e, i, jf);
     630                 :      45893 :                 if (!ctx.useless_p ())
     631                 :            :                   {
     632                 :      45599 :                     if (!known_contexts_ptr->length ())
     633                 :      45474 :                       known_contexts_ptr->safe_grow_cleared (count);
     634                 :      45599 :                     (*known_contexts_ptr)[i]
     635                 :      91198 :                       = ipa_context_from_jfunc (caller_parms_info, e, i, jf);
     636                 :            :                   }
     637                 :            :                }
     638                 :            :           }
     639                 :            :         else
     640                 :     345080 :           gcc_assert (!count || callee->thunk.thunk_p);
     641                 :            :     }
     642                 :    7203080 :   else if (e->call_stmt && !e->call_stmt_cannot_inline_p && info->conds)
     643                 :            :     {
     644                 :    4415480 :       int i, count = (int)gimple_call_num_args (e->call_stmt);
     645                 :            : 
     646                 :   12167200 :       for (i = 0; i < count; i++)
     647                 :            :         {
     648                 :    7751680 :           tree cst = gimple_call_arg (e->call_stmt, i);
     649                 :    7751680 :           if (!is_gimple_min_invariant (cst))
     650                 :            :             cst = NULL;
     651                 :    2615120 :           if (cst)
     652                 :            :             {
     653                 :    2615120 :               if (!known_vals_ptr->length ())
     654                 :    1803580 :                 vec_safe_grow_cleared (known_vals_ptr, count);
     655                 :    2615120 :               (*known_vals_ptr)[i] = cst;
     656                 :            :             }
     657                 :            :         }
     658                 :            :     }
     659                 :            : 
     660                 :   11132400 :   evaluate_conditions_for_known_args (callee, inline_p,
     661                 :            :                                       *known_vals_ptr,
     662                 :            :                                       known_value_ranges,
     663                 :            :                                       *known_aggs_ptr,
     664                 :            :                                       clause_ptr,
     665                 :            :                                       nonspec_clause_ptr);
     666                 :   11132400 : }
     667                 :            : 
     668                 :            : 
     669                 :            : /* Allocate the function summary. */
     670                 :            : 
     671                 :            : static void
     672                 :     323552 : ipa_fn_summary_alloc (void)
     673                 :            : {
     674                 :     323552 :   gcc_checking_assert (!ipa_fn_summaries);
     675                 :     323552 :   ipa_size_summaries = new ipa_size_summary_t (symtab);
     676                 :     323552 :   ipa_fn_summaries = ipa_fn_summary_t::create_ggc (symtab);
     677                 :     323552 :   ipa_call_summaries = new ipa_call_summary_t (symtab);
     678                 :     323552 : }
     679                 :            : 
     680                 :   32490600 : ipa_call_summary::~ipa_call_summary ()
     681                 :            : {
     682                 :   16245300 :   if (predicate)
     683                 :    1651510 :     edge_predicate_pool.remove (predicate);
     684                 :            : 
     685                 :   16245300 :   param.release ();
     686                 :   16245300 : }
     687                 :            : 
     688                 :   12216300 : ipa_fn_summary::~ipa_fn_summary ()
     689                 :            : {
     690                 :    6108130 :   if (loop_iterations)
     691                 :      35507 :     edge_predicate_pool.remove (loop_iterations);
     692                 :    6108130 :   if (loop_stride)
     693                 :       4400 :     edge_predicate_pool.remove (loop_stride);
     694                 :    6108130 :   vec_free (conds);
     695                 :    6108130 :   vec_free (size_time_table);
     696                 :    6108130 :   vec_free (call_size_time_table);
     697                 :    6108130 : }
     698                 :            : 
     699                 :            : void
     700                 :    4620110 : ipa_fn_summary_t::remove_callees (cgraph_node *node)
     701                 :            : {
     702                 :    4620110 :   cgraph_edge *e;
     703                 :   18774900 :   for (e = node->callees; e; e = e->next_callee)
     704                 :   14154800 :     ipa_call_summaries->remove (e);
     705                 :    5026330 :   for (e = node->indirect_calls; e; e = e->next_callee)
     706                 :     406213 :     ipa_call_summaries->remove (e);
     707                 :    4620110 : }
     708                 :            : 
     709                 :            : /* Same as remap_predicate_after_duplication but handle hint predicate *P.
     710                 :            :    Additionally care about allocating new memory slot for updated predicate
     711                 :            :    and set it to NULL when it becomes true or false (and thus uninteresting).
     712                 :            :  */
     713                 :            : 
     714                 :            : static void
     715                 :      28978 : remap_hint_predicate_after_duplication (predicate **p,
     716                 :            :                                         clause_t possible_truths)
     717                 :            : {
     718                 :      28978 :   predicate new_predicate;
     719                 :            : 
     720                 :      28978 :   if (!*p)
     721                 :      26500 :     return;
     722                 :            : 
     723                 :       2478 :   new_predicate = (*p)->remap_after_duplication (possible_truths);
     724                 :            :   /* We do not want to free previous predicate; it is used by node origin.  */
     725                 :       2478 :   *p = NULL;
     726                 :       2478 :   set_hint_predicate (p, new_predicate);
     727                 :            : }
     728                 :            : 
     729                 :            : 
     730                 :            : /* Hook that is called by cgraph.c when a node is duplicated.  */
     731                 :            : void
     732                 :    1461260 : ipa_fn_summary_t::duplicate (cgraph_node *src,
     733                 :            :                              cgraph_node *dst,
     734                 :            :                              ipa_fn_summary *,
     735                 :            :                              ipa_fn_summary *info)
     736                 :            : {
     737                 :    2922530 :   new (info) ipa_fn_summary (*ipa_fn_summaries->get (src));
     738                 :            :   /* TODO: as an optimization, we may avoid copying conditions
     739                 :            :      that are known to be false or true.  */
     740                 :    1461260 :   info->conds = vec_safe_copy (info->conds);
     741                 :            : 
     742                 :            :   /* When there are any replacements in the function body, see if we can figure
     743                 :            :      out that something was optimized out.  */
     744                 :    1461260 :   if (ipa_node_params_sum && dst->clone.tree_map)
     745                 :            :     {
     746                 :      14489 :       vec<size_time_entry, va_gc> *entry = info->size_time_table;
     747                 :            :       /* Use SRC parm info since it may not be copied yet.  */
     748                 :      14489 :       class ipa_node_params *parms_info = IPA_NODE_REF (src);
     749                 :      14489 :       vec<tree> known_vals = vNULL;
     750                 :      14489 :       int count = ipa_get_param_count (parms_info);
     751                 :      14489 :       int i, j;
     752                 :      14489 :       clause_t possible_truths;
     753                 :      14489 :       predicate true_pred = true;
     754                 :      14489 :       size_time_entry *e;
     755                 :      14489 :       int optimized_out_size = 0;
     756                 :      14489 :       bool inlined_to_p = false;
     757                 :      14489 :       struct cgraph_edge *edge, *next;
     758                 :            : 
     759                 :      14489 :       info->size_time_table = 0;
     760                 :      14489 :       known_vals.safe_grow_cleared (count);
     761                 :      52112 :       for (i = 0; i < count; i++)
     762                 :            :         {
     763                 :            :           struct ipa_replace_map *r;
     764                 :            : 
     765                 :     116609 :           for (j = 0; vec_safe_iterate (dst->clone.tree_map, j, &r); j++)
     766                 :            :             {
     767                 :      68135 :               if (r->parm_num == i)
     768                 :            :                 {
     769                 :      26772 :                   known_vals[i] = r->new_tree;
     770                 :      26772 :                   break;
     771                 :            :                 }
     772                 :            :             }
     773                 :            :         }
     774                 :      14489 :       evaluate_conditions_for_known_args (dst, false,
     775                 :            :                                           known_vals,
     776                 :            :                                           vNULL,
     777                 :            :                                           vNULL,
     778                 :            :                                           &possible_truths,
     779                 :            :                                           /* We are going to specialize,
     780                 :            :                                              so ignore nonspec truths.  */
     781                 :            :                                           NULL);
     782                 :      14489 :       known_vals.release ();
     783                 :            : 
     784                 :      14489 :       info->account_size_time (0, 0, true_pred, true_pred);
     785                 :            : 
     786                 :            :       /* Remap size_time vectors.
     787                 :            :          Simplify the predicate by pruning out alternatives that are known
     788                 :            :          to be false.
     789                 :            :          TODO: as on optimization, we can also eliminate conditions known
     790                 :            :          to be true.  */
     791                 :      83311 :       for (i = 0; vec_safe_iterate (entry, i, &e); i++)
     792                 :            :         {
     793                 :      68822 :           predicate new_exec_pred;
     794                 :      68822 :           predicate new_nonconst_pred;
     795                 :      68822 :           new_exec_pred = e->exec_predicate.remap_after_duplication
     796                 :      68822 :                                  (possible_truths);
     797                 :      68822 :           new_nonconst_pred = e->nonconst_predicate.remap_after_duplication
     798                 :      68822 :                                  (possible_truths);
     799                 :      68822 :           if (new_exec_pred == false || new_nonconst_pred == false)
     800                 :      19136 :             optimized_out_size += e->size;
     801                 :            :           else
     802                 :      49686 :             info->account_size_time (e->size, e->time, new_exec_pred,
     803                 :            :                                      new_nonconst_pred);
     804                 :            :         }
     805                 :            : 
     806                 :            :       /* Remap edge predicates with the same simplification as above.
     807                 :            :          Also copy constantness arrays.   */
     808                 :      60420 :       for (edge = dst->callees; edge; edge = next)
     809                 :            :         {
     810                 :      45931 :           predicate new_predicate;
     811                 :      45931 :           class ipa_call_summary *es = ipa_call_summaries->get (edge);
     812                 :      45931 :           next = edge->next_callee;
     813                 :            : 
     814                 :      45931 :           if (!edge->inline_failed)
     815                 :          0 :             inlined_to_p = true;
     816                 :      45931 :           if (!es->predicate)
     817                 :      21032 :             continue;
     818                 :      24899 :           new_predicate = es->predicate->remap_after_duplication
     819                 :      24899 :             (possible_truths);
     820                 :      25848 :           if (new_predicate == false && *es->predicate != false)
     821                 :        949 :             optimized_out_size += es->call_stmt_size * ipa_fn_summary::size_scale;
     822                 :      24899 :           edge_set_predicate (edge, &new_predicate);
     823                 :            :         }
     824                 :            : 
     825                 :            :       /* Remap indirect edge predicates with the same simplification as above.
     826                 :            :          Also copy constantness arrays.   */
     827                 :      14926 :       for (edge = dst->indirect_calls; edge; edge = next)
     828                 :            :         {
     829                 :        437 :           predicate new_predicate;
     830                 :        437 :           class ipa_call_summary *es = ipa_call_summaries->get (edge);
     831                 :        437 :           next = edge->next_callee;
     832                 :            : 
     833                 :        437 :           gcc_checking_assert (edge->inline_failed);
     834                 :        437 :           if (!es->predicate)
     835                 :        363 :             continue;
     836                 :         74 :           new_predicate = es->predicate->remap_after_duplication
     837                 :         74 :                                  (possible_truths);
     838                 :         78 :           if (new_predicate == false && *es->predicate != false)
     839                 :          3 :             optimized_out_size += es->call_stmt_size * ipa_fn_summary::size_scale;
     840                 :         74 :           edge_set_predicate (edge, &new_predicate);
     841                 :            :         }
     842                 :      14489 :       remap_hint_predicate_after_duplication (&info->loop_iterations,
     843                 :            :                                               possible_truths);
     844                 :      14489 :       remap_hint_predicate_after_duplication (&info->loop_stride,
     845                 :            :                                               possible_truths);
     846                 :            : 
     847                 :            :       /* If inliner or someone after inliner will ever start producing
     848                 :            :          non-trivial clones, we will get trouble with lack of information
     849                 :            :          about updating self sizes, because size vectors already contains
     850                 :            :          sizes of the callees.  */
     851                 :      14489 :       gcc_assert (!inlined_to_p || !optimized_out_size);
     852                 :            :     }
     853                 :            :   else
     854                 :            :     {
     855                 :    1446780 :       info->size_time_table = vec_safe_copy (info->size_time_table);
     856                 :    1446780 :       if (info->loop_iterations)
     857                 :            :         {
     858                 :       8019 :           predicate p = *info->loop_iterations;
     859                 :       8019 :           info->loop_iterations = NULL;
     860                 :       8019 :           set_hint_predicate (&info->loop_iterations, p);
     861                 :            :         }
     862                 :    1446780 :       if (info->loop_stride)
     863                 :            :         {
     864                 :        572 :           predicate p = *info->loop_stride;
     865                 :        572 :           info->loop_stride = NULL;
     866                 :        572 :           set_hint_predicate (&info->loop_stride, p);
     867                 :            :         }
     868                 :            :     }
     869                 :    1461260 :   if (!dst->inlined_to)
     870                 :      74074 :     ipa_update_overall_fn_summary (dst);
     871                 :    1461260 : }
     872                 :            : 
     873                 :            : 
     874                 :            : /* Hook that is called by cgraph.c when a node is duplicated.  */
     875                 :            : 
     876                 :            : void
     877                 :    1594740 : ipa_call_summary_t::duplicate (struct cgraph_edge *src,
     878                 :            :                                struct cgraph_edge *dst,
     879                 :            :                                class ipa_call_summary *srcinfo,
     880                 :            :                                class ipa_call_summary *info)
     881                 :            : {
     882                 :    1594740 :   new (info) ipa_call_summary (*srcinfo);
     883                 :    1594740 :   info->predicate = NULL;
     884                 :    1594740 :   edge_set_predicate (dst, srcinfo->predicate);
     885                 :    1594740 :   info->param = srcinfo->param.copy ();
     886                 :    1594740 :   if (!dst->indirect_unknown_callee && src->indirect_unknown_callee)
     887                 :            :     {
     888                 :      22110 :       info->call_stmt_size -= (eni_size_weights.indirect_call_cost
     889                 :      22110 :                                - eni_size_weights.call_cost);
     890                 :      22110 :       info->call_stmt_time -= (eni_time_weights.indirect_call_cost
     891                 :      22110 :                                - eni_time_weights.call_cost);
     892                 :            :     }
     893                 :    1594740 : }
     894                 :            : 
     895                 :            : /* Dump edge summaries associated to NODE and recursively to all clones.
     896                 :            :    Indent by INDENT.  */
     897                 :            : 
     898                 :            : static void
     899                 :       2270 : dump_ipa_call_summary (FILE *f, int indent, struct cgraph_node *node,
     900                 :            :                        class ipa_fn_summary *info)
     901                 :            : {
     902                 :       2270 :   struct cgraph_edge *edge;
     903                 :      10230 :   for (edge = node->callees; edge; edge = edge->next_callee)
     904                 :            :     {
     905                 :       7960 :       class ipa_call_summary *es = ipa_call_summaries->get (edge);
     906                 :       7960 :       struct cgraph_node *callee = edge->callee->ultimate_alias_target ();
     907                 :       7960 :       int i;
     908                 :            : 
     909                 :      15920 :       fprintf (f,
     910                 :            :                "%*s%s %s\n%*s  freq:%4.2f",
     911                 :            :                indent, "", callee->dump_name (),
     912                 :       7960 :                !edge->inline_failed
     913                 :       7335 :                ? "inlined" : cgraph_inline_failed_string (edge-> inline_failed),
     914                 :       7960 :                indent, "", edge->sreal_frequency ().to_double ());
     915                 :            : 
     916                 :       7960 :       if (cross_module_call_p (edge))
     917                 :          2 :         fprintf (f, " cross module");
     918                 :            : 
     919                 :       7960 :       if (es)
     920                 :       7335 :         fprintf (f, " loop depth:%2i size:%2i time: %2i",
     921                 :            :                  es->loop_depth, es->call_stmt_size, es->call_stmt_time);
     922                 :            : 
     923                 :       7960 :       ipa_fn_summary *s = ipa_fn_summaries->get (callee);
     924                 :       7960 :       ipa_size_summary *ss = ipa_size_summaries->get (callee);
     925                 :       7960 :       if (s != NULL)
     926                 :        686 :         fprintf (f, " callee size:%2i stack:%2i",
     927                 :        686 :                  (int) (ss->size / ipa_fn_summary::size_scale),
     928                 :        686 :                  (int) s->estimated_stack_size);
     929                 :            : 
     930                 :       7960 :       if (es && es->predicate)
     931                 :            :         {
     932                 :       4568 :           fprintf (f, " predicate: ");
     933                 :       4568 :           es->predicate->dump (f, info->conds);
     934                 :            :         }
     935                 :            :       else
     936                 :       3392 :         fprintf (f, "\n");
     937                 :       7960 :       if (es && es->param.exists ())
     938                 :       5448 :         for (i = 0; i < (int) es->param.length (); i++)
     939                 :            :           {
     940                 :       1598 :             int prob = es->param[i].change_prob;
     941                 :            : 
     942                 :       1598 :             if (!prob)
     943                 :        602 :               fprintf (f, "%*s op%i is compile time invariant\n",
     944                 :            :                        indent + 2, "", i);
     945                 :        996 :             else if (prob != REG_BR_PROB_BASE)
     946                 :         40 :               fprintf (f, "%*s op%i change %f%% of time\n", indent + 2, "", i,
     947                 :         40 :                        prob * 100.0 / REG_BR_PROB_BASE);
     948                 :            :           }
     949                 :       7960 :       if (!edge->inline_failed)
     950                 :            :         {
     951                 :        625 :           ipa_size_summary *ss = ipa_size_summaries->get (callee);
     952                 :        625 :           fprintf (f, "%*sStack frame offset %i, callee self size %i\n",
     953                 :            :                    indent + 2, "",
     954                 :        625 :                    (int) ipa_get_stack_frame_offset (callee),
     955                 :        625 :                    (int) ss->estimated_self_stack_size);
     956                 :        625 :           dump_ipa_call_summary (f, indent + 2, callee, info);
     957                 :            :         }
     958                 :            :     }
     959                 :       2625 :   for (edge = node->indirect_calls; edge; edge = edge->next_callee)
     960                 :            :     {
     961                 :        355 :       class ipa_call_summary *es = ipa_call_summaries->get (edge);
     962                 :        355 :       fprintf (f, "%*sindirect call loop depth:%2i freq:%4.2f size:%2i"
     963                 :            :                " time: %2i",
     964                 :            :                indent, "",
     965                 :            :                es->loop_depth,
     966                 :        355 :                edge->sreal_frequency ().to_double (), es->call_stmt_size,
     967                 :            :                es->call_stmt_time);
     968                 :        355 :       if (es->predicate)
     969                 :            :         {
     970                 :          8 :           fprintf (f, "predicate: ");
     971                 :          8 :           es->predicate->dump (f, info->conds);
     972                 :            :         }
     973                 :            :       else
     974                 :        347 :         fprintf (f, "\n");
     975                 :            :     }
     976                 :       2270 : }
     977                 :            : 
     978                 :            : 
     979                 :            : void
     980                 :       1935 : ipa_dump_fn_summary (FILE *f, struct cgraph_node *node)
     981                 :            : {
     982                 :       1935 :   if (node->definition)
     983                 :            :     {
     984                 :       1935 :       class ipa_fn_summary *s = ipa_fn_summaries->get (node);
     985                 :       1935 :       class ipa_size_summary *ss = ipa_size_summaries->get (node);
     986                 :       1935 :       if (s != NULL)
     987                 :            :         {
     988                 :       1645 :           size_time_entry *e;
     989                 :       1645 :           int i;
     990                 :       1645 :           fprintf (f, "IPA function summary for %s", node->dump_name ());
     991                 :       1645 :           if (DECL_DISREGARD_INLINE_LIMITS (node->decl))
     992                 :          0 :             fprintf (f, " always_inline");
     993                 :       1645 :           if (s->inlinable)
     994                 :       1462 :             fprintf (f, " inlinable");
     995                 :       1645 :           if (s->fp_expressions)
     996                 :         45 :             fprintf (f, " fp_expression");
     997                 :       1645 :           fprintf (f, "\n  global time:     %f\n", s->time.to_double ());
     998                 :       1645 :           fprintf (f, "  self size:       %i\n", ss->self_size);
     999                 :       1645 :           fprintf (f, "  global size:     %i\n", ss->size);
    1000                 :       1645 :           fprintf (f, "  min size:       %i\n", s->min_size);
    1001                 :       1645 :           fprintf (f, "  self stack:      %i\n",
    1002                 :       1645 :                    (int) ss->estimated_self_stack_size);
    1003                 :       1645 :           fprintf (f, "  global stack:    %i\n", (int) s->estimated_stack_size);
    1004                 :       1645 :           if (s->growth)
    1005                 :        119 :             fprintf (f, "  estimated growth:%i\n", (int) s->growth);
    1006                 :       1645 :           if (s->scc_no)
    1007                 :          6 :             fprintf (f, "  In SCC:          %i\n", (int) s->scc_no);
    1008                 :       6237 :           for (i = 0; vec_safe_iterate (s->size_time_table, i, &e); i++)
    1009                 :            :             {
    1010                 :       4592 :               fprintf (f, "    size:%f, time:%f",
    1011                 :       4592 :                        (double) e->size / ipa_fn_summary::size_scale,
    1012                 :            :                        e->time.to_double ());
    1013                 :       4592 :               if (e->exec_predicate != true)
    1014                 :            :                 {
    1015                 :       2206 :                   fprintf (f, ",  executed if:");
    1016                 :       2206 :                   e->exec_predicate.dump (f, s->conds, 0);
    1017                 :            :                 }
    1018                 :       4592 :               if (e->exec_predicate != e->nonconst_predicate)
    1019                 :            :                 {
    1020                 :       1157 :                   fprintf (f, ",  nonconst if:");
    1021                 :       1157 :                   e->nonconst_predicate.dump (f, s->conds, 0);
    1022                 :            :                 }
    1023                 :       4592 :               fprintf (f, "\n");
    1024                 :            :             }
    1025                 :       1645 :           if (s->loop_iterations)
    1026                 :            :             {
    1027                 :         76 :               fprintf (f, "  loop iterations:");
    1028                 :         76 :               s->loop_iterations->dump (f, s->conds);
    1029                 :            :             }
    1030                 :       1645 :           if (s->loop_stride)
    1031                 :            :             {
    1032                 :         10 :               fprintf (f, "  loop stride:");
    1033                 :         10 :               s->loop_stride->dump (f, s->conds);
    1034                 :            :             }
    1035                 :       1645 :           fprintf (f, "  calls:\n");
    1036                 :       1645 :           dump_ipa_call_summary (f, 4, node, s);
    1037                 :       1645 :           fprintf (f, "\n");
    1038                 :            :         }
    1039                 :            :       else
    1040                 :        290 :         fprintf (f, "IPA summary for %s is missing.\n", node->dump_name ());
    1041                 :            :     }
    1042                 :       1935 : }
    1043                 :            : 
    1044                 :            : DEBUG_FUNCTION void
    1045                 :          0 : ipa_debug_fn_summary (struct cgraph_node *node)
    1046                 :            : {
    1047                 :          0 :   ipa_dump_fn_summary (stderr, node);
    1048                 :          0 : }
    1049                 :            : 
    1050                 :            : void
    1051                 :        384 : ipa_dump_fn_summaries (FILE *f)
    1052                 :            : {
    1053                 :        384 :   struct cgraph_node *node;
    1054                 :            : 
    1055                 :       5418 :   FOR_EACH_DEFINED_FUNCTION (node)
    1056                 :       2325 :     if (!node->inlined_to)
    1057                 :       1700 :       ipa_dump_fn_summary (f, node);
    1058                 :        384 : }
    1059                 :            : 
    1060                 :            : /* Callback of walk_aliased_vdefs.  Flags that it has been invoked to the
    1061                 :            :    boolean variable pointed to by DATA.  */
    1062                 :            : 
    1063                 :            : static bool
    1064                 :     473295 : mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
    1065                 :            :                void *data)
    1066                 :            : {
    1067                 :     473295 :   bool *b = (bool *) data;
    1068                 :     473295 :   *b = true;
    1069                 :     473295 :   return true;
    1070                 :            : }
    1071                 :            : 
    1072                 :            : /* If OP refers to value of function parameter, return the corresponding
    1073                 :            :    parameter.  If non-NULL, the size of the memory load (or the SSA_NAME of the
    1074                 :            :    PARM_DECL) will be stored to *SIZE_P in that case too.  */
    1075                 :            : 
    1076                 :            : static tree
    1077                 :  123446000 : unmodified_parm_1 (ipa_func_body_info *fbi, gimple *stmt, tree op,
    1078                 :            :                    poly_int64 *size_p)
    1079                 :            : {
    1080                 :            :   /* SSA_NAME referring to parm default def?  */
    1081                 :  123446000 :   if (TREE_CODE (op) == SSA_NAME
    1082                 :   71698000 :       && SSA_NAME_IS_DEFAULT_DEF (op)
    1083                 :  155164000 :       && TREE_CODE (SSA_NAME_VAR (op)) == PARM_DECL)
    1084                 :            :     {
    1085                 :   15741100 :       if (size_p)
    1086                 :          0 :         *size_p = tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (op)));
    1087                 :   15741100 :       return SSA_NAME_VAR (op);
    1088                 :            :     }
    1089                 :            :   /* Non-SSA parm reference?  */
    1090                 :  107705000 :   if (TREE_CODE (op) == PARM_DECL)
    1091                 :            :     {
    1092                 :     866192 :       bool modified = false;
    1093                 :            : 
    1094                 :     866192 :       ao_ref refd;
    1095                 :     866192 :       ao_ref_init (&refd, op);
    1096                 :     866192 :       int walked = walk_aliased_vdefs (&refd, gimple_vuse (stmt),
    1097                 :            :                                        mark_modified, &modified, NULL, NULL,
    1098                 :     866192 :                                        fbi->aa_walk_budget + 1);
    1099                 :     866192 :       if (walked < 0)
    1100                 :            :         {
    1101                 :        130 :           fbi->aa_walk_budget = 0;
    1102                 :     554069 :           return NULL_TREE;
    1103                 :            :         }
    1104                 :     866062 :       if (!modified)
    1105                 :            :         {
    1106                 :     553939 :           if (size_p)
    1107                 :          0 :             *size_p = tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (op)));
    1108                 :     553939 :           return op;
    1109                 :            :         }
    1110                 :            :     }
    1111                 :            :   return NULL_TREE;
    1112                 :            : }
    1113                 :            : 
    1114                 :            : /* If OP refers to value of function parameter, return the corresponding
    1115                 :            :    parameter.  Also traverse chains of SSA register assignments.  If non-NULL,
    1116                 :            :    the size of the memory load (or the SSA_NAME of the PARM_DECL) will be
    1117                 :            :    stored to *SIZE_P in that case too.  */
    1118                 :            : 
    1119                 :            : static tree
    1120                 :   80208100 : unmodified_parm (ipa_func_body_info *fbi, gimple *stmt, tree op,
    1121                 :            :                  poly_int64 *size_p)
    1122                 :            : {
    1123                 :  100729000 :   tree res = unmodified_parm_1 (fbi, stmt, op, size_p);
    1124                 :  100729000 :   if (res)
    1125                 :            :     return res;
    1126                 :            : 
    1127                 :   84956200 :   if (TREE_CODE (op) == SSA_NAME
    1128                 :   48232200 :       && !SSA_NAME_IS_DEFAULT_DEF (op)
    1129                 :  133074000 :       && gimple_assign_single_p (SSA_NAME_DEF_STMT (op)))
    1130                 :   20521200 :     return unmodified_parm (fbi, SSA_NAME_DEF_STMT (op),
    1131                 :   20521200 :                             gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op)),
    1132                 :   20521200 :                             size_p);
    1133                 :            :   return NULL_TREE;
    1134                 :            : }
    1135                 :            : 
    1136                 :            : /* If OP refers to a value of a function parameter or value loaded from an
    1137                 :            :    aggregate passed to a parameter (either by value or reference), return TRUE
    1138                 :            :    and store the number of the parameter to *INDEX_P, the access size into
    1139                 :            :    *SIZE_P, and information whether and how it has been loaded from an
    1140                 :            :    aggregate into *AGGPOS.  INFO describes the function parameters, STMT is the
    1141                 :            :    statement in which OP is used or loaded.  */
    1142                 :            : 
    1143                 :            : static bool
    1144                 :   21603300 : unmodified_parm_or_parm_agg_item (struct ipa_func_body_info *fbi,
    1145                 :            :                                   gimple *stmt, tree op, int *index_p,
    1146                 :            :                                   poly_int64 *size_p,
    1147                 :            :                                   struct agg_position_info *aggpos)
    1148                 :            : {
    1149                 :   22716900 :   tree res = unmodified_parm_1 (fbi, stmt, op, size_p);
    1150                 :            : 
    1151                 :   22716900 :   gcc_checking_assert (aggpos);
    1152                 :   22716900 :   if (res)
    1153                 :            :     {
    1154                 :     521880 :       *index_p = ipa_get_param_decl_index (fbi->info, res);
    1155                 :     521880 :       if (*index_p < 0)
    1156                 :            :         return false;
    1157                 :     521825 :       aggpos->agg_contents = false;
    1158                 :     521825 :       aggpos->by_ref = false;
    1159                 :     521825 :       return true;
    1160                 :            :     }
    1161                 :            : 
    1162                 :   22195000 :   if (TREE_CODE (op) == SSA_NAME)
    1163                 :            :     {
    1164                 :    7724770 :       if (SSA_NAME_IS_DEFAULT_DEF (op)
    1165                 :    7724770 :           || !gimple_assign_single_p (SSA_NAME_DEF_STMT (op)))
    1166                 :            :         return false;
    1167                 :    3460770 :       stmt = SSA_NAME_DEF_STMT (op);
    1168                 :    3460770 :       op = gimple_assign_rhs1 (stmt);
    1169                 :    3460770 :       if (!REFERENCE_CLASS_P (op))
    1170                 :            :         return unmodified_parm_or_parm_agg_item (fbi, stmt, op, index_p, size_p,
    1171                 :            :                                                  aggpos);
    1172                 :            :     }
    1173                 :            : 
    1174                 :   16817400 :   aggpos->agg_contents = true;
    1175                 :   16817400 :   return ipa_load_from_parm_agg (fbi, fbi->info->descriptors,
    1176                 :            :                                  stmt, op, index_p, &aggpos->offset,
    1177                 :   16817400 :                                  size_p, &aggpos->by_ref);
    1178                 :            : }
    1179                 :            : 
    1180                 :            : /* See if statement might disappear after inlining.
    1181                 :            :    0 - means not eliminated
    1182                 :            :    1 - half of statements goes away
    1183                 :            :    2 - for sure it is eliminated.
    1184                 :            :    We are not terribly sophisticated, basically looking for simple abstraction
    1185                 :            :    penalty wrappers.  */
    1186                 :            : 
    1187                 :            : static int
    1188                 :   72924700 : eliminated_by_inlining_prob (ipa_func_body_info *fbi, gimple *stmt)
    1189                 :            : {
    1190                 :   72924700 :   enum gimple_code code = gimple_code (stmt);
    1191                 :   72924700 :   enum tree_code rhs_code;
    1192                 :            : 
    1193                 :   72924700 :   if (!optimize)
    1194                 :            :     return 0;
    1195                 :            : 
    1196                 :   62301700 :   switch (code)
    1197                 :            :     {
    1198                 :            :     case GIMPLE_RETURN:
    1199                 :            :       return 2;
    1200                 :   37384100 :     case GIMPLE_ASSIGN:
    1201                 :   37384100 :       if (gimple_num_ops (stmt) != 2)
    1202                 :            :         return 0;
    1203                 :            : 
    1204                 :   27332700 :       rhs_code = gimple_assign_rhs_code (stmt);
    1205                 :            : 
    1206                 :            :       /* Casts of parameters, loads from parameters passed by reference
    1207                 :            :          and stores to return value or parameters are often free after
    1208                 :            :          inlining due to SRA and further combining.
    1209                 :            :          Assume that half of statements goes away.  */
    1210                 :   27332700 :       if (CONVERT_EXPR_CODE_P (rhs_code)
    1211                 :   27332700 :           || rhs_code == VIEW_CONVERT_EXPR
    1212                 :   27332700 :           || rhs_code == ADDR_EXPR
    1213                 :   52603700 :           || gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
    1214                 :            :         {
    1215                 :   26784700 :           tree rhs = gimple_assign_rhs1 (stmt);
    1216                 :   26784700 :           tree lhs = gimple_assign_lhs (stmt);
    1217                 :   26784700 :           tree inner_rhs = get_base_address (rhs);
    1218                 :   26784700 :           tree inner_lhs = get_base_address (lhs);
    1219                 :   26784700 :           bool rhs_free = false;
    1220                 :   26784700 :           bool lhs_free = false;
    1221                 :            : 
    1222                 :   26784700 :           if (!inner_rhs)
    1223                 :          0 :             inner_rhs = rhs;
    1224                 :   26784700 :           if (!inner_lhs)
    1225                 :          0 :             inner_lhs = lhs;
    1226                 :            : 
    1227                 :            :           /* Reads of parameter are expected to be free.  */
    1228                 :   26784700 :           if (unmodified_parm (fbi, stmt, inner_rhs, NULL))
    1229                 :            :             rhs_free = true;
    1230                 :            :           /* Match expressions of form &this->field. Those will most likely
    1231                 :            :              combine with something upstream after inlining.  */
    1232                 :   26022100 :           else if (TREE_CODE (inner_rhs) == ADDR_EXPR)
    1233                 :            :             {
    1234                 :    1827950 :               tree op = get_base_address (TREE_OPERAND (inner_rhs, 0));
    1235                 :    1827950 :               if (TREE_CODE (op) == PARM_DECL)
    1236                 :            :                 rhs_free = true;
    1237                 :    1810760 :               else if (TREE_CODE (op) == MEM_REF
    1238                 :    1810760 :                        && unmodified_parm (fbi, stmt, TREE_OPERAND (op, 0),
    1239                 :            :                                            NULL))
    1240                 :            :                 rhs_free = true;
    1241                 :            :             }
    1242                 :            : 
    1243                 :            :           /* When parameter is not SSA register because its address is taken
    1244                 :            :              and it is just copied into one, the statement will be completely
    1245                 :            :              free after inlining (we will copy propagate backward).   */
    1246                 :     779829 :           if (rhs_free && is_gimple_reg (lhs))
    1247                 :            :             return 2;
    1248                 :            : 
    1249                 :            :           /* Reads of parameters passed by reference
    1250                 :            :              expected to be free (i.e. optimized out after inlining).  */
    1251                 :   26382000 :           if (TREE_CODE (inner_rhs) == MEM_REF
    1252                 :   26382000 :               && unmodified_parm (fbi, stmt, TREE_OPERAND (inner_rhs, 0), NULL))
    1253                 :            :             rhs_free = true;
    1254                 :            : 
    1255                 :            :           /* Copying parameter passed by reference into gimple register is
    1256                 :            :              probably also going to copy propagate, but we can't be quite
    1257                 :            :              sure.  */
    1258                 :   26382000 :           if (rhs_free && is_gimple_reg (lhs))
    1259                 :            :             lhs_free = true;
    1260                 :            : 
    1261                 :            :           /* Writes to parameters, parameters passed by value and return value
    1262                 :            :              (either directly or passed via invisible reference) are free.  
    1263                 :            : 
    1264                 :            :              TODO: We ought to handle testcase like
    1265                 :            :              struct a {int a,b;};
    1266                 :            :              struct a
    1267                 :            :              returnstruct (void)
    1268                 :            :              {
    1269                 :            :              struct a a ={1,2};
    1270                 :            :              return a;
    1271                 :            :              }
    1272                 :            : 
    1273                 :            :              This translate into:
    1274                 :            : 
    1275                 :            :              returnstruct ()
    1276                 :            :              {
    1277                 :            :              int a$b;
    1278                 :            :              int a$a;
    1279                 :            :              struct a a;
    1280                 :            :              struct a D.2739;
    1281                 :            : 
    1282                 :            :              <bb 2>:
    1283                 :            :              D.2739.a = 1;
    1284                 :            :              D.2739.b = 2;
    1285                 :            :              return D.2739;
    1286                 :            : 
    1287                 :            :              }
    1288                 :            :              For that we either need to copy ipa-split logic detecting writes
    1289                 :            :              to return value.  */
    1290                 :   26382000 :           if (TREE_CODE (inner_lhs) == PARM_DECL
    1291                 :   26382000 :               || TREE_CODE (inner_lhs) == RESULT_DECL
    1292                 :   26382000 :               || (TREE_CODE (inner_lhs) == MEM_REF
    1293                 :    3318400 :                   && (unmodified_parm (fbi, stmt, TREE_OPERAND (inner_lhs, 0),
    1294                 :            :                                        NULL)
    1295                 :    1748200 :                       || (TREE_CODE (TREE_OPERAND (inner_lhs, 0)) == SSA_NAME
    1296                 :    1747100 :                           && SSA_NAME_VAR (TREE_OPERAND (inner_lhs, 0))
    1297                 :     216594 :                           && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND
    1298                 :            :                                                       (inner_lhs,
    1299                 :            :                                                        0))) == RESULT_DECL))))
    1300                 :            :             lhs_free = true;
    1301                 :   24030300 :           if (lhs_free
    1302                 :   26382000 :               && (is_gimple_reg (rhs) || is_gimple_min_invariant (rhs)))
    1303                 :            :             rhs_free = true;
    1304                 :   26382000 :           if (lhs_free && rhs_free)
    1305                 :    5197100 :             return 1;
    1306                 :            :         }
    1307                 :            :       return 0;
    1308                 :   20887100 :     default:
    1309                 :   20887100 :       return 0;
    1310                 :            :     }
    1311                 :            : }
    1312                 :            : 
    1313                 :            : /* Analyze EXPR if it represents a series of simple operations performed on
    1314                 :            :    a function parameter and return true if so.  FBI, STMT, EXPR, INDEX_P and
    1315                 :            :    AGGPOS have the same meaning like in unmodified_parm_or_parm_agg_item.
    1316                 :            :    Type of the parameter or load from an aggregate via the parameter is
    1317                 :            :    stored in *TYPE_P.  Operations on the parameter are recorded to
    1318                 :            :    PARAM_OPS_P if it is not NULL.  */
    1319                 :            : 
    1320                 :            : static bool
    1321                 :   17772500 : decompose_param_expr (struct ipa_func_body_info *fbi,
    1322                 :            :                       gimple *stmt, tree expr,
    1323                 :            :                       int *index_p, tree *type_p,
    1324                 :            :                       struct agg_position_info *aggpos,
    1325                 :            :                       expr_eval_ops *param_ops_p = NULL)
    1326                 :            : {
    1327                 :   17772500 :   int op_limit = opt_for_fn (fbi->node->decl, param_ipa_max_param_expr_ops);
    1328                 :   17772500 :   int op_count = 0;
    1329                 :            : 
    1330                 :   17772500 :   if (param_ops_p)
    1331                 :    6023970 :     *param_ops_p = NULL;
    1332                 :            : 
    1333                 :   21603300 :   while (true)
    1334                 :            :     {
    1335                 :   21603300 :       expr_eval_op eval_op;
    1336                 :   21603300 :       unsigned rhs_count;
    1337                 :   21603300 :       unsigned cst_count = 0;
    1338                 :            : 
    1339                 :   21603300 :       if (unmodified_parm_or_parm_agg_item (fbi, stmt, expr, index_p, NULL,
    1340                 :            :                                             aggpos))
    1341                 :            :         {
    1342                 :    2712270 :           tree type = TREE_TYPE (expr);
    1343                 :            : 
    1344                 :    2712270 :           if (aggpos->agg_contents)
    1345                 :            :             {
    1346                 :            :               /* Stop if containing bit-field.  */
    1347                 :    2190440 :               if (TREE_CODE (expr) == BIT_FIELD_REF
    1348                 :    2190440 :                   || contains_bitfld_component_ref_p (expr))
    1349                 :            :                 break;
    1350                 :            :             }
    1351                 :            : 
    1352                 :    2708310 :           *type_p = type;
    1353                 :    2708310 :           return true;
    1354                 :            :         }
    1355                 :            : 
    1356                 :   18891000 :       if (TREE_CODE (expr) != SSA_NAME || SSA_NAME_IS_DEFAULT_DEF (expr))
    1357                 :            :         break;
    1358                 :            : 
    1359                 :    6792800 :       if (!is_gimple_assign (stmt = SSA_NAME_DEF_STMT (expr)))
    1360                 :            :         break;
    1361                 :            : 
    1362                 :    4355900 :       switch (gimple_assign_rhs_class (stmt))
    1363                 :            :         {
    1364                 :    2816870 :         case GIMPLE_SINGLE_RHS:
    1365                 :    2816870 :           expr = gimple_assign_rhs1 (stmt);
    1366                 :    2816870 :           continue;
    1367                 :            : 
    1368                 :            :         case GIMPLE_UNARY_RHS:
    1369                 :            :           rhs_count = 1;
    1370                 :            :           break;
    1371                 :            : 
    1372                 :     932919 :         case GIMPLE_BINARY_RHS:
    1373                 :     932919 :           rhs_count = 2;
    1374                 :     932919 :           break;
    1375                 :            : 
    1376                 :        180 :         case GIMPLE_TERNARY_RHS:
    1377                 :        180 :           rhs_count = 3;
    1378                 :        180 :           break;
    1379                 :            : 
    1380                 :          0 :         default:
    1381                 :     525126 :           goto fail;
    1382                 :            :         }
    1383                 :            : 
    1384                 :            :       /* Stop if expression is too complex.  */
    1385                 :    1539030 :       if (op_count++ == op_limit)
    1386                 :            :         break;
    1387                 :            : 
    1388                 :    1539000 :       if (param_ops_p)
    1389                 :            :         {
    1390                 :    1538260 :           eval_op.code = gimple_assign_rhs_code (stmt);
    1391                 :    1538260 :           eval_op.type = TREE_TYPE (gimple_assign_lhs (stmt));
    1392                 :    1538260 :           eval_op.val[0] = NULL_TREE;
    1393                 :    1538260 :           eval_op.val[1] = NULL_TREE;
    1394                 :            :         }
    1395                 :            : 
    1396                 :            :       expr = NULL_TREE;
    1397                 :    3486070 :       for (unsigned i = 0; i < rhs_count; i++)
    1398                 :            :         {
    1399                 :    2472200 :           tree op = gimple_op (stmt, i + 1);
    1400                 :            : 
    1401                 :    2472200 :           gcc_assert (op && !TYPE_P (op));
    1402                 :    2472200 :           if (is_gimple_ip_invariant (op))
    1403                 :            :             {
    1404                 :     409893 :               if (++cst_count == rhs_count)
    1405                 :        910 :                 goto fail;
    1406                 :            : 
    1407                 :     408983 :               eval_op.val[cst_count - 1] = op;
    1408                 :            :             }
    1409                 :    2062300 :           else if (!expr)
    1410                 :            :             {
    1411                 :            :               /* Found a non-constant operand, and record its index in rhs
    1412                 :            :                  operands.  */
    1413                 :    1538090 :               eval_op.index = i;
    1414                 :    1538090 :               expr = op;
    1415                 :            :             }
    1416                 :            :           else
    1417                 :            :             {
    1418                 :            :               /* Found more than one non-constant operands.  */
    1419                 :     524216 :               goto fail;
    1420                 :            :             }
    1421                 :            :         }
    1422                 :            : 
    1423                 :    1013870 :       if (param_ops_p)
    1424                 :    1013310 :         vec_safe_insert (*param_ops_p, 0, eval_op);
    1425                 :            :     }
    1426                 :            : 
    1427                 :            :   /* Failed to decompose, free resource and return.  */
    1428                 :   15064200 : fail:
    1429                 :   15064200 :   if (param_ops_p)
    1430                 :    5234450 :     vec_free (*param_ops_p);
    1431                 :            : 
    1432                 :            :   return false;
    1433                 :            : }
    1434                 :            : 
    1435                 :            : /* If BB ends by a conditional we can turn into predicates, attach corresponding
    1436                 :            :    predicates to the CFG edges.   */
    1437                 :            : 
    1438                 :            : static void
    1439                 :   23256400 : set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
    1440                 :            :                                    class ipa_fn_summary *summary,
    1441                 :            :                                    class ipa_node_params *params_summary,
    1442                 :            :                                    basic_block bb)
    1443                 :            : {
    1444                 :   23256400 :   gimple *last;
    1445                 :   23256400 :   tree op, op2;
    1446                 :   23256400 :   int index;
    1447                 :   23256400 :   struct agg_position_info aggpos;
    1448                 :   23256400 :   enum tree_code code, inverted_code;
    1449                 :   23256400 :   edge e;
    1450                 :   23256400 :   edge_iterator ei;
    1451                 :   23256400 :   gimple *set_stmt;
    1452                 :   23256400 :   tree param_type;
    1453                 :   23256400 :   expr_eval_ops param_ops;
    1454                 :            : 
    1455                 :   23256400 :   last = last_stmt (bb);
    1456                 :   23256400 :   if (!last || gimple_code (last) != GIMPLE_COND)
    1457                 :   23252900 :     return;
    1458                 :    7653180 :   if (!is_gimple_ip_invariant (gimple_cond_rhs (last)))
    1459                 :            :     return;
    1460                 :    5972320 :   op = gimple_cond_lhs (last);
    1461                 :            : 
    1462                 :    5972320 :   if (decompose_param_expr (fbi, last, op, &index, &param_type, &aggpos,
    1463                 :            :                             &param_ops))
    1464                 :            :     {
    1465                 :     761306 :       code = gimple_cond_code (last);
    1466                 :     761306 :       inverted_code = invert_tree_comparison (code, HONOR_NANS (op));
    1467                 :            : 
    1468                 :    2283920 :       FOR_EACH_EDGE (e, ei, bb->succs)
    1469                 :            :         {
    1470                 :    3045220 :           enum tree_code this_code = (e->flags & EDGE_TRUE_VALUE
    1471                 :    1522610 :                                       ? code : inverted_code);
    1472                 :            :           /* invert_tree_comparison will return ERROR_MARK on FP
    1473                 :            :              comparisons that are not EQ/NE instead of returning proper
    1474                 :            :              unordered one.  Be sure it is not confused with NON_CONSTANT.
    1475                 :            : 
    1476                 :            :              And if the edge's target is the final block of diamond CFG graph
    1477                 :            :              of this conditional statement, we do not need to compute
    1478                 :            :              predicate for the edge because the final block's predicate must
    1479                 :            :              be at least as that of the first block of the statement.  */
    1480                 :    1522610 :           if (this_code != ERROR_MARK
    1481                 :    1522610 :               && !dominated_by_p (CDI_POST_DOMINATORS, bb, e->dest))
    1482                 :            :             {
    1483                 :    1208400 :               predicate p
    1484                 :            :                 = add_condition (summary, params_summary, index,
    1485                 :            :                                  param_type, &aggpos,
    1486                 :    1208400 :                                  this_code, gimple_cond_rhs (last), param_ops);
    1487                 :    1208400 :               e->aux = edge_predicate_pool.allocate ();
    1488                 :    1208400 :               *(predicate *) e->aux = p;
    1489                 :            :             }
    1490                 :            :         }
    1491                 :     761306 :       vec_free (param_ops);
    1492                 :            :     }
    1493                 :            : 
    1494                 :    5972320 :   if (TREE_CODE (op) != SSA_NAME)
    1495                 :            :     return;
    1496                 :            :   /* Special case
    1497                 :            :      if (builtin_constant_p (op))
    1498                 :            :      constant_code
    1499                 :            :      else
    1500                 :            :      nonconstant_code.
    1501                 :            :      Here we can predicate nonconstant_code.  We can't
    1502                 :            :      really handle constant_code since we have no predicate
    1503                 :            :      for this and also the constant code is not known to be
    1504                 :            :      optimized away when inliner doesn't see operand is constant.
    1505                 :            :      Other optimizers might think otherwise.  */
    1506                 :    5964370 :   if (gimple_cond_code (last) != NE_EXPR
    1507                 :    5964370 :       || !integer_zerop (gimple_cond_rhs (last)))
    1508                 :    3383980 :     return;
    1509                 :    2580380 :   set_stmt = SSA_NAME_DEF_STMT (op);
    1510                 :    2580380 :   if (!gimple_call_builtin_p (set_stmt, BUILT_IN_CONSTANT_P)
    1511                 :    2580380 :       || gimple_call_num_args (set_stmt) != 1)
    1512                 :            :     return;
    1513                 :       4372 :   op2 = gimple_call_arg (set_stmt, 0);
    1514                 :       4372 :   if (!decompose_param_expr (fbi, set_stmt, op2, &index, &param_type, &aggpos))
    1515                 :            :     return;
    1516                 :      10551 :   FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_FALSE_VALUE)
    1517                 :            :     {
    1518                 :       3517 :       predicate p = add_condition (summary, params_summary, index,
    1519                 :            :                                    param_type, &aggpos,
    1520                 :       3517 :                                    predicate::is_not_constant, NULL_TREE);
    1521                 :       3517 :       e->aux = edge_predicate_pool.allocate ();
    1522                 :       3517 :       *(predicate *) e->aux = p;
    1523                 :            :     }
    1524                 :            : }
    1525                 :            : 
    1526                 :            : 
    1527                 :            : /* If BB ends by a switch we can turn into predicates, attach corresponding
    1528                 :            :    predicates to the CFG edges.   */
    1529                 :            : 
    1530                 :            : static void
    1531                 :   23256400 : set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
    1532                 :            :                                      class ipa_fn_summary *summary,
    1533                 :            :                                      class ipa_node_params *params_summary,
    1534                 :            :                                      basic_block bb)
    1535                 :            : {
    1536                 :   23256400 :   gimple *lastg;
    1537                 :   23256400 :   tree op;
    1538                 :   23256400 :   int index;
    1539                 :   23256400 :   struct agg_position_info aggpos;
    1540                 :   23256400 :   edge e;
    1541                 :   23256400 :   edge_iterator ei;
    1542                 :   23256400 :   size_t n;
    1543                 :   23256400 :   size_t case_idx;
    1544                 :   23256400 :   tree param_type;
    1545                 :   23256400 :   expr_eval_ops param_ops;
    1546                 :            : 
    1547                 :   23256400 :   lastg = last_stmt (bb);
    1548                 :   23256400 :   if (!lastg || gimple_code (lastg) != GIMPLE_SWITCH)
    1549                 :   23238800 :     return;
    1550                 :      51653 :   gswitch *last = as_a <gswitch *> (lastg);
    1551                 :      51653 :   op = gimple_switch_index (last);
    1552                 :      51653 :   if (!decompose_param_expr (fbi, last, op, &index, &param_type, &aggpos,
    1553                 :            :                              &param_ops))
    1554                 :            :     return;
    1555                 :            : 
    1556                 :      45803 :   auto_vec<std::pair<tree, tree> > ranges;
    1557                 :      28211 :   tree type = TREE_TYPE (op);
    1558                 :      28211 :   int bound_limit = opt_for_fn (fbi->node->decl,
    1559                 :            :                                 param_ipa_max_switch_predicate_bounds);
    1560                 :      28211 :   int bound_count = 0;
    1561                 :      28211 :   wide_int vr_wmin, vr_wmax;
    1562                 :      28211 :   value_range_kind vr_type = get_range_info (op, &vr_wmin, &vr_wmax);
    1563                 :            : 
    1564                 :     167393 :   FOR_EACH_EDGE (e, ei, bb->succs)
    1565                 :            :     {
    1566                 :     139182 :       e->aux = edge_predicate_pool.allocate ();
    1567                 :     139182 :       *(predicate *) e->aux = false;
    1568                 :            :     }
    1569                 :            : 
    1570                 :      28211 :   e = gimple_switch_edge (cfun, last, 0);
    1571                 :            :   /* Set BOUND_COUNT to maximum count to bypass computing predicate for
    1572                 :            :      default case if its target basic block is in convergence point of all
    1573                 :            :      switch cases, which can be determined by checking whether it
    1574                 :            :      post-dominates the switch statement.  */
    1575                 :      28211 :   if (dominated_by_p (CDI_POST_DOMINATORS, bb, e->dest))
    1576                 :       9752 :     bound_count = INT_MAX;
    1577                 :            : 
    1578                 :      28211 :   n = gimple_switch_num_labels (last);
    1579                 :     149402 :   for (case_idx = 1; case_idx < n; ++case_idx)
    1580                 :            :     {
    1581                 :     121191 :       tree cl = gimple_switch_label (last, case_idx);
    1582                 :     121191 :       tree min = CASE_LOW (cl);
    1583                 :     121191 :       tree max = CASE_HIGH (cl);
    1584                 :     121191 :       predicate p;
    1585                 :            : 
    1586                 :     121191 :       e = gimple_switch_edge (cfun, last, case_idx);
    1587                 :            : 
    1588                 :            :       /* The case value might not have same type as switch expression,
    1589                 :            :          extend the value based on the expression type.  */
    1590                 :     121191 :       if (TREE_TYPE (min) != type)
    1591                 :      24294 :         min = wide_int_to_tree (type, wi::to_wide (min));
    1592                 :            : 
    1593                 :     121191 :       if (!max)
    1594                 :            :         max = min;
    1595                 :       4539 :       else if (TREE_TYPE (max) != type)
    1596                 :        358 :         max = wide_int_to_tree (type, wi::to_wide (max));
    1597                 :            : 
    1598                 :            :       /* The case's target basic block is in convergence point of all switch
    1599                 :            :          cases, its predicate should be at least as that of the switch
    1600                 :            :          statement.  */
    1601                 :     121191 :       if (dominated_by_p (CDI_POST_DOMINATORS, bb, e->dest))
    1602                 :       2090 :         p = true;
    1603                 :     119101 :       else if (min == max)
    1604                 :     115253 :         p = add_condition (summary, params_summary, index, param_type,
    1605                 :     115253 :                            &aggpos, EQ_EXPR, min, param_ops);
    1606                 :            :       else
    1607                 :            :         {
    1608                 :       3848 :           predicate p1, p2;
    1609                 :       3848 :           p1 = add_condition (summary, params_summary, index, param_type,
    1610                 :       3848 :                               &aggpos, GE_EXPR, min, param_ops);
    1611                 :       3848 :           p2 = add_condition (summary,  params_summary,index, param_type,
    1612                 :       3848 :                               &aggpos, LE_EXPR, max, param_ops);
    1613                 :       3848 :           p = p1 & p2;
    1614                 :            :         }
    1615                 :     121191 :       *(class predicate *) e->aux
    1616                 :     121191 :         = p.or_with (summary->conds, *(class predicate *) e->aux);
    1617                 :            : 
    1618                 :            :       /* If there are too many disjoint case ranges, predicate for default
    1619                 :            :          case might become too complicated.  So add a limit here.  */
    1620                 :     121191 :       if (bound_count > bound_limit)
    1621                 :      53759 :         continue;
    1622                 :            : 
    1623                 :      67432 :       bool new_range = true;
    1624                 :            : 
    1625                 :      67432 :       if (!ranges.is_empty ())
    1626                 :            :         {
    1627                 :      48973 :           wide_int curr_wmin = wi::to_wide (min);
    1628                 :      48973 :           wide_int last_wmax = wi::to_wide (ranges.last ().second);
    1629                 :            : 
    1630                 :            :           /* Merge case ranges if they are continuous.  */
    1631                 :      48973 :           if (curr_wmin == last_wmax + 1)
    1632                 :            :             new_range = false;
    1633                 :      15357 :           else if (vr_type == VR_ANTI_RANGE)
    1634                 :            :             {
    1635                 :            :               /* If two disjoint case ranges can be connected by anti-range
    1636                 :            :                  of switch index, combine them to one range.  */
    1637                 :          0 :               if (wi::lt_p (vr_wmax, curr_wmin - 1, TYPE_SIGN (type)))
    1638                 :            :                 vr_type = VR_UNDEFINED;
    1639                 :          0 :               else if (wi::le_p (vr_wmin, last_wmax + 1, TYPE_SIGN (type)))
    1640                 :          0 :                 new_range = false;
    1641                 :            :             }
    1642                 :            :         }
    1643                 :            : 
    1644                 :            :       /* Create/extend a case range.  And we count endpoints of range set,
    1645                 :            :          this number nearly equals to number of conditions that we will create
    1646                 :            :          for predicate of default case.  */
    1647                 :      48973 :       if (new_range)
    1648                 :            :         {
    1649                 :      33816 :           bound_count += (min == max) ? 1 : 2;
    1650                 :      33816 :           ranges.safe_push (std::make_pair (min, max));
    1651                 :            :         }
    1652                 :            :       else
    1653                 :            :         {
    1654                 :      33616 :           bound_count += (ranges.last ().first == ranges.last ().second);
    1655                 :      33616 :           ranges.last ().second = max;
    1656                 :            :         }
    1657                 :            :     }
    1658                 :            : 
    1659                 :      28211 :   e = gimple_switch_edge (cfun, last, 0);
    1660                 :      28211 :   if (bound_count > bound_limit)
    1661                 :            :     {
    1662                 :      10619 :       *(class predicate *) e->aux = true;
    1663                 :      10619 :       vec_free (param_ops);
    1664                 :   23249400 :       return;
    1665                 :            :     }
    1666                 :            : 
    1667                 :      17592 :   predicate p_seg = true;
    1668                 :      17592 :   predicate p_all = false;
    1669                 :            : 
    1670                 :      17592 :   if (vr_type != VR_RANGE)
    1671                 :            :     {
    1672                 :      17190 :       vr_wmin = wi::to_wide (TYPE_MIN_VALUE (type));
    1673                 :      17190 :       vr_wmax = wi::to_wide (TYPE_MAX_VALUE (type));
    1674                 :            :     }
    1675                 :            : 
    1676                 :            :   /* Construct predicate to represent default range set that is negation of
    1677                 :            :      all case ranges.  Case range is classified as containing single/non-single
    1678                 :            :      values.  Suppose a piece of case ranges in the following.
    1679                 :            : 
    1680                 :            :                 [D1...D2]  [S1] ... [Sn]  [D3...D4]
    1681                 :            : 
    1682                 :            :      To represent default case's range sets between two non-single value
    1683                 :            :      case ranges (From D2 to D3), we construct predicate as:
    1684                 :            : 
    1685                 :            :               D2 < x < D3 && x != S1 && ... && x != Sn
    1686                 :            :    */
    1687                 :      94588 :   for (size_t i = 0; i < ranges.length (); i++)
    1688                 :            :     {
    1689                 :      29782 :       tree min = ranges[i].first;
    1690                 :      29782 :       tree max = ranges[i].second;
    1691                 :            : 
    1692                 :      29782 :       if (min == max)
    1693                 :      16814 :         p_seg &= add_condition (summary, params_summary, index,
    1694                 :            :                                 param_type, &aggpos, NE_EXPR,
    1695                 :      16814 :                                 min, param_ops);
    1696                 :            :       else
    1697                 :            :         {
    1698                 :            :           /* Do not create sub-predicate for range that is beyond low bound
    1699                 :            :              of switch index.  */
    1700                 :      12968 :           if (wi::lt_p (vr_wmin, wi::to_wide (min), TYPE_SIGN (type)))
    1701                 :            :             {
    1702                 :      14914 :               p_seg &= add_condition (summary, params_summary, index,
    1703                 :            :                                       param_type, &aggpos,
    1704                 :       7457 :                                       LT_EXPR, min, param_ops);
    1705                 :       7457 :               p_all = p_all.or_with (summary->conds, p_seg);
    1706                 :            :             }
    1707                 :            : 
    1708                 :            :           /* Do not create sub-predicate for range that is beyond up bound
    1709                 :            :              of switch index.  */
    1710                 :      12968 :           if (wi::le_p (vr_wmax, wi::to_wide (max), TYPE_SIGN (type)))
    1711                 :            :             {
    1712                 :         80 :               p_seg = false;
    1713                 :         80 :               break;
    1714                 :            :             }
    1715                 :            : 
    1716                 :      12888 :           p_seg = add_condition (summary, params_summary, index,
    1717                 :            :                                  param_type, &aggpos, GT_EXPR,
    1718                 :      12888 :                                  max, param_ops);
    1719                 :            :         }
    1720                 :            :     }
    1721                 :            : 
    1722                 :      17592 :   p_all = p_all.or_with (summary->conds, p_seg);
    1723                 :      17592 :   *(class predicate *) e->aux
    1724                 :      17592 :     = p_all.or_with (summary->conds, *(class predicate *) e->aux);
    1725                 :            : 
    1726                 :      21901 :   vec_free (param_ops);
    1727                 :            : }
    1728                 :            : 
    1729                 :            : 
    1730                 :            : /* For each BB in NODE attach to its AUX pointer predicate under
    1731                 :            :    which it is executable.  */
    1732                 :            : 
    1733                 :            : static void
    1734                 :    4097720 : compute_bb_predicates (struct ipa_func_body_info *fbi,
    1735                 :            :                        struct cgraph_node *node,
    1736                 :            :                        class ipa_fn_summary *summary,
    1737                 :            :                        class ipa_node_params *params_summary)
    1738                 :            : {
    1739                 :    4097720 :   struct function *my_function = DECL_STRUCT_FUNCTION (node->decl);
    1740                 :    4097720 :   bool done = false;
    1741                 :    4097720 :   basic_block bb;
    1742                 :            : 
    1743                 :   27354100 :   FOR_EACH_BB_FN (bb, my_function)
    1744                 :            :     {
    1745                 :   23256400 :       set_cond_stmt_execution_predicate (fbi, summary, params_summary, bb);
    1746                 :   23256400 :       set_switch_stmt_execution_predicate (fbi, summary, params_summary, bb);
    1747                 :            :     }
    1748                 :            : 
    1749                 :            :   /* Entry block is always executable.  */
    1750                 :    4097720 :   ENTRY_BLOCK_PTR_FOR_FN (my_function)->aux
    1751                 :    4097720 :     = edge_predicate_pool.allocate ();
    1752                 :    4097720 :   *(predicate *) ENTRY_BLOCK_PTR_FOR_FN (my_function)->aux = true;
    1753                 :            : 
    1754                 :            :   /* A simple dataflow propagation of predicates forward in the CFG.
    1755                 :            :      TODO: work in reverse postorder.  */
    1756                 :   12360200 :   while (!done)
    1757                 :            :     {
    1758                 :    8262490 :       done = true;
    1759                 :   58320700 :       FOR_EACH_BB_FN (bb, my_function)
    1760                 :            :         {
    1761                 :   50058200 :           predicate p = false;
    1762                 :   50058200 :           edge e;
    1763                 :   50058200 :           edge_iterator ei;
    1764                 :   61747600 :           FOR_EACH_EDGE (e, ei, bb->preds)
    1765                 :            :             {
    1766                 :   53229400 :               if (e->src->aux)
    1767                 :            :                 {
    1768                 :   51923100 :                   predicate this_bb_predicate
    1769                 :            :                     = *(predicate *) e->src->aux;
    1770                 :   51923100 :                   if (e->aux)
    1771                 :    2833600 :                     this_bb_predicate &= (*(class predicate *) e->aux);
    1772                 :   51923100 :                   p = p.or_with (summary->conds, this_bb_predicate);
    1773                 :   51923100 :                   if (p == true)
    1774                 :            :                     break;
    1775                 :            :                 }
    1776                 :            :             }
    1777                 :   50058200 :           if (p != false)
    1778                 :            :             {
    1779                 :   49312400 :               basic_block pdom_bb;
    1780                 :            : 
    1781                 :   49312400 :               if (!bb->aux)
    1782                 :            :                 {
    1783                 :   18056800 :                   done = false;
    1784                 :   18056800 :                   bb->aux = edge_predicate_pool.allocate ();
    1785                 :   18056800 :                   *((predicate *) bb->aux) = p;
    1786                 :            :                 }
    1787                 :   31255700 :               else if (p != *(predicate *) bb->aux)
    1788                 :            :                 {
    1789                 :            :                   /* This OR operation is needed to ensure monotonous data flow
    1790                 :            :                      in the case we hit the limit on number of clauses and the
    1791                 :            :                      and/or operations above give approximate answers.  */
    1792                 :      98225 :                   p = p.or_with (summary->conds, *(predicate *)bb->aux);
    1793                 :      98225 :                   if (p != *(predicate *) bb->aux)
    1794                 :            :                     {
    1795                 :      79917 :                       done = false;
    1796                 :      79917 :                       *((predicate *) bb->aux) = p;
    1797                 :            :                     }
    1798                 :            :                 }
    1799                 :            : 
    1800                 :            :               /* For switch/if statement, we can OR-combine predicates of all
    1801                 :            :                  its cases/branches to get predicate for basic block in their
    1802                 :            :                  convergence point, but sometimes this will generate very
    1803                 :            :                  complicated predicate.  Actually, we can get simplified
    1804                 :            :                  predicate in another way by using the fact that predicate
    1805                 :            :                  for a basic block must also hold true for its post dominators.
    1806                 :            :                  To be specific, basic block in convergence point of
    1807                 :            :                  conditional statement should include predicate of the
    1808                 :            :                  statement.  */
    1809                 :   49312400 :               pdom_bb = get_immediate_dominator (CDI_POST_DOMINATORS, bb);
    1810                 :   49312400 :               if (pdom_bb == EXIT_BLOCK_PTR_FOR_FN (my_function) || !pdom_bb)
    1811                 :            :                 ;
    1812                 :   25545900 :               else if (!pdom_bb->aux)
    1813                 :            :                 {
    1814                 :    5199650 :                   done = false;
    1815                 :    5199650 :                   pdom_bb->aux = edge_predicate_pool.allocate ();
    1816                 :    5199650 :                   *((predicate *) pdom_bb->aux) = p;
    1817                 :            :                 }
    1818                 :   20346200 :               else if (p != *(predicate *) pdom_bb->aux)
    1819                 :            :                 {
    1820                 :    2191360 :                   p = p.or_with (summary->conds, *(predicate *)pdom_bb->aux);
    1821                 :    2191360 :                   if (p != *(predicate *) pdom_bb->aux)
    1822                 :            :                     {
    1823                 :      94021 :                       done = false;
    1824                 :      94021 :                       *((predicate *) pdom_bb->aux) = p;
    1825                 :            :                     }
    1826                 :            :                 }
    1827                 :            :             }
    1828                 :            :         }
    1829                 :            :     }
    1830                 :    4097720 : }
    1831                 :            : 
    1832                 :            : 
    1833                 :            : /* Return predicate specifying when the STMT might have result that is not
    1834                 :            :    a compile time constant.  */
    1835                 :            : 
    1836                 :            : static predicate
    1837                 :    3040870 : will_be_nonconstant_expr_predicate (ipa_func_body_info *fbi,
    1838                 :            :                                     class ipa_fn_summary *summary,
    1839                 :            :                                     class ipa_node_params *params_summary,
    1840                 :            :                                     tree expr,
    1841                 :            :                                     vec<predicate> nonconstant_names)
    1842                 :            : {
    1843                 :    3208340 :   tree parm;
    1844                 :    3208340 :   int index;
    1845                 :            : 
    1846                 :    3208340 :   while (UNARY_CLASS_P (expr))
    1847                 :     167465 :     expr = TREE_OPERAND (expr, 0);
    1848                 :            : 
    1849                 :    3040870 :   parm = unmodified_parm (fbi, NULL, expr, NULL);
    1850                 :    3040870 :   if (parm && (index = ipa_get_param_decl_index (fbi->info, parm)) >= 0)
    1851                 :     166863 :     return add_condition (summary, params_summary, index, TREE_TYPE (parm), NULL,
    1852                 :     166863 :                           predicate::changed, NULL_TREE);
    1853                 :    2874010 :   if (is_gimple_min_invariant (expr))
    1854                 :      41522 :     return false;
    1855                 :    2832490 :   if (TREE_CODE (expr) == SSA_NAME)
    1856                 :    2725880 :     return nonconstant_names[SSA_NAME_VERSION (expr)];
    1857                 :     106609 :   if (BINARY_CLASS_P (expr) || COMPARISON_CLASS_P (expr))
    1858                 :            :     {
    1859                 :     106608 :       predicate p1
    1860                 :            :         = will_be_nonconstant_expr_predicate (fbi, summary,
    1861                 :            :                                               params_summary,
    1862                 :     106608 :                                               TREE_OPERAND (expr, 0),
    1863                 :     106608 :                                               nonconstant_names);
    1864                 :     106608 :       if (p1 == true)
    1865                 :      63719 :         return p1;
    1866                 :            : 
    1867                 :      42889 :       predicate p2
    1868                 :            :         = will_be_nonconstant_expr_predicate (fbi, summary,
    1869                 :            :                                               params_summary,
    1870                 :      42889 :                                               TREE_OPERAND (expr, 1),
    1871                 :      42889 :                                               nonconstant_names);
    1872                 :      42889 :       return p1.or_with (summary->conds, p2);
    1873                 :            :     }
    1874                 :          1 :   else if (TREE_CODE (expr) == COND_EXPR)
    1875                 :            :     {
    1876                 :          0 :       predicate p1
    1877                 :            :         = will_be_nonconstant_expr_predicate (fbi, summary,
    1878                 :            :                                               params_summary,
    1879                 :          0 :                                               TREE_OPERAND (expr, 0),
    1880                 :          0 :                                               nonconstant_names);
    1881                 :          0 :       if (p1 == true)
    1882                 :          0 :         return p1;
    1883                 :            : 
    1884                 :          0 :       predicate p2
    1885                 :            :         = will_be_nonconstant_expr_predicate (fbi, summary,
    1886                 :            :                                               params_summary,
    1887                 :          0 :                                               TREE_OPERAND (expr, 1),
    1888                 :          0 :                                               nonconstant_names);
    1889                 :          0 :       if (p2 == true)
    1890                 :          0 :         return p2;
    1891                 :          0 :       p1 = p1.or_with (summary->conds, p2);
    1892                 :          0 :       p2 = will_be_nonconstant_expr_predicate (fbi, summary,
    1893                 :            :                                                params_summary,
    1894                 :          0 :                                                TREE_OPERAND (expr, 2),
    1895                 :          0 :                                                nonconstant_names);
    1896                 :          0 :       return p2.or_with (summary->conds, p1);
    1897                 :            :     }
    1898                 :          1 :   else if (TREE_CODE (expr) == CALL_EXPR)
    1899                 :          1 :     return true;
    1900                 :            :   else
    1901                 :            :     {
    1902                 :          0 :       debug_tree (expr);
    1903                 :          0 :       gcc_unreachable ();
    1904                 :            :     }
    1905                 :            :   return false;
    1906                 :            : }
    1907                 :            : 
    1908                 :            : 
    1909                 :            : /* Return predicate specifying when the STMT might have result that is not
    1910                 :            :    a compile time constant.  */
    1911                 :            : 
    1912                 :            : static predicate
    1913                 :   77948100 : will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
    1914                 :            :                                class ipa_fn_summary *summary,
    1915                 :            :                                class ipa_node_params *params_summary,
    1916                 :            :                                gimple *stmt,
    1917                 :            :                                vec<predicate> nonconstant_names)
    1918                 :            : {
    1919                 :   77948100 :   predicate p = true;
    1920                 :   77948100 :   ssa_op_iter iter;
    1921                 :   77948100 :   tree use;
    1922                 :   77948100 :   tree param_type = NULL_TREE;
    1923                 :   77948100 :   predicate op_non_const;
    1924                 :   77948100 :   bool is_load;
    1925                 :   77948100 :   int base_index;
    1926                 :   77948100 :   struct agg_position_info aggpos;
    1927                 :            : 
    1928                 :            :   /* What statements might be optimized away
    1929                 :            :      when their arguments are constant.  */
    1930                 :   77948100 :   if (gimple_code (stmt) != GIMPLE_ASSIGN
    1931                 :   26946800 :       && gimple_code (stmt) != GIMPLE_COND
    1932                 :   19293600 :       && gimple_code (stmt) != GIMPLE_SWITCH
    1933                 :   97190000 :       && (gimple_code (stmt) != GIMPLE_CALL
    1934                 :   13303600 :           || !(gimple_call_flags (stmt) & ECF_CONST)))
    1935                 :   18376700 :     return p;
    1936                 :            : 
    1937                 :            :   /* Stores will stay anyway.  */
    1938                 :   59571400 :   if (gimple_store_p (stmt))
    1939                 :   17884600 :     return p;
    1940                 :            : 
    1941                 :   41686700 :   is_load = gimple_assign_load_p (stmt);
    1942                 :            : 
    1943                 :            :   /* Loads can be optimized when the value is known.  */
    1944                 :   41686700 :   if (is_load)
    1945                 :            :     {
    1946                 :   11744200 :       tree op = gimple_assign_rhs1 (stmt);
    1947                 :   11744200 :       if (!decompose_param_expr (fbi, stmt, op, &base_index, &param_type,
    1948                 :            :                                  &aggpos))
    1949                 :    9828920 :         return p;
    1950                 :            :     }
    1951                 :            :   else
    1952                 :   29942500 :     base_index = -1;
    1953                 :            : 
    1954                 :            :   /* See if we understand all operands before we start
    1955                 :            :      adding conditionals.  */
    1956                 :   42463400 :   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
    1957                 :            :     {
    1958                 :   31343100 :       tree parm = unmodified_parm (fbi, stmt, use, NULL);
    1959                 :            :       /* For arguments we can build a condition.  */
    1960                 :   31343100 :       if (parm && ipa_get_param_decl_index (fbi->info, parm) >= 0)
    1961                 :    5207920 :         continue;
    1962                 :   26135200 :       if (TREE_CODE (use) != SSA_NAME)
    1963                 :          0 :         return p;
    1964                 :            :       /* If we know when operand is constant,
    1965                 :            :          we still can say something useful.  */
    1966                 :   26135200 :       if (nonconstant_names[SSA_NAME_VERSION (use)] != true)
    1967                 :    5397700 :         continue;
    1968                 :   20737500 :       return p;
    1969                 :            :     }
    1970                 :            : 
    1971                 :   11120300 :   if (is_load)
    1972                 :    1915210 :     op_non_const =
    1973                 :            :       add_condition (summary, params_summary,
    1974                 :            :                      base_index, param_type, &aggpos,
    1975                 :    1915210 :                      predicate::changed, NULL_TREE);
    1976                 :            :   else
    1977                 :    9205090 :     op_non_const = false;
    1978                 :   21013700 :   FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
    1979                 :            :     {
    1980                 :    9893450 :       tree parm = unmodified_parm (fbi, stmt, use, NULL);
    1981                 :    9893450 :       int index;
    1982                 :            : 
    1983                 :    9893450 :       if (parm && (index = ipa_get_param_decl_index (fbi->info, parm)) >= 0)
    1984                 :            :         {
    1985                 :    4877040 :           if (index != base_index)
    1986                 :    3386690 :             p = add_condition (summary, params_summary, index,
    1987                 :    3386690 :                                TREE_TYPE (parm), NULL,
    1988                 :    3386690 :                                predicate::changed, NULL_TREE);
    1989                 :            :           else
    1990                 :    1490340 :             continue;
    1991                 :            :         }
    1992                 :            :       else
    1993                 :    5016410 :         p = nonconstant_names[SSA_NAME_VERSION (use)];
    1994                 :    8403100 :       op_non_const = p.or_with (summary->conds, op_non_const);
    1995                 :            :     }
    1996                 :   11120300 :   if ((gimple_code (stmt) == GIMPLE_ASSIGN || gimple_code (stmt) == GIMPLE_CALL)
    1997                 :    9695130 :       && gimple_op (stmt, 0)
    1998                 :   20781400 :       && TREE_CODE (gimple_op (stmt, 0)) == SSA_NAME)
    1999                 :    9661100 :     nonconstant_names[SSA_NAME_VERSION (gimple_op (stmt, 0))]
    2000                 :    9661100 :       = op_non_const;
    2001                 :   11120300 :   return op_non_const;
    2002                 :            : }
    2003                 :            : 
    2004                 :            : struct record_modified_bb_info
    2005                 :            : {
    2006                 :            :   tree op;
    2007                 :            :   bitmap bb_set;
    2008                 :            :   gimple *stmt;
    2009                 :            : };
    2010                 :            : 
    2011                 :            : /* Value is initialized in INIT_BB and used in USE_BB.  We want to compute
    2012                 :            :    probability how often it changes between USE_BB.
    2013                 :            :    INIT_BB->count/USE_BB->count is an estimate, but if INIT_BB
    2014                 :            :    is in different loop nest, we can do better.
    2015                 :            :    This is all just estimate.  In theory we look for minimal cut separating
    2016                 :            :    INIT_BB and USE_BB, but we only want to anticipate loop invariant motion
    2017                 :            :    anyway.  */
    2018                 :            : 
    2019                 :            : static basic_block
    2020                 :    7388090 : get_minimal_bb (basic_block init_bb, basic_block use_bb)
    2021                 :            : {
    2022                 :    7388090 :   class loop *l = find_common_loop (init_bb->loop_father, use_bb->loop_father);
    2023                 :    7388090 :   if (l && l->header->count < init_bb->count)
    2024                 :     220489 :     return l->header;
    2025                 :            :   return init_bb;
    2026                 :            : }
    2027                 :            : 
    2028                 :            : /* Callback of walk_aliased_vdefs.  Records basic blocks where the value may be
    2029                 :            :    set except for info->stmt.  */
    2030                 :            : 
    2031                 :            : static bool
    2032                 :    3844540 : record_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
    2033                 :            : {
    2034                 :    3844540 :   struct record_modified_bb_info *info =
    2035                 :            :     (struct record_modified_bb_info *) data;
    2036                 :    3844540 :   if (SSA_NAME_DEF_STMT (vdef) == info->stmt)
    2037                 :            :     return false;
    2038                 :    3822930 :   if (gimple_clobber_p (SSA_NAME_DEF_STMT (vdef)))
    2039                 :            :     return false;
    2040                 :    7573010 :   bitmap_set_bit (info->bb_set,
    2041                 :    3786500 :                   SSA_NAME_IS_DEFAULT_DEF (vdef)
    2042                 :          0 :                   ? ENTRY_BLOCK_PTR_FOR_FN (cfun)->index
    2043                 :            :                   : get_minimal_bb
    2044                 :    3786500 :                          (gimple_bb (SSA_NAME_DEF_STMT (vdef)),
    2045                 :    3786500 :                           gimple_bb (info->stmt))->index);
    2046                 :    3786500 :   if (dump_file)
    2047                 :            :     {
    2048                 :          0 :       fprintf (dump_file, "     Param ");
    2049                 :          0 :       print_generic_expr (dump_file, info->op, TDF_SLIM);
    2050                 :          0 :       fprintf (dump_file, " changed at bb %i, minimal: %i stmt: ",
    2051                 :          0 :                gimple_bb (SSA_NAME_DEF_STMT (vdef))->index,
    2052                 :            :                get_minimal_bb
    2053                 :          0 :                          (gimple_bb (SSA_NAME_DEF_STMT (vdef)),
    2054                 :          0 :                           gimple_bb (info->stmt))->index);
    2055                 :          0 :       print_gimple_stmt (dump_file, SSA_NAME_DEF_STMT (vdef), 0);
    2056                 :            :     }
    2057                 :            :   return false;
    2058                 :            : }
    2059                 :            : 
    2060                 :            : /* Return probability (based on REG_BR_PROB_BASE) that I-th parameter of STMT
    2061                 :            :    will change since last invocation of STMT. 
    2062                 :            : 
    2063                 :            :    Value 0 is reserved for compile time invariants.
    2064                 :            :    For common parameters it is REG_BR_PROB_BASE.  For loop invariants it
    2065                 :            :    ought to be REG_BR_PROB_BASE / estimated_iters.  */
    2066                 :            : 
    2067                 :            : static int
    2068                 :   22953800 : param_change_prob (ipa_func_body_info *fbi, gimple *stmt, int i)
    2069                 :            : {
    2070                 :   22953800 :   tree op = gimple_call_arg (stmt, i);
    2071                 :   22953800 :   basic_block bb = gimple_bb (stmt);
    2072                 :            : 
    2073                 :   22953800 :   if (TREE_CODE (op) == WITH_SIZE_EXPR)
    2074                 :        294 :     op = TREE_OPERAND (op, 0);
    2075                 :            : 
    2076                 :   22953800 :   tree base = get_base_address (op);
    2077                 :            : 
    2078                 :            :   /* Global invariants never change.  */
    2079                 :   22953800 :   if (is_gimple_min_invariant (base))
    2080                 :            :     return 0;
    2081                 :            : 
    2082                 :            :   /* We would have to do non-trivial analysis to really work out what
    2083                 :            :      is the probability of value to change (i.e. when init statement
    2084                 :            :      is in a sibling loop of the call). 
    2085                 :            : 
    2086                 :            :      We do an conservative estimate: when call is executed N times more often
    2087                 :            :      than the statement defining value, we take the frequency 1/N.  */
    2088                 :   11687400 :   if (TREE_CODE (base) == SSA_NAME)
    2089                 :            :     {
    2090                 :   10106300 :       profile_count init_count;
    2091                 :            : 
    2092                 :   10106300 :       if (!bb->count.nonzero_p ())
    2093                 :    4814180 :         return REG_BR_PROB_BASE;
    2094                 :            : 
    2095                 :    5292150 :       if (SSA_NAME_IS_DEFAULT_DEF (base))
    2096                 :    1690560 :         init_count = ENTRY_BLOCK_PTR_FOR_FN (cfun)->count;
    2097                 :            :       else
    2098                 :    3601580 :         init_count = get_minimal_bb
    2099                 :    3601580 :                       (gimple_bb (SSA_NAME_DEF_STMT (base)),
    2100                 :            :                        gimple_bb (stmt))->count;
    2101                 :            : 
    2102                 :    5292150 :       if (init_count < bb->count)
    2103                 :     310564 :         return MAX ((init_count.to_sreal_scale (bb->count)
    2104                 :            :                      * REG_BR_PROB_BASE).to_int (), 1);
    2105                 :            :       return REG_BR_PROB_BASE;
    2106                 :            :     }
    2107                 :            :   else
    2108                 :            :     {
    2109                 :    1581080 :       ao_ref refd;
    2110                 :    1581080 :       profile_count max = ENTRY_BLOCK_PTR_FOR_FN (cfun)->count;
    2111                 :    1581080 :       struct record_modified_bb_info info;
    2112                 :    1581080 :       tree init = ctor_for_folding (base);
    2113                 :            : 
    2114                 :    1581080 :       if (init != error_mark_node)
    2115                 :            :         return 0;
    2116                 :    1580990 :       if (!bb->count.nonzero_p ())
    2117                 :     589200 :         return REG_BR_PROB_BASE;
    2118                 :     991793 :       if (dump_file)
    2119                 :            :         {
    2120                 :          0 :           fprintf (dump_file, "     Analyzing param change probability of ");
    2121                 :          0 :           print_generic_expr (dump_file, op, TDF_SLIM);
    2122                 :          0 :           fprintf (dump_file, "\n");
    2123                 :            :         }
    2124                 :     991793 :       ao_ref_init (&refd, op);
    2125                 :     991793 :       info.op = op;
    2126                 :     991793 :       info.stmt = stmt;
    2127                 :     991793 :       info.bb_set = BITMAP_ALLOC (NULL);
    2128                 :     991793 :       int walked
    2129                 :    1983590 :         = walk_aliased_vdefs (&refd, gimple_vuse (stmt), record_modified, &info,
    2130                 :            :                               NULL, NULL, fbi->aa_walk_budget);
    2131                 :     991793 :       if (walked < 0 || bitmap_bit_p (info.bb_set, bb->index))
    2132                 :            :         {
    2133                 :     639874 :           if (dump_file)
    2134                 :            :             {
    2135                 :          0 :               if (walked < 0)
    2136                 :          0 :                 fprintf (dump_file, "     Ran out of AA walking budget.\n");
    2137                 :            :               else
    2138                 :          0 :                 fprintf (dump_file, "     Set in same BB as used.\n");
    2139                 :            :             }
    2140                 :     639874 :           BITMAP_FREE (info.bb_set);
    2141                 :     639874 :           return REG_BR_PROB_BASE;
    2142                 :            :         }
    2143                 :            : 
    2144                 :     351919 :       bitmap_iterator bi;
    2145                 :     351919 :       unsigned index;
    2146                 :            :       /* Lookup the most frequent update of the value and believe that
    2147                 :            :          it dominates all the other; precise analysis here is difficult.  */
    2148                 :    1136700 :       EXECUTE_IF_SET_IN_BITMAP (info.bb_set, 0, index, bi)
    2149                 :     784783 :         max = max.max (BASIC_BLOCK_FOR_FN (cfun, index)->count);
    2150                 :     351919 :       if (dump_file)
    2151                 :            :         {
    2152                 :          0 :           fprintf (dump_file, "     Set with count ");        
    2153                 :          0 :           max.dump (dump_file);
    2154                 :          0 :           fprintf (dump_file, " and used with count ");       
    2155                 :          0 :           bb->count.dump (dump_file);
    2156                 :          0 :           fprintf (dump_file, " freq %f\n",
    2157                 :          0 :                    max.to_sreal_scale (bb->count).to_double ());     
    2158                 :            :         }
    2159                 :            : 
    2160                 :     351919 :       BITMAP_FREE (info.bb_set);
    2161                 :     351919 :       if (max < bb->count)
    2162                 :      66172 :         return MAX ((max.to_sreal_scale (bb->count)
    2163                 :            :                      * REG_BR_PROB_BASE).to_int (), 1);
    2164                 :            :       return REG_BR_PROB_BASE;
    2165                 :            :     }
    2166                 :            : }
    2167                 :            : 
    2168                 :            : /* Find whether a basic block BB is the final block of a (half) diamond CFG
    2169                 :            :    sub-graph and if the predicate the condition depends on is known.  If so,
    2170                 :            :    return true and store the pointer the predicate in *P.  */
    2171                 :            : 
    2172                 :            : static bool
    2173                 :    4780650 : phi_result_unknown_predicate (ipa_func_body_info *fbi,
    2174                 :            :                               ipa_fn_summary *summary,
    2175                 :            :                               class ipa_node_params *params_summary,
    2176                 :            :                               basic_block bb,
    2177                 :            :                               predicate *p,
    2178                 :            :                               vec<predicate> nonconstant_names)
    2179                 :            : {
    2180                 :    4780650 :   edge e;
    2181                 :    4780650 :   edge_iterator ei;
    2182                 :    4780650 :   basic_block first_bb = NULL;
    2183                 :    4780650 :   gimple *stmt;
    2184                 :            : 
    2185                 :    4780650 :   if (single_pred_p (bb))
    2186                 :            :     {
    2187                 :     274090 :       *p = false;
    2188                 :     274090 :       return true;
    2189                 :            :     }
    2190                 :            : 
    2191                 :   10413000 :   FOR_EACH_EDGE (e, ei, bb->preds)
    2192                 :            :     {
    2193                 :    8776450 :       if (single_succ_p (e->src))
    2194                 :            :         {
    2195                 :    5650760 :           if (!single_pred_p (e->src))
    2196                 :            :             return false;
    2197                 :    4954260 :           if (!first_bb)
    2198                 :    2126430 :             first_bb = single_pred (e->src);
    2199                 :    2827830 :           else if (single_pred (e->src) != first_bb)
    2200                 :            :             return false;
    2201                 :            :         }
    2202                 :            :       else
    2203                 :            :         {
    2204                 :    3125700 :           if (!first_bb)
    2205                 :            :             first_bb = e->src;
    2206                 :    1086750 :           else if (e->src != first_bb)
    2207                 :            :             return false;
    2208                 :            :         }
    2209                 :            :     }
    2210                 :            : 
    2211                 :    1636590 :   if (!first_bb)
    2212                 :            :     return false;
    2213                 :            : 
    2214                 :    1636590 :   stmt = last_stmt (first_bb);
    2215                 :    1636590 :   if (!stmt
    2216                 :    1636590 :       || gimple_code (stmt) != GIMPLE_COND
    2217                 :    3245250 :       || !is_gimple_ip_invariant (gimple_cond_rhs (stmt)))
    2218                 :     271777 :     return false;
    2219                 :            : 
    2220                 :    1364810 :   *p = will_be_nonconstant_expr_predicate (fbi, summary, params_summary,
    2221                 :            :                                            gimple_cond_lhs (stmt),
    2222                 :    1364810 :                                            nonconstant_names);
    2223                 :    1364810 :   if (*p == true)
    2224                 :            :     return false;
    2225                 :            :   else
    2226                 :     436326 :     return true;
    2227                 :            : }
    2228                 :            : 
    2229                 :            : /* Given a PHI statement in a function described by inline properties SUMMARY
    2230                 :            :    and *P being the predicate describing whether the selected PHI argument is
    2231                 :            :    known, store a predicate for the result of the PHI statement into
    2232                 :            :    NONCONSTANT_NAMES, if possible.  */
    2233                 :            : 
    2234                 :            : static void
    2235                 :     897218 : predicate_for_phi_result (class ipa_fn_summary *summary, gphi *phi,
    2236                 :            :                           predicate *p,
    2237                 :            :                           vec<predicate> nonconstant_names)
    2238                 :            : {
    2239                 :     897218 :   unsigned i;
    2240                 :            : 
    2241                 :    1094580 :   for (i = 0; i < gimple_phi_num_args (phi); i++)
    2242                 :            :     {
    2243                 :    1009510 :       tree arg = gimple_phi_arg (phi, i)->def;
    2244                 :    1009510 :       if (!is_gimple_min_invariant (arg))
    2245                 :            :         {
    2246                 :     938830 :           gcc_assert (TREE_CODE (arg) == SSA_NAME);
    2247                 :     938830 :           *p = p->or_with (summary->conds,
    2248                 :     938830 :                            nonconstant_names[SSA_NAME_VERSION (arg)]);
    2249                 :     938830 :           if (*p == true)
    2250                 :            :             return;
    2251                 :            :         }
    2252                 :            :     }
    2253                 :            : 
    2254                 :      85066 :   if (dump_file && (dump_flags & TDF_DETAILS))
    2255                 :            :     {
    2256                 :          3 :       fprintf (dump_file, "\t\tphi predicate: ");
    2257                 :          3 :       p->dump (dump_file, summary->conds);
    2258                 :            :     }
    2259                 :      85066 :   nonconstant_names[SSA_NAME_VERSION (gimple_phi_result (phi))] = *p;
    2260                 :            : }
    2261                 :            : 
    2262                 :            : /* For a typical usage of __builtin_expect (a<b, 1), we
    2263                 :            :    may introduce an extra relation stmt:
    2264                 :            :    With the builtin, we have
    2265                 :            :      t1 = a <= b;
    2266                 :            :      t2 = (long int) t1;
    2267                 :            :      t3 = __builtin_expect (t2, 1);
    2268                 :            :      if (t3 != 0)
    2269                 :            :        goto ...
    2270                 :            :    Without the builtin, we have
    2271                 :            :      if (a<=b)
    2272                 :            :        goto...
    2273                 :            :    This affects the size/time estimation and may have
    2274                 :            :    an impact on the earlier inlining.
    2275                 :            :    Here find this pattern and fix it up later.  */
    2276                 :            : 
    2277                 :            : static gimple *
    2278                 :   27010200 : find_foldable_builtin_expect (basic_block bb)
    2279                 :            : {
    2280                 :   27010200 :   gimple_stmt_iterator bsi;
    2281                 :            : 
    2282                 :  188791000 :   for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
    2283                 :            :     {
    2284                 :  134838000 :       gimple *stmt = gsi_stmt (bsi);
    2285                 :  134838000 :       if (gimple_call_builtin_p (stmt, BUILT_IN_EXPECT)
    2286                 :  134756000 :           || gimple_call_builtin_p (stmt, BUILT_IN_EXPECT_WITH_PROBABILITY)
    2287                 :  269594000 :           || gimple_call_internal_p (stmt, IFN_BUILTIN_EXPECT))
    2288                 :            :         {
    2289                 :     157768 :           tree var = gimple_call_lhs (stmt);
    2290                 :     157768 :           tree arg = gimple_call_arg (stmt, 0);
    2291                 :     157768 :           use_operand_p use_p;
    2292                 :     157768 :           gimple *use_stmt;
    2293                 :     157768 :           bool match = false;
    2294                 :     157768 :           bool done = false;
    2295                 :            : 
    2296                 :     157768 :           if (!var || !arg)
    2297                 :          4 :             continue;
    2298                 :     157764 :           gcc_assert (TREE_CODE (var) == SSA_NAME);
    2299                 :            : 
    2300                 :     315013 :           while (TREE_CODE (arg) == SSA_NAME)
    2301                 :            :             {
    2302                 :     315013 :               gimple *stmt_tmp = SSA_NAME_DEF_STMT (arg);
    2303                 :     315013 :               if (!is_gimple_assign (stmt_tmp))
    2304                 :            :                 break;
    2305                 :     311961 :               switch (gimple_assign_rhs_code (stmt_tmp))
    2306                 :            :                 {
    2307                 :     143808 :                   case LT_EXPR:
    2308                 :     143808 :                   case LE_EXPR:
    2309                 :     143808 :                   case GT_EXPR:
    2310                 :     143808 :                   case GE_EXPR:
    2311                 :     143808 :                   case EQ_EXPR:
    2312                 :     143808 :                   case NE_EXPR:
    2313                 :     143808 :                     match = true;
    2314                 :     143808 :                     done = true;
    2315                 :     143808 :                     break;
    2316                 :            :                   CASE_CONVERT:
    2317                 :            :                     break;
    2318                 :            :                   default:
    2319                 :            :                     done = true;
    2320                 :            :                     break;
    2321                 :            :                 }
    2322                 :     143808 :               if (done)
    2323                 :            :                 break;
    2324                 :     157249 :               arg = gimple_assign_rhs1 (stmt_tmp);
    2325                 :            :             }
    2326                 :            : 
    2327                 :     143808 :           if (match && single_imm_use (var, &use_p, &use_stmt)
    2328                 :     301510 :               && gimple_code (use_stmt) == GIMPLE_COND)
    2329                 :      67160 :             return use_stmt;
    2330                 :            :         }
    2331                 :            :     }
    2332                 :            :   return NULL;
    2333                 :            : }
    2334                 :            : 
    2335                 :            : /* Return true when the basic blocks contains only clobbers followed by RESX.
    2336                 :            :    Such BBs are kept around to make removal of dead stores possible with
    2337                 :            :    presence of EH and will be optimized out by optimize_clobbers later in the
    2338                 :            :    game. 
    2339                 :            : 
    2340                 :            :    NEED_EH is used to recurse in case the clobber has non-EH predecessors
    2341                 :            :    that can be clobber only, too.. When it is false, the RESX is not necessary
    2342                 :            :    on the end of basic block.  */
    2343                 :            : 
    2344                 :            : static bool
    2345                 :   27355300 : clobber_only_eh_bb_p (basic_block bb, bool need_eh = true)
    2346                 :            : {
    2347                 :   27355300 :   gimple_stmt_iterator gsi = gsi_last_bb (bb);
    2348                 :   27355300 :   edge_iterator ei;
    2349                 :   27355300 :   edge e;
    2350                 :            : 
    2351                 :   27355300 :   if (need_eh)
    2352                 :            :     {
    2353                 :   27310900 :       if (gsi_end_p (gsi))
    2354                 :            :         return false;
    2355                 :   26599700 :       if (gimple_code (gsi_stmt (gsi)) != GIMPLE_RESX)
    2356                 :            :         return false;
    2357                 :     644655 :       gsi_prev (&gsi);
    2358                 :            :     }
    2359                 :      44308 :   else if (!single_succ_p (bb))
    2360                 :            :     return false;
    2361                 :            : 
    2362                 :    3058190 :   for (; !gsi_end_p (gsi); gsi_prev (&gsi))
    2363                 :            :     {
    2364                 :    1807440 :       gimple *stmt = gsi_stmt (gsi);
    2365                 :    1807440 :       if (is_gimple_debug (stmt))
    2366                 :     723005 :         continue;
    2367                 :    1084440 :       if (gimple_clobber_p (stmt))
    2368                 :     483489 :         continue;
    2369                 :     600950 :       if (gimple_code (stmt) == GIMPLE_LABEL)
    2370                 :            :         break;
    2371                 :            :       return false;
    2372                 :            :     }
    2373                 :            : 
    2374                 :            :   /* See if all predecessors are either throws or clobber only BBs.  */
    2375                 :    2156400 :   FOR_EACH_EDGE (e, ei, bb->preds)
    2376                 :    1855650 :     if (!(e->flags & EDGE_EH)
    2377                 :    1855650 :         && !clobber_only_eh_bb_p (e->src, false))
    2378                 :            :       return false;
    2379                 :            : 
    2380                 :            :   return true;
    2381                 :            : }
    2382                 :            : 
    2383                 :            : /* Return true if STMT compute a floating point expression that may be affected
    2384                 :            :    by -ffast-math and similar flags.  */
    2385                 :            : 
    2386                 :            : static bool
    2387                 :   61641300 : fp_expression_p (gimple *stmt)
    2388                 :            : {
    2389                 :   61641300 :   ssa_op_iter i;
    2390                 :   61641300 :   tree op;
    2391                 :            : 
    2392                 :  136537000 :   FOR_EACH_SSA_TREE_OPERAND (op, stmt, i, SSA_OP_DEF|SSA_OP_USE)
    2393                 :   75204200 :     if (FLOAT_TYPE_P (TREE_TYPE (op)))
    2394                 :            :       return true;
    2395                 :            :   return false;
    2396                 :            : }
    2397                 :            : 
    2398                 :            : /* Analyze function body for NODE.
    2399                 :            :    EARLY indicates run from early optimization pipeline.  */
    2400                 :            : 
    2401                 :            : static void
    2402                 :    4618960 : analyze_function_body (struct cgraph_node *node, bool early)
    2403                 :            : {
    2404                 :    4618960 :   sreal time = opt_for_fn (node->decl, param_uninlined_function_time);
    2405                 :            :   /* Estimate static overhead for function prologue/epilogue and alignment. */
    2406                 :    4618960 :   int size = opt_for_fn (node->decl, param_uninlined_function_insns);
    2407                 :            :   /* Benefits are scaled by probability of elimination that is in range
    2408                 :            :      <0,2>.  */
    2409                 :    4618960 :   basic_block bb;
    2410                 :    4618960 :   struct function *my_function = DECL_STRUCT_FUNCTION (node->decl);
    2411                 :    4618960 :   sreal freq;
    2412                 :    4618960 :   class ipa_fn_summary *info = ipa_fn_summaries->get_create (node);
    2413                 :    4618960 :   class ipa_node_params *params_summary = early ? NULL : IPA_NODE_REF (node);
    2414                 :    4618960 :   predicate bb_predicate;
    2415                 :    4618960 :   struct ipa_func_body_info fbi;
    2416                 :    4618960 :   vec<predicate> nonconstant_names = vNULL;
    2417                 :    4618960 :   int nblocks, n;
    2418                 :    4618960 :   int *order;
    2419                 :    4618960 :   gimple *fix_builtin_expect_stmt;
    2420                 :            : 
    2421                 :    4618960 :   gcc_assert (my_function && my_function->cfg);
    2422                 :    4618960 :   gcc_assert (cfun == my_function);
    2423                 :            : 
    2424                 :    4618960 :   memset(&fbi, 0, sizeof(fbi));
    2425                 :    4618960 :   vec_free (info->conds);
    2426                 :    4618960 :   info->conds = NULL;
    2427                 :    4618960 :   vec_free (info->size_time_table);
    2428                 :    4618960 :   info->size_time_table = NULL;
    2429                 :            : 
    2430                 :            :   /* When optimizing and analyzing for IPA inliner, initialize loop optimizer
    2431                 :            :      so we can produce proper inline hints.
    2432                 :            : 
    2433                 :            :      When optimizing and analyzing for early inliner, initialize node params
    2434                 :            :      so we can produce correct BB predicates.  */
    2435                 :            :      
    2436                 :    4618960 :   if (opt_for_fn (node->decl, optimize))
    2437                 :            :     {
    2438                 :    4097720 :       calculate_dominance_info (CDI_DOMINATORS);
    2439                 :    4097720 :       calculate_dominance_info (CDI_POST_DOMINATORS);
    2440                 :    4097720 :       if (!early)
    2441                 :     893397 :         loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS);
    2442                 :            :       else
    2443                 :            :         {
    2444                 :    3204320 :           ipa_check_create_node_params ();
    2445                 :    3204320 :           ipa_initialize_node_params (node);
    2446                 :            :         }
    2447                 :            : 
    2448                 :    4097720 :       if (ipa_node_params_sum)
    2449                 :            :         {
    2450                 :    4097720 :           fbi.node = node;
    2451                 :    4097720 :           fbi.info = IPA_NODE_REF (node);
    2452                 :    4097720 :           fbi.bb_infos = vNULL;
    2453                 :    4097720 :           fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun));
    2454                 :    4097720 :           fbi.param_count = count_formal_params (node->decl);
    2455                 :    4097720 :           fbi.aa_walk_budget = opt_for_fn (node->decl, param_ipa_max_aa_steps);
    2456                 :            : 
    2457                 :    4097720 :           nonconstant_names.safe_grow_cleared
    2458                 :    4097720 :             (SSANAMES (my_function)->length ());
    2459                 :            :         }
    2460                 :            :     }
    2461                 :            : 
    2462                 :    4618960 :   if (dump_file)
    2463                 :        235 :     fprintf (dump_file, "\nAnalyzing function body size: %s\n",
    2464                 :            :              node->dump_name ());
    2465                 :            : 
    2466                 :            :   /* When we run into maximal number of entries, we assign everything to the
    2467                 :            :      constant truth case.  Be sure to have it in list. */
    2468                 :    4618960 :   bb_predicate = true;
    2469                 :    4618960 :   info->account_size_time (0, 0, bb_predicate, bb_predicate);
    2470                 :            : 
    2471                 :    4618960 :   bb_predicate = predicate::not_inlined ();
    2472                 :    4618960 :   info->account_size_time (opt_for_fn (node->decl,
    2473                 :            :                                 param_uninlined_function_insns)
    2474                 :            :                            * ipa_fn_summary::size_scale,
    2475                 :    4618960 :                            opt_for_fn (node->decl,
    2476                 :            :                                 param_uninlined_function_time),
    2477                 :            :                            bb_predicate,
    2478                 :            :                            bb_predicate);
    2479                 :            : 
    2480                 :    4618960 :   if (fbi.info)
    2481                 :    4097720 :     compute_bb_predicates (&fbi, node, info, params_summary);
    2482                 :    4618960 :   order = XNEWVEC (int, n_basic_blocks_for_fn (cfun));
    2483                 :    4618960 :   nblocks = pre_and_rev_post_order_compute (NULL, order, false);
    2484                 :   31929900 :   for (n = 0; n < nblocks; n++)
    2485                 :            :     {
    2486                 :   27310900 :       bb = BASIC_BLOCK_FOR_FN (cfun, order[n]);
    2487                 :   27310900 :       freq = bb->count.to_sreal_scale (ENTRY_BLOCK_PTR_FOR_FN (cfun)->count);
    2488                 :   27310900 :       if (clobber_only_eh_bb_p (bb))
    2489                 :            :         {
    2490                 :     300752 :           if (dump_file && (dump_flags & TDF_DETAILS))
    2491                 :          0 :             fprintf (dump_file, "\n Ignoring BB %i;"
    2492                 :            :                      " it will be optimized away by cleanup_clobbers\n",
    2493                 :            :                      bb->index);
    2494                 :     300752 :           continue;
    2495                 :            :         }
    2496                 :            : 
    2497                 :            :       /* TODO: Obviously predicates can be propagated down across CFG.  */
    2498                 :   27010200 :       if (fbi.info)
    2499                 :            :         {
    2500                 :   23000700 :           if (bb->aux)
    2501                 :   23000700 :             bb_predicate = *(predicate *) bb->aux;
    2502                 :            :           else
    2503                 :          0 :             bb_predicate = false;
    2504                 :            :         }
    2505                 :            :       else
    2506                 :    4009500 :         bb_predicate = true;
    2507                 :            : 
    2508                 :   27010200 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2509                 :            :         {
    2510                 :         64 :           fprintf (dump_file, "\n BB %i predicate:", bb->index);
    2511                 :         64 :           bb_predicate.dump (dump_file, info->conds);
    2512                 :            :         }
    2513                 :            : 
    2514                 :   27010200 :       if (fbi.info && nonconstant_names.exists ())
    2515                 :            :         {
    2516                 :   23000700 :           predicate phi_predicate;
    2517                 :   23000700 :           bool first_phi = true;
    2518                 :            : 
    2519                 :   23897900 :           for (gphi_iterator bsi = gsi_start_phis (bb); !gsi_end_p (bsi);
    2520                 :     897218 :                gsi_next (&bsi))
    2521                 :            :             {
    2522                 :    4967450 :               if (first_phi
    2523                 :    4967450 :                   && !phi_result_unknown_predicate (&fbi, info,
    2524                 :            :                                                     params_summary,
    2525                 :            :                                                     bb,
    2526                 :            :                                                     &phi_predicate,
    2527                 :            :                                                     nonconstant_names))
    2528                 :            :                 break;
    2529                 :     897218 :               first_phi = false;
    2530                 :     897218 :               if (dump_file && (dump_flags & TDF_DETAILS))
    2531                 :            :                 {
    2532                 :          3 :                   fprintf (dump_file, "  ");
    2533                 :          3 :                   print_gimple_stmt (dump_file, gsi_stmt (bsi), 0);
    2534                 :            :                 }
    2535                 :     897218 :               predicate_for_phi_result (info, bsi.phi (), &phi_predicate,
    2536                 :            :                                         nonconstant_names);
    2537                 :            :             }
    2538                 :            :         }
    2539                 :            : 
    2540                 :   27010200 :       fix_builtin_expect_stmt = find_foldable_builtin_expect (bb);
    2541                 :            : 
    2542                 :   27010200 :       for (gimple_stmt_iterator bsi = gsi_start_nondebug_bb (bb);
    2543                 :  209820000 :            !gsi_end_p (bsi); gsi_next_nondebug (&bsi))
    2544                 :            :         {
    2545                 :   91405000 :           gimple *stmt = gsi_stmt (bsi);
    2546                 :   91405000 :           int this_size = estimate_num_insns (stmt, &eni_size_weights);
    2547                 :   91405000 :           int this_time = estimate_num_insns (stmt, &eni_time_weights);
    2548                 :   91405000 :           int prob;
    2549                 :   91405000 :           predicate will_be_nonconstant;
    2550                 :            : 
    2551                 :            :           /* This relation stmt should be folded after we remove
    2552                 :            :              __builtin_expect call. Adjust the cost here.  */
    2553                 :   91405000 :           if (stmt == fix_builtin_expect_stmt)
    2554                 :            :             {
    2555                 :      67160 :               this_size--;
    2556                 :      67160 :               this_time--;
    2557                 :            :             }
    2558                 :            : 
    2559                 :   91405000 :           if (dump_file && (dump_flags & TDF_DETAILS))
    2560                 :            :             {
    2561                 :        232 :               fprintf (dump_file, "  ");
    2562                 :        232 :               print_gimple_stmt (dump_file, stmt, 0);
    2563                 :        232 :               fprintf (dump_file, "\t\tfreq:%3.2f size:%3i time:%3i\n",
    2564                 :            :                        freq.to_double (), this_size,
    2565                 :            :                        this_time);
    2566                 :            :             }
    2567                 :            : 
    2568                 :   91405000 :           if (is_gimple_call (stmt)
    2569                 :   91405000 :               && !gimple_call_internal_p (stmt))
    2570                 :            :             {
    2571                 :   14559900 :               struct cgraph_edge *edge = node->get_edge (stmt);
    2572                 :   14559900 :               ipa_call_summary *es = ipa_call_summaries->get_create (edge);
    2573                 :            : 
    2574                 :            :               /* Special case: results of BUILT_IN_CONSTANT_P will be always
    2575                 :            :                  resolved as constant.  We however don't want to optimize
    2576                 :            :                  out the cgraph edges.  */
    2577                 :   14559900 :               if (nonconstant_names.exists ()
    2578                 :   12776400 :                   && gimple_call_builtin_p (stmt, BUILT_IN_CONSTANT_P)
    2579                 :       3715 :                   && gimple_call_lhs (stmt)
    2580                 :   14563600 :                   && TREE_CODE (gimple_call_lhs (stmt)) == SSA_NAME)
    2581                 :            :                 {
    2582                 :       3715 :                   predicate false_p = false;
    2583                 :       3715 :                   nonconstant_names[SSA_NAME_VERSION (gimple_call_lhs (stmt))]
    2584                 :       3715 :                     = false_p;
    2585                 :            :                 }
    2586                 :   14559900 :               if (ipa_node_params_sum)
    2587                 :            :                 {
    2588                 :   12789600 :                   int count = gimple_call_num_args (stmt);
    2589                 :   12789600 :                   int i;
    2590                 :            : 
    2591                 :   12789600 :                   if (count)
    2592                 :   10864300 :                     es->param.safe_grow_cleared (count);
    2593                 :   35743400 :                   for (i = 0; i < count; i++)
    2594                 :            :                     {
    2595                 :   22953800 :                       int prob = param_change_prob (&fbi, stmt, i);
    2596                 :   22953800 :                       gcc_assert (prob >= 0 && prob <= REG_BR_PROB_BASE);
    2597                 :   22953800 :                       es->param[i].change_prob = prob;
    2598                 :            :                     }
    2599                 :            :                 }
    2600                 :            : 
    2601                 :   14559900 :               es->call_stmt_size = this_size;
    2602                 :   14559900 :               es->call_stmt_time = this_time;
    2603                 :   14559900 :               es->loop_depth = bb_loop_depth (bb);
    2604                 :   14559900 :               edge_set_predicate (edge, &bb_predicate);
    2605                 :   14559900 :               if (edge->speculative)
    2606                 :            :                 {
    2607                 :          0 :                   cgraph_edge *indirect
    2608                 :          0 :                         = edge->speculative_call_indirect_edge ();
    2609                 :          0 :                   ipa_call_summary *es2
    2610                 :          0 :                          = ipa_call_summaries->get_create (indirect);
    2611                 :          0 :                   ipa_call_summaries->duplicate (edge, indirect,
    2612                 :          0 :                                                  es, es2);
    2613                 :            : 
    2614                 :            :                   /* Edge is the first direct call.
    2615                 :            :                      create and duplicate call summaries for multiple
    2616                 :            :                      speculative call targets.  */
    2617                 :          0 :                   for (cgraph_edge *direct
    2618                 :          0 :                          = edge->next_speculative_call_target ();
    2619                 :          0 :                        direct;
    2620                 :          0 :                        direct = direct->next_speculative_call_target ())
    2621                 :            :                     {
    2622                 :          0 :                       ipa_call_summary *es3
    2623                 :          0 :                         = ipa_call_summaries->get_create (direct);
    2624                 :          0 :                       ipa_call_summaries->duplicate (edge, direct,
    2625                 :          0 :                                                      es, es3);
    2626                 :            :                     }
    2627                 :            :                 }
    2628                 :            :             }
    2629                 :            : 
    2630                 :            :           /* TODO: When conditional jump or switch is known to be constant, but
    2631                 :            :              we did not translate it into the predicates, we really can account
    2632                 :            :              just maximum of the possible paths.  */
    2633                 :   91405000 :           if (fbi.info)
    2634                 :   77948100 :             will_be_nonconstant
    2635                 :            :               = will_be_nonconstant_predicate (&fbi, info, params_summary,
    2636                 :   77948100 :                                                stmt, nonconstant_names);
    2637                 :            :           else
    2638                 :   13456900 :             will_be_nonconstant = true;
    2639                 :   91405000 :           if (this_time || this_size)
    2640                 :            :             {
    2641                 :   72924700 :               sreal final_time = (sreal)this_time * freq;
    2642                 :            : 
    2643                 :   72924700 :               prob = eliminated_by_inlining_prob (&fbi, stmt);
    2644                 :   72924700 :               if (prob == 1 && dump_file && (dump_flags & TDF_DETAILS))
    2645                 :         11 :                 fprintf (dump_file,
    2646                 :            :                          "\t\t50%% will be eliminated by inlining\n");
    2647                 :   72924700 :               if (prob == 2 && dump_file && (dump_flags & TDF_DETAILS))
    2648                 :         17 :                 fprintf (dump_file, "\t\tWill be eliminated by inlining\n");
    2649                 :            : 
    2650                 :   72924700 :               class predicate p = bb_predicate & will_be_nonconstant;
    2651                 :            : 
    2652                 :            :               /* We can ignore statement when we proved it is never going
    2653                 :            :                  to happen, but we cannot do that for call statements
    2654                 :            :                  because edges are accounted specially.  */
    2655                 :            : 
    2656                 :  145849000 :               if (*(is_gimple_call (stmt) ? &bb_predicate : &p) != false)
    2657                 :            :                 {
    2658                 :   72529100 :                   time += final_time;
    2659                 :   72529100 :                   size += this_size;
    2660                 :            :                 }
    2661                 :            : 
    2662                 :            :               /* We account everything but the calls.  Calls have their own
    2663                 :            :                  size/time info attached to cgraph edges.  This is necessary
    2664                 :            :                  in order to make the cost disappear after inlining.  */
    2665                 :   72924700 :               if (!is_gimple_call (stmt))
    2666                 :            :                 {
    2667                 :   58600200 :                   if (prob)
    2668                 :            :                     {
    2669                 :    9630280 :                       predicate ip = bb_predicate & predicate::not_inlined ();
    2670                 :   19260600 :                       info->account_size_time (this_size * prob,
    2671                 :   19260600 :                                                (final_time * prob) / 2, ip,
    2672                 :            :                                                p);
    2673                 :            :                     }
    2674                 :   58600200 :                   if (prob != 2)
    2675                 :  108334000 :                     info->account_size_time (this_size * (2 - prob),
    2676                 :  108334000 :                                              (final_time * (2 - prob) / 2),
    2677                 :            :                                              bb_predicate,
    2678                 :            :                                              p);
    2679                 :            :                 }
    2680                 :            : 
    2681                 :   72924700 :               if (!info->fp_expressions && fp_expression_p (stmt))
    2682                 :            :                 {
    2683                 :     308456 :                   info->fp_expressions = true;
    2684                 :     308456 :                   if (dump_file)
    2685                 :          9 :                     fprintf (dump_file, "   fp_expression set\n");
    2686                 :            :                 }
    2687                 :            :             }
    2688                 :            : 
    2689                 :            :           /* Account cost of address calculations in the statements.  */
    2690                 :  345483000 :           for (unsigned int i = 0; i < gimple_num_ops (stmt); i++)
    2691                 :            :             {
    2692                 :  254078000 :               for (tree op = gimple_op (stmt, i);
    2693                 :  490158000 :                    op && handled_component_p (op);
    2694                 :   31488900 :                    op = TREE_OPERAND (op, 0))
    2695                 :   31488900 :                 if ((TREE_CODE (op) == ARRAY_REF
    2696                 :   31488900 :                      || TREE_CODE (op) == ARRAY_RANGE_REF)
    2697                 :   31488900 :                     && TREE_CODE (TREE_OPERAND (op, 1)) == SSA_NAME)
    2698                 :            :                   {
    2699                 :    1661580 :                     predicate p = bb_predicate;
    2700                 :    1661580 :                     if (fbi.info)
    2701                 :    1320360 :                       p = p & will_be_nonconstant_expr_predicate
    2702                 :    1320360 :                                  (&fbi, info, params_summary,
    2703                 :    1320360 :                                   TREE_OPERAND (op, 1),
    2704                 :    1320360 :                                   nonconstant_names);
    2705                 :    1661580 :                     if (p != false)
    2706                 :            :                       {
    2707                 :    1657000 :                         time += freq;
    2708                 :    1657000 :                         size += 1;
    2709                 :    1657000 :                         if (dump_file)
    2710                 :         25 :                           fprintf (dump_file,
    2711                 :            :                                    "\t\tAccounting address calculation.\n");
    2712                 :    1657000 :                         info->account_size_time (ipa_fn_summary::size_scale,
    2713                 :            :                                                  freq,
    2714                 :            :                                                  bb_predicate,
    2715                 :            :                                                  p);
    2716                 :            :                       }
    2717                 :            :                   }
    2718                 :            :             }
    2719                 :            : 
    2720                 :            :         }
    2721                 :            :     }
    2722                 :    4618960 :   free (order);
    2723                 :            : 
    2724                 :    4618960 :   if (nonconstant_names.exists () && !early)
    2725                 :            :     {
    2726                 :     893397 :       class loop *loop;
    2727                 :     893397 :       predicate loop_iterations = true;
    2728                 :     893397 :       predicate loop_stride = true;
    2729                 :            : 
    2730                 :     893397 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2731                 :         14 :         flow_loops_dump (dump_file, NULL, 0);
    2732                 :     893397 :       scev_initialize ();
    2733                 :    1278250 :       FOR_EACH_LOOP (loop, 0)
    2734                 :            :         {
    2735                 :     384855 :           vec<edge> exits;
    2736                 :     384855 :           edge ex;
    2737                 :     384855 :           unsigned int j;
    2738                 :     384855 :           class tree_niter_desc niter_desc;
    2739                 :     384855 :           bb_predicate = *(predicate *) loop->header->aux;
    2740                 :            : 
    2741                 :     384855 :           exits = get_loop_exit_edges (loop);
    2742                 :    1083130 :           FOR_EACH_VEC_ELT (exits, j, ex)
    2743                 :     698276 :             if (number_of_iterations_exit (loop, ex, &niter_desc, false)
    2744                 :     698276 :                 && !is_gimple_min_invariant (niter_desc.niter))
    2745                 :            :             {
    2746                 :     107151 :               predicate will_be_nonconstant
    2747                 :            :                 = will_be_nonconstant_expr_predicate (&fbi, info,
    2748                 :            :                                                       params_summary,
    2749                 :            :                                                       niter_desc.niter,
    2750                 :     107151 :                                                       nonconstant_names);
    2751                 :     107151 :               if (will_be_nonconstant != true)
    2752                 :      44451 :                 will_be_nonconstant = bb_predicate & will_be_nonconstant;
    2753                 :     107151 :               if (will_be_nonconstant != true
    2754                 :     151602 :                   && will_be_nonconstant != false)
    2755                 :            :                 /* This is slightly inprecise.  We may want to represent each
    2756                 :            :                    loop with independent predicate.  */
    2757                 :      44148 :                 loop_iterations &= will_be_nonconstant;
    2758                 :            :             }
    2759                 :     765676 :           exits.release ();
    2760                 :            :         }
    2761                 :            : 
    2762                 :            :       /* To avoid quadratic behavior we analyze stride predicates only
    2763                 :            :          with respect to the containing loop.  Thus we simply iterate
    2764                 :            :          over all defs in the outermost loop body.  */
    2765                 :     893397 :       for (loop = loops_for_fn (cfun)->tree_root->inner;
    2766                 :    1186560 :            loop != NULL; loop = loop->next)
    2767                 :            :         {
    2768                 :     293165 :           basic_block *body = get_loop_body (loop);
    2769                 :    1921820 :           for (unsigned i = 0; i < loop->num_nodes; i++)
    2770                 :            :             {
    2771                 :    1628650 :               gimple_stmt_iterator gsi;
    2772                 :    1628650 :               bb_predicate = *(predicate *) body[i]->aux;
    2773                 :   10639400 :               for (gsi = gsi_start_bb (body[i]); !gsi_end_p (gsi);
    2774                 :    7382130 :                    gsi_next (&gsi))
    2775                 :            :                 {
    2776                 :    7382130 :                   gimple *stmt = gsi_stmt (gsi);
    2777                 :            : 
    2778                 :    7382130 :                   if (!is_gimple_assign (stmt))
    2779                 :    7283080 :                     continue;
    2780                 :            : 
    2781                 :    3570740 :                   tree def = gimple_assign_lhs (stmt);
    2782                 :    3570740 :                   if (TREE_CODE (def) != SSA_NAME)
    2783                 :     746397 :                     continue;
    2784                 :            : 
    2785                 :    2824350 :                   affine_iv iv;
    2786                 :    5648690 :                   if (!simple_iv (loop_containing_stmt (stmt),
    2787                 :            :                                   loop_containing_stmt (stmt),
    2788                 :            :                                   def, &iv, true)
    2789                 :    2824350 :                       || is_gimple_min_invariant (iv.step))
    2790                 :    2725300 :                     continue;
    2791                 :            : 
    2792                 :      99051 :                   predicate will_be_nonconstant
    2793                 :            :                     = will_be_nonconstant_expr_predicate (&fbi, info,
    2794                 :            :                                                           params_summary,
    2795                 :            :                                                           iv.step,
    2796                 :      99051 :                                                           nonconstant_names);
    2797                 :      99051 :                   if (will_be_nonconstant != true)
    2798                 :      32377 :                     will_be_nonconstant = bb_predicate & will_be_nonconstant;
    2799                 :      99051 :                   if (will_be_nonconstant != true
    2800                 :     131428 :                       && will_be_nonconstant != false)
    2801                 :            :                     /* This is slightly inprecise.  We may want to represent
    2802                 :            :                        each loop with independent predicate.  */
    2803                 :      14043 :                     loop_stride = loop_stride & will_be_nonconstant;
    2804                 :            :                 }
    2805                 :            :             }
    2806                 :     293165 :           free (body);
    2807                 :            :         }
    2808                 :     893397 :       ipa_fn_summary *s = ipa_fn_summaries->get (node);
    2809                 :     893397 :       set_hint_predicate (&s->loop_iterations, loop_iterations);
    2810                 :     893397 :       set_hint_predicate (&s->loop_stride, loop_stride);
    2811                 :     893397 :       scev_finalize ();
    2812                 :            :     }
    2813                 :   41167800 :   FOR_ALL_BB_FN (bb, my_function)
    2814                 :            :     {
    2815                 :   36548900 :       edge e;
    2816                 :   36548900 :       edge_iterator ei;
    2817                 :            : 
    2818                 :   36548900 :       if (bb->aux)
    2819                 :   27354100 :         edge_predicate_pool.remove ((predicate *)bb->aux);
    2820                 :   36548900 :       bb->aux = NULL;
    2821                 :   78305600 :       FOR_EACH_EDGE (e, ei, bb->succs)
    2822                 :            :         {
    2823                 :   41756800 :           if (e->aux)
    2824                 :    1351100 :             edge_predicate_pool.remove ((predicate *) e->aux);
    2825                 :   41756800 :           e->aux = NULL;
    2826                 :            :         }
    2827                 :            :     }
    2828                 :    4618960 :   ipa_fn_summary *s = ipa_fn_summaries->get (node);
    2829                 :    4618960 :   ipa_size_summary *ss = ipa_size_summaries->get (node);
    2830                 :    4618960 :   s->time = time;
    2831                 :    4618960 :   ss->self_size = size;
    2832                 :    4618960 :   nonconstant_names.release ();
    2833                 :    4618960 :   ipa_release_body_info (&fbi);
    2834                 :    4618960 :   if (opt_for_fn (node->decl, optimize))
    2835                 :            :     {
    2836                 :    4097720 :       if (!early)
    2837                 :     893397 :         loop_optimizer_finalize ();
    2838                 :    3204320 :       else if (!ipa_edge_args_sum)
    2839                 :    3204310 :         ipa_free_all_node_params ();
    2840                 :    4097720 :       free_dominance_info (CDI_DOMINATORS);
    2841                 :    4097720 :       free_dominance_info (CDI_POST_DOMINATORS);
    2842                 :            :     }
    2843                 :    4618960 :   if (dump_file)
    2844                 :            :     {
    2845                 :        235 :       fprintf (dump_file, "\n");
    2846                 :        235 :       ipa_dump_fn_summary (dump_file, node);
    2847                 :            :     }
    2848                 :    4618960 : }
    2849                 :            : 
    2850                 :            : 
    2851                 :            : /* Compute function summary.
    2852                 :            :    EARLY is true when we compute parameters during early opts.  */
    2853                 :            : 
    2854                 :            : void
    2855                 :    4620110 : compute_fn_summary (struct cgraph_node *node, bool early)
    2856                 :            : {
    2857                 :    4620110 :   HOST_WIDE_INT self_stack_size;
    2858                 :    4620110 :   struct cgraph_edge *e;
    2859                 :            : 
    2860                 :    4620110 :   gcc_assert (!node->inlined_to);
    2861                 :            : 
    2862                 :    4620110 :   if (!ipa_fn_summaries)
    2863                 :     151548 :     ipa_fn_summary_alloc ();
    2864                 :            : 
    2865                 :            :   /* Create a new ipa_fn_summary.  */
    2866                 :    4620110 :   ((ipa_fn_summary_t *)ipa_fn_summaries)->remove_callees (node);
    2867                 :    4620110 :   ipa_fn_summaries->remove (node);
    2868                 :    4620110 :   class ipa_fn_summary *info = ipa_fn_summaries->get_create (node);
    2869                 :    4620110 :   class ipa_size_summary *size_info = ipa_size_summaries->get_create (node);
    2870                 :            : 
    2871                 :            :   /* Estimate the stack size for the function if we're optimizing.  */
    2872                 :    4098840 :   self_stack_size = optimize && !node->thunk.thunk_p
    2873                 :    8717830 :                     ? estimated_stack_frame_size (node) : 0;
    2874                 :    4620110 :   size_info->estimated_self_stack_size = self_stack_size;
    2875                 :    4620110 :   info->estimated_stack_size = self_stack_size;
    2876                 :            : 
    2877                 :    4620110 :   if (node->thunk.thunk_p)
    2878                 :            :     {
    2879                 :       1149 :       ipa_call_summary *es = ipa_call_summaries->get_create (node->callees);
    2880                 :       1149 :       predicate t = true;
    2881                 :            : 
    2882                 :       1149 :       node->can_change_signature = false;
    2883                 :       1149 :       es->call_stmt_size = eni_size_weights.call_cost;
    2884                 :       1149 :       es->call_stmt_time = eni_time_weights.call_cost;
    2885                 :       5745 :       info->account_size_time (ipa_fn_summary::size_scale
    2886                 :       1149 :                                * opt_for_fn (node->decl,
    2887                 :            :                                  param_uninlined_function_thunk_insns),
    2888                 :       1149 :                                opt_for_fn (node->decl,
    2889                 :            :                                  param_uninlined_function_thunk_time), t, t);
    2890                 :       1149 :       t = predicate::not_inlined ();
    2891                 :       1149 :       info->account_size_time (2 * ipa_fn_summary::size_scale, 0, t, t);
    2892                 :       1149 :       ipa_update_overall_fn_summary (node);
    2893                 :       1149 :       size_info->self_size = size_info->size;
    2894                 :       1149 :       if (stdarg_p (TREE_TYPE (node->decl)))
    2895                 :            :         {
    2896                 :         10 :           info->inlinable = false;
    2897                 :         10 :           node->callees->inline_failed = CIF_VARIADIC_THUNK;
    2898                 :            :         }
    2899                 :            :       else
    2900                 :       1139 :         info->inlinable = true;
    2901                 :            :     }
    2902                 :            :   else
    2903                 :            :     {
    2904                 :            :        /* Even is_gimple_min_invariant rely on current_function_decl.  */
    2905                 :    4618960 :        push_cfun (DECL_STRUCT_FUNCTION (node->decl));
    2906                 :            : 
    2907                 :            :        /* During IPA profile merging we may be called w/o virtual SSA form
    2908                 :            :           built.  */
    2909                 :    4618960 :        update_ssa (TODO_update_ssa_only_virtuals);
    2910                 :            : 
    2911                 :            :        /* Can this function be inlined at all?  */
    2912                 :    4618960 :        if (!opt_for_fn (node->decl, optimize)
    2913                 :    5140210 :            && !lookup_attribute ("always_inline",
    2914                 :     521247 :                                  DECL_ATTRIBUTES (node->decl)))
    2915                 :     485204 :          info->inlinable = false;
    2916                 :            :        else
    2917                 :    4133760 :          info->inlinable = tree_inlinable_function_p (node->decl);
    2918                 :            : 
    2919                 :            :        /* Type attributes can use parameter indices to describe them.  */
    2920                 :    4618960 :        if (TYPE_ATTRIBUTES (TREE_TYPE (node->decl))
    2921                 :            :            /* Likewise for #pragma omp declare simd functions or functions
    2922                 :            :               with simd attribute.  */
    2923                 :    9012760 :            || lookup_attribute ("omp declare simd",
    2924                 :    4393800 :                                 DECL_ATTRIBUTES (node->decl)))
    2925                 :     226274 :          node->can_change_signature = false;
    2926                 :            :        else
    2927                 :            :          {
    2928                 :            :            /* Otherwise, inlinable functions always can change signature.  */
    2929                 :    4392690 :            if (info->inlinable)
    2930                 :    3495950 :              node->can_change_signature = true;
    2931                 :            :            else
    2932                 :            :              {
    2933                 :            :                /* Functions calling builtin_apply cannot change signature.  */
    2934                 :    3531580 :                for (e = node->callees; e; e = e->next_callee)
    2935                 :            :                  {
    2936                 :    2655440 :                    tree cdecl = e->callee->decl;
    2937                 :    2655440 :                    if (fndecl_built_in_p (cdecl, BUILT_IN_APPLY_ARGS)
    2938                 :    2655440 :                        || fndecl_built_in_p (cdecl, BUILT_IN_VA_START))
    2939                 :            :                      break;
    2940                 :            :                  }
    2941                 :     896736 :                node->can_change_signature = !e;
    2942                 :            :              }
    2943                 :            :          }
    2944                 :    4618960 :        analyze_function_body (node, early);
    2945                 :    4618960 :        pop_cfun ();
    2946                 :            :      }
    2947                 :            : 
    2948                 :            :   /* Inlining characteristics are maintained by the cgraph_mark_inline.  */
    2949                 :    4620110 :   size_info->size = size_info->self_size;
    2950                 :    4620110 :   info->estimated_stack_size = size_info->estimated_self_stack_size;
    2951                 :            : 
    2952                 :            :   /* Code above should compute exactly the same result as
    2953                 :            :      ipa_update_overall_fn_summary but because computation happens in
    2954                 :            :      different order the roundoff errors result in slight changes.  */
    2955                 :    4620110 :   ipa_update_overall_fn_summary (node);
    2956                 :            :   /* In LTO mode we may have speculative edges set.  */
    2957                 :    4620110 :   gcc_assert (in_lto_p || size_info->size == size_info->self_size);
    2958                 :    4620110 : }
    2959                 :            : 
    2960                 :            : 
    2961                 :            : /* Compute parameters of functions used by inliner using
    2962                 :            :    current_function_decl.  */
    2963                 :            : 
    2964                 :            : static unsigned int
    2965                 :    3694450 : compute_fn_summary_for_current (void)
    2966                 :            : {
    2967                 :    3694450 :   compute_fn_summary (cgraph_node::get (current_function_decl), true);
    2968                 :    3694450 :   return 0;
    2969                 :            : }
    2970                 :            : 
    2971                 :            : /* Estimate benefit devirtualizing indirect edge IE, provided KNOWN_VALS,
    2972                 :            :    KNOWN_CONTEXTS and KNOWN_AGGS.  */
    2973                 :            : 
    2974                 :            : static bool
    2975                 :     117353 : estimate_edge_devirt_benefit (struct cgraph_edge *ie,
    2976                 :            :                               int *size, int *time,
    2977                 :            :                               vec<tree> known_vals,
    2978                 :            :                               vec<ipa_polymorphic_call_context> known_contexts,
    2979                 :            :                               vec<ipa_agg_value_set> known_aggs)
    2980                 :            : {
    2981                 :     117353 :   tree target;
    2982                 :     117353 :   struct cgraph_node *callee;
    2983                 :     117353 :   class ipa_fn_summary *isummary;
    2984                 :     117353 :   enum availability avail;
    2985                 :     117353 :   bool speculative;
    2986                 :            : 
    2987                 :     117353 :   if (!known_vals.length () && !known_contexts.length ())
    2988                 :            :     return false;
    2989                 :      96514 :   if (!opt_for_fn (ie->caller->decl, flag_indirect_inlining))
    2990                 :            :     return false;
    2991                 :            : 
    2992                 :      96493 :   target = ipa_get_indirect_edge_target (ie, known_vals, known_contexts,
    2993                 :            :                                          known_aggs, &speculative);
    2994                 :      96493 :   if (!target || speculative)
    2995                 :            :     return false;
    2996                 :            : 
    2997                 :            :   /* Account for difference in cost between indirect and direct calls.  */
    2998                 :      11015 :   *size -= (eni_size_weights.indirect_call_cost - eni_size_weights.call_cost);
    2999                 :      11015 :   *time -= (eni_time_weights.indirect_call_cost - eni_time_weights.call_cost);
    3000                 :      11015 :   gcc_checking_assert (*time >= 0);
    3001                 :      11015 :   gcc_checking_assert (*size >= 0);
    3002                 :            : 
    3003                 :      11015 :   callee = cgraph_node::get (target);
    3004                 :      11015 :   if (!callee || !callee->definition)
    3005                 :            :     return false;
    3006                 :       4523 :   callee = callee->function_symbol (&avail);
    3007                 :       4523 :   if (avail < AVAIL_AVAILABLE)
    3008                 :            :     return false;
    3009                 :       4523 :   isummary = ipa_fn_summaries->get (callee);
    3010                 :       4519 :   if (isummary == NULL)
    3011                 :            :     return false;
    3012                 :            : 
    3013                 :       4519 :   return isummary->inlinable;
    3014                 :            : }
    3015                 :            : 
    3016                 :            : /* Increase SIZE, MIN_SIZE (if non-NULL) and TIME for size and time needed to
    3017                 :            :    handle edge E with probability PROB.
    3018                 :            :    Set HINTS if edge may be devirtualized.
    3019                 :            :    KNOWN_VALS, KNOWN_AGGS and KNOWN_CONTEXTS describe context of the call
    3020                 :            :    site.  */
    3021                 :            : 
    3022                 :            : static inline void
    3023                 :   57006500 : estimate_edge_size_and_time (struct cgraph_edge *e, int *size, int *min_size,
    3024                 :            :                              sreal *time,
    3025                 :            :                              vec<tree> known_vals,
    3026                 :            :                              vec<ipa_polymorphic_call_context> known_contexts,
    3027                 :            :                              vec<ipa_agg_value_set> known_aggs,
    3028                 :            :                              ipa_hints *hints)
    3029                 :            : {
    3030                 :   57006500 :   class ipa_call_summary *es = ipa_call_summaries->get (e);
    3031                 :   57006500 :   int call_size = es->call_stmt_size;
    3032                 :   57006500 :   int call_time = es->call_stmt_time;
    3033                 :   57006500 :   int cur_size;
    3034                 :            : 
    3035                 :    1765020 :   if (!e->callee && hints && e->maybe_hot_p ()
    3036                 :   57123900 :       && estimate_edge_devirt_benefit (e, &call_size, &call_time,
    3037                 :            :                                        known_vals, known_contexts, known_aggs))
    3038                 :       4481 :     *hints |= INLINE_HINT_indirect_call;
    3039                 :   57006500 :   cur_size = call_size * ipa_fn_summary::size_scale;
    3040                 :   57006500 :   *size += cur_size;
    3041                 :   57006500 :   if (min_size)
    3042                 :   15631200 :     *min_size += cur_size;
    3043                 :   57006500 :   if (time)
    3044                 :   51661300 :     *time += ((sreal)call_time) * e->sreal_frequency ();
    3045                 :   57006500 : }
    3046                 :            : 
    3047                 :            : 
    3048                 :            : /* Increase SIZE, MIN_SIZE and TIME for size and time needed to handle all
    3049                 :            :    calls in NODE.  POSSIBLE_TRUTHS, KNOWN_VALS, KNOWN_AGGS and KNOWN_CONTEXTS
    3050                 :            :    describe context of the call site.
    3051                 :            :  
    3052                 :            :    Helper for estimate_calls_size_and_time which does the same but
    3053                 :            :    (in most cases) faster.  */
    3054                 :            : 
    3055                 :            : static void
    3056                 :   18476200 : estimate_calls_size_and_time_1 (struct cgraph_node *node, int *size,
    3057                 :            :                                 int *min_size, sreal *time,
    3058                 :            :                                 ipa_hints *hints,
    3059                 :            :                                 clause_t possible_truths,
    3060                 :            :                                 vec<tree> known_vals,
    3061                 :            :                                 vec<ipa_polymorphic_call_context> known_contexts,
    3062                 :            :                                 vec<ipa_agg_value_set> known_aggs)
    3063                 :            : {
    3064                 :   18476200 :   struct cgraph_edge *e;
    3065                 :   77845100 :   for (e = node->callees; e; e = e->next_callee)
    3066                 :            :     {
    3067                 :   59369000 :       if (!e->inline_failed)
    3068                 :            :         {
    3069                 :    8668540 :           gcc_checking_assert (!ipa_call_summaries->get (e));
    3070                 :    8668540 :           estimate_calls_size_and_time_1 (e->callee, size, min_size, time,
    3071                 :            :                                           hints,
    3072                 :            :                                           possible_truths,
    3073                 :            :                                           known_vals, known_contexts,
    3074                 :            :                                           known_aggs);
    3075                 :    8668540 :           continue;
    3076                 :            :         }
    3077                 :   50700400 :       class ipa_call_summary *es = ipa_call_summaries->get (e);
    3078                 :            : 
    3079                 :            :       /* Do not care about zero sized builtins.  */
    3080                 :   50700400 :       if (!es->call_stmt_size)
    3081                 :            :         {
    3082                 :    1357470 :           gcc_checking_assert (!es->call_stmt_time);
    3083                 :    1357470 :           continue;
    3084                 :            :         }
    3085                 :   49343000 :       if (!es->predicate
    3086                 :   49343000 :           || es->predicate->evaluate (possible_truths))
    3087                 :            :         {
    3088                 :            :           /* Predicates of calls shall not use NOT_CHANGED codes,
    3089                 :            :              so we do not need to compute probabilities.  */
    3090                 :   48810400 :           estimate_edge_size_and_time (e, size,
    3091                 :   48810400 :                                        es->predicate ? NULL : min_size,
    3092                 :            :                                        time,
    3093                 :            :                                        known_vals, known_contexts,
    3094                 :            :                                        known_aggs, hints);
    3095                 :            :         }
    3096                 :            :     }
    3097                 :   20067100 :   for (e = node->indirect_calls; e; e = e->next_callee)
    3098                 :            :     {
    3099                 :    1590920 :       class ipa_call_summary *es = ipa_call_summaries->get (e);
    3100                 :    1590920 :       if (!es->predicate
    3101                 :    1590920 :           || es->predicate->evaluate (possible_truths))
    3102                 :    1576860 :         estimate_edge_size_and_time (e, size,
    3103                 :    1576860 :                                      es->predicate ? NULL : min_size,
    3104                 :            :                                      time,
    3105                 :            :                                      known_vals, known_contexts, known_aggs,
    3106                 :            :                                      hints);
    3107                 :            :     }
    3108                 :   18476200 : }
    3109                 :            : 
    3110                 :            : /* Populate sum->call_size_time_table for edges from NODE.  */
    3111                 :            : 
    3112                 :            : static void
    3113                 :    1799240 : summarize_calls_size_and_time (struct cgraph_node *node,
    3114                 :            :                                ipa_fn_summary *sum)
    3115                 :            : {
    3116                 :    1799240 :   struct cgraph_edge *e;
    3117                 :    8257240 :   for (e = node->callees; e; e = e->next_callee)
    3118                 :            :     {
    3119                 :    6458010 :       if (!e->inline_failed)
    3120                 :            :         {
    3121                 :     490807 :           gcc_checking_assert (!ipa_call_summaries->get (e));
    3122                 :     490807 :           summarize_calls_size_and_time (e->callee, sum);
    3123                 :     490807 :           continue;
    3124                 :            :         }
    3125                 :    5967200 :       int size = 0;
    3126                 :    5967200 :       sreal time = 0;
    3127                 :            : 
    3128                 :    5967200 :       estimate_edge_size_and_time (e, &size, NULL, &time,
    3129                 :            :                                    vNULL, vNULL, vNULL, NULL);
    3130                 :            : 
    3131                 :    5967200 :       struct predicate pred = true;
    3132                 :    5967200 :       class ipa_call_summary *es = ipa_call_summaries->get (e);
    3133                 :            : 
    3134                 :    5967200 :       if (es->predicate)
    3135                 :     730246 :         pred = *es->predicate;
    3136                 :    5967200 :       sum->account_size_time (size, time, pred, pred, true);
    3137                 :            :     }
    3138                 :    1987400 :   for (e = node->indirect_calls; e; e = e->next_callee)
    3139                 :            :     {
    3140                 :     188161 :       int size = 0;
    3141                 :     188161 :       sreal time = 0;
    3142                 :            : 
    3143                 :     188161 :       estimate_edge_size_and_time (e, &size, NULL, &time,
    3144                 :            :                                    vNULL, vNULL, vNULL, NULL);
    3145                 :     188161 :       struct predicate pred = true;
    3146                 :     188161 :       class ipa_call_summary *es = ipa_call_summaries->get (e);
    3147                 :            : 
    3148                 :     188161 :       if (es->predicate)
    3149                 :      24590 :         pred = *es->predicate;
    3150                 :     188161 :       sum->account_size_time (size, time, pred, pred, true);
    3151                 :            :     }
    3152                 :    1799240 : }
    3153                 :            : 
    3154                 :            : /* Increase SIZE, MIN_SIZE and TIME for size and time needed to handle all
    3155                 :            :    calls in NODE.  POSSIBLE_TRUTHS, KNOWN_VALS, KNOWN_AGGS and KNOWN_CONTEXTS
    3156                 :            :    describe context of the call site.  */
    3157                 :            : 
    3158                 :            : static void
    3159                 :    9807650 : estimate_calls_size_and_time (struct cgraph_node *node, int *size,
    3160                 :            :                               int *min_size, sreal *time,
    3161                 :            :                               ipa_hints *hints,
    3162                 :            :                               clause_t possible_truths,
    3163                 :            :                               vec<tree> known_vals,
    3164                 :            :                               vec<ipa_polymorphic_call_context> known_contexts,
    3165                 :            :                               vec<ipa_agg_value_set> known_aggs)
    3166                 :            : {
    3167                 :    9807650 :   class ipa_fn_summary *sum = ipa_fn_summaries->get (node);
    3168                 :    9807650 :   bool use_table = true;
    3169                 :            : 
    3170                 :    9807650 :   gcc_assert (node->callees || node->indirect_calls);
    3171                 :            : 
    3172                 :            :   /* During early inlining we do not calculate info for very
    3173                 :            :      large functions and thus there is no need for producing
    3174                 :            :      summaries.  */
    3175                 :    9807650 :   if (!ipa_node_params_sum)
    3176                 :            :     use_table = false;
    3177                 :            :   /* Do not calculate summaries for simple wrappers; it is waste
    3178                 :            :      of memory.  */
    3179                 :    4604420 :   else if (node->callees && node->indirect_calls
    3180                 :     253889 :            && node->callees->inline_failed && !node->callees->next_callee)
    3181                 :            :     use_table = false;
    3182                 :            :   /* If there is an indirect edge that may be optimized, we need
    3183                 :            :      to go the slow way.  */
    3184                 :    4552380 :   else if ((known_vals.length ()
    3185                 :    3081590 :             || known_contexts.length ()
    3186                 :    6385880 :             || known_aggs.length ()) && hints)
    3187                 :            :     {
    3188                 :    1126130 :       class ipa_node_params *params_summary = IPA_NODE_REF (node);
    3189                 :          0 :       unsigned int nargs = params_summary
    3190                 :    1126130 :                            ? ipa_get_param_count (params_summary) : 0;
    3191                 :            : 
    3192                 :    3319900 :       for (unsigned int i = 0; i < nargs && use_table; i++)
    3193                 :            :         {
    3194                 :    2193770 :           if (ipa_is_param_used_by_indirect_call (params_summary, i)
    3195                 :    2270450 :               && ((known_vals.length () > i && known_vals[i])
    3196                 :      60134 :                   || (known_aggs.length () > i
    3197                 :       1814 :                       && known_aggs[i].items.length ())))
    3198                 :            :             use_table = false;
    3199                 :    2146360 :           else if (ipa_is_param_used_by_polymorphic_call (params_summary, i)
    3200                 :    2175030 :                    && (known_contexts.length () > i
    3201                 :      28662 :                        && !known_contexts[i].useless_p ()))
    3202                 :            :             use_table = false;
    3203                 :            :         }
    3204                 :            :     }
    3205                 :            : 
    3206                 :            :   /* Fast path is via the call size time table.  */
    3207                 :    1126130 :   if (use_table)
    3208                 :            :     {
    3209                 :            :       /* Build summary if it is absent.  */
    3210                 :    4476560 :       if (!sum->call_size_time_table)
    3211                 :            :         {
    3212                 :     844586 :           predicate true_pred = true;
    3213                 :     844586 :           sum->account_size_time (0, 0, true_pred, true_pred, true);
    3214                 :     844586 :           summarize_calls_size_and_time (node, sum);
    3215                 :            :         }
    3216                 :            : 
    3217                 :    4476560 :       int old_size = *size;
    3218                 :    4476560 :       sreal old_time = time ? *time : 0;
    3219                 :            : 
    3220                 :    4476560 :       if (min_size)
    3221                 :    4476560 :         *min_size += (*sum->call_size_time_table)[0].size;
    3222                 :            : 
    3223                 :            :       unsigned int i;
    3224                 :            :       size_time_entry *e;
    3225                 :            : 
    3226                 :            :       /* Walk the table and account sizes and times.  */
    3227                 :   11066200 :       for (i = 0; vec_safe_iterate (sum->call_size_time_table, i, &e);
    3228                 :            :            i++)
    3229                 :    6589620 :         if (e->exec_predicate.evaluate (possible_truths))
    3230                 :            :           {
    3231                 :    6289710 :             *size += e->size;
    3232                 :    6289710 :             if (time)
    3233                 :    6589620 :               *time += e->time;
    3234                 :            :           }
    3235                 :            : 
    3236                 :            :       /* Be careful and see if both methods agree.  */
    3237                 :          4 :       if ((flag_checking || dump_file)
    3238                 :            :           /* Do not try to sanity check when we know we lost some
    3239                 :            :              precision.  */
    3240                 :    4476560 :           && sum->call_size_time_table->length ()
    3241                 :            :              < ipa_fn_summary::max_size_time_table_size)
    3242                 :            :         {
    3243                 :    4476560 :           estimate_calls_size_and_time_1 (node, &old_size, NULL, &old_time, NULL,
    3244                 :            :                                           possible_truths, known_vals,
    3245                 :            :                                           known_contexts, known_aggs);
    3246                 :    4476560 :           gcc_assert (*size == old_size);
    3247                 :   11189000 :           if (time && (*time - old_time > 1 || *time - old_time < -1)
    3248                 :    4476600 :               && dump_file)
    3249                 :          3 :             fprintf (dump_file, "Time mismatch in call summary %f!=%f\n",
    3250                 :            :                      old_time.to_double (),
    3251                 :            :                      time->to_double ());
    3252                 :            :         }
    3253                 :            :     }
    3254                 :            :   /* Slow path by walking all edges.  */
    3255                 :            :   else
    3256                 :    5331090 :     estimate_calls_size_and_time_1 (node, size, min_size, time, hints,
    3257                 :            :                                     possible_truths, known_vals, known_contexts,
    3258                 :            :                                     known_aggs);
    3259                 :    9807650 : }
    3260                 :            : 
    3261                 :            : /* Default constructor for ipa call context.
    3262                 :            :    Memory allocation of known_vals, known_contexts
    3263                 :            :    and known_aggs vectors is owned by the caller, but can
    3264                 :            :    be release by ipa_call_context::release.  
    3265                 :            :    
    3266                 :            :    inline_param_summary is owned by the caller.  */
    3267                 :    9944480 : ipa_call_context::ipa_call_context (cgraph_node *node,
    3268                 :            :                                     clause_t possible_truths,
    3269                 :            :                                     clause_t nonspec_possible_truths,
    3270                 :            :                                     vec<tree> known_vals,
    3271                 :            :                                     vec<ipa_polymorphic_call_context>
    3272                 :            :                                          known_contexts,
    3273                 :            :                                     vec<ipa_agg_value_set> known_aggs,
    3274                 :            :                                     vec<inline_param_summary>
    3275                 :    9944480 :                                          inline_param_summary)
    3276                 :            : : m_node (node), m_possible_truths (possible_truths),
    3277                 :            :   m_nonspec_possible_truths (nonspec_possible_truths),
    3278                 :            :   m_inline_param_summary (inline_param_summary),
    3279                 :            :   m_known_vals (known_vals),
    3280                 :            :   m_known_contexts (known_contexts),
    3281                 :    9944480 :   m_known_aggs (known_aggs)
    3282                 :            : {
    3283                 :    9944480 : }
    3284                 :            : 
    3285                 :            : /* Set THIS to be a duplicate of CTX.  Copy all relevant info.  */
    3286                 :            : 
    3287                 :            : void
    3288                 :     529303 : ipa_call_context::duplicate_from (const ipa_call_context &ctx)
    3289                 :            : {
    3290                 :     529303 :   m_node = ctx.m_node;
    3291                 :     529303 :   m_possible_truths = ctx.m_possible_truths;
    3292                 :     529303 :   m_nonspec_possible_truths = ctx.m_nonspec_possible_truths;
    3293                 :     529303 :   class ipa_node_params *params_summary = IPA_NODE_REF (m_node);
    3294                 :        116 :   unsigned int nargs = params_summary
    3295                 :     529187 :                        ? ipa_get_param_count (params_summary) : 0;
    3296                 :            : 
    3297                 :     529303 :   m_inline_param_summary = vNULL;
    3298                 :            :   /* Copy the info only if there is at least one useful entry.  */
    3299                 :     529303 :   if (ctx.m_inline_param_summary.exists ())
    3300                 :            :     {
    3301                 :     498295 :       unsigned int n = MIN (ctx.m_inline_param_summary.length (), nargs);
    3302                 :            : 
    3303                 :    1194230 :       for (unsigned int i = 0; i < n; i++)
    3304                 :     918745 :         if (ipa_is_param_used_by_ipa_predicates (params_summary, i)
    3305                 :     918745 :             && !ctx.m_inline_param_summary[i].useless_p ())
    3306                 :            :           {
    3307                 :     222811 :             m_inline_param_summary
    3308                 :     222811 :                     = ctx.m_inline_param_summary.copy ();
    3309                 :     222811 :             break;
    3310                 :            :           }
    3311                 :            :     }
    3312                 :     529303 :   m_known_vals = vNULL;
    3313                 :     529303 :   if (ctx.m_known_vals.exists ())
    3314                 :            :     {
    3315                 :     529303 :       unsigned int n = MIN (ctx.m_known_vals.length (), nargs);
    3316                 :            : 
    3317                 :     968316 :       for (unsigned int i = 0; i < n; i++)
    3318                 :     447360 :         if (ipa_is_param_used_by_indirect_call (params_summary, i)
    3319                 :     447360 :             && ctx.m_known_vals[i])
    3320                 :            :           {
    3321                 :       8347 :             m_known_vals = ctx.m_known_vals.copy ();
    3322                 :       8347 :             break;
    3323                 :            :           }
    3324                 :            :     }
    3325                 :            : 
    3326                 :     529303 :   m_known_contexts = vNULL;
    3327                 :     529303 :   if (ctx.m_known_contexts.exists ())
    3328                 :            :     {
    3329                 :     529303 :       unsigned int n = MIN (ctx.m_known_contexts.length (), nargs);
    3330                 :            : 
    3331                 :     529601 :       for (unsigned int i = 0; i < n; i++)
    3332                 :      10361 :         if (ipa_is_param_used_by_polymorphic_call (params_summary, i)
    3333                 :      10361 :             && !ctx.m_known_contexts[i].useless_p ())
    3334                 :            :           {
    3335                 :      10063 :             m_known_contexts = ctx.m_known_contexts.copy ();
    3336                 :      10063 :             break;
    3337                 :            :           }
    3338                 :            :     }
    3339                 :            : 
    3340                 :     529303 :   m_known_aggs = vNULL;
    3341                 :     529303 :   if (ctx.m_known_aggs.exists ())
    3342                 :            :     {
    3343                 :     529303 :       unsigned int n = MIN (ctx.m_known_aggs.length (), nargs);
    3344                 :            : 
    3345                 :     595723 :       for (unsigned int i = 0; i < n; i++)
    3346                 :      67810 :         if (ipa_is_param_used_by_indirect_call (params_summary, i)
    3347                 :      67810 :             && !ctx.m_known_aggs[i].is_empty ())
    3348                 :            :           {
    3349                 :       1390 :             m_known_aggs = ipa_copy_agg_values (ctx.m_known_aggs);
    3350                 :       1390 :             break;
    3351                 :            :           }
    3352                 :            :     }
    3353                 :     529303 : }
    3354                 :            : 
    3355                 :            : /* Release memory used by known_vals/contexts/aggs vectors.
    3356                 :            :    If ALL is true release also inline_param_summary.
    3357                 :            :    This happens when context was previously duplicated to be stored
    3358                 :            :    into cache.  */
    3359                 :            : 
    3360                 :            : void
    3361                 :   11002200 : ipa_call_context::release (bool all)
    3362                 :            : {
    3363                 :            :   /* See if context is initialized at first place.  */
    3364                 :   11002200 :   if (!m_node)
    3365                 :            :     return;
    3366                 :   10350000 :   ipa_release_agg_values (m_known_aggs, all);
    3367                 :   10350000 :   if (all)
    3368                 :            :     {
    3369                 :     165826 :       m_known_vals.release ();
    3370                 :     165826 :       m_known_contexts.release ();
    3371                 :     165826 :       m_inline_param_summary.release ();
    3372                 :            :     }
    3373                 :            : }
    3374                 :            : 
    3375                 :            : /* Return true if CTX describes the same call context as THIS.  */
    3376                 :            : 
    3377                 :            : bool
    3378                 :    2294990 : ipa_call_context::equal_to (const ipa_call_context &ctx)
    3379                 :            : {
    3380                 :    2294990 :   if (m_node != ctx.m_node
    3381                 :            :       || m_possible_truths != ctx.m_possible_truths
    3382                 :    1931510 :       || m_nonspec_possible_truths != ctx.m_nonspec_possible_truths)
    3383                 :            :     return false;
    3384                 :            : 
    3385                 :    1826350 :   class ipa_node_params *params_summary = IPA_NODE_REF (m_node);
    3386                 :         47 :   unsigned int nargs = params_summary
    3387                 :    1826300 :                        ? ipa_get_param_count (params_summary) : 0;
    3388                 :            : 
    3389                 :    1826350 :   if (m_inline_param_summary.exists () || ctx.m_inline_param_summary.exists ())
    3390                 :            :     {
    3391                 :    4853180 :       for (unsigned int i = 0; i < nargs; i++)
    3392                 :            :         {
    3393                 :    3200140 :           if (!ipa_is_param_used_by_ipa_predicates (params_summary, i))
    3394                 :    1179720 :             continue;
    3395                 :    2020420 :           if (i >= m_inline_param_summary.length ()
    3396                 :    2020420 :               || m_inline_param_summary[i].useless_p ())
    3397                 :            :             {
    3398                 :     962046 :               if (i < ctx.m_inline_param_summary.length ()
    3399                 :     962046 :                   && !ctx.m_inline_param_summary[i].useless_p ())
    3400                 :            :                 return false;
    3401                 :     936597 :               continue;
    3402                 :            :             }
    3403                 :    1058380 :           if (i >= ctx.m_inline_param_summary.length ()
    3404                 :    1058380 :               || ctx.m_inline_param_summary[i].useless_p ())
    3405                 :            :             {
    3406                 :    2294990 :               if (i < m_inline_param_summary.length ()
    3407                 :    2294990 :                   && !m_inline_param_summary[i].useless_p ())
    3408                 :            :                 return false;
    3409                 :            :               continue;
    3410                 :            :             }
    3411                 :    1035960 :           if (!m_inline_param_summary[i].equal_to
    3412                 :    1035960 :                  (ctx.m_inline_param_summary[i]))
    3413                 :            :             return false;
    3414                 :            :         }
    3415                 :            :     }
    3416                 :    1769400 :   if (m_known_vals.exists () || ctx.m_known_vals.exists ())
    3417                 :            :     {
    3418                 :    4890520 :       for (unsigned int i = 0; i < nargs; i++)
    3419                 :            :         {
    3420                 :    3123860 :           if (!ipa_is_param_used_by_indirect_call (params_summary, i))
    3421                 :    3050980 :             continue;
    3422                 :     116118 :           if (i >= m_known_vals.length () || !m_known_vals[i])
    3423                 :            :             {
    3424                 :      59284 :               if (i < ctx.m_known_vals.length () && ctx.m_known_vals[i])
    3425                 :            :                 return false;
    3426                 :      29553 :               continue;
    3427                 :            :             }
    3428                 :      86476 :           if (i >= ctx.m_known_vals.length () || !ctx.m_known_vals[i])
    3429                 :            :             {
    3430                 :    2294990 :               if (i < m_known_vals.length () && m_known_vals[i])
    3431                 :            :                 return false;
    3432                 :            :               continue;
    3433                 :            :             }
    3434                 :      43160 :           if (m_known_vals[i] != ctx.m_known_vals[i])
    3435                 :            :             return false;
    3436                 :            :         }
    3437                 :            :     }
    3438                 :    1766670 :   if (m_known_contexts.exists () || ctx.m_known_contexts.exists ())
    3439                 :            :     {
    3440                 :    4886720 :       for (unsigned int i = 0; i < nargs; i++)
    3441                 :            :         {
    3442                 :    3120520 :           if (!ipa_is_param_used_by_polymorphic_call (params_summary, i))
    3443                 :    3093980 :             continue;
    3444                 :      26537 :           if (i >= m_known_contexts.length ()
    3445                 :      26537 :               || m_known_contexts[i].useless_p ())
    3446                 :            :             {
    3447                 :        145 :               if (i < ctx.m_known_contexts.length ()
    3448                 :        145 :                   && !ctx.m_known_contexts[i].useless_p ())
    3449                 :            :                 return false;
    3450                 :        129 :               continue;
    3451                 :            :             }
    3452                 :      26392 :           if (i >= ctx.m_known_contexts.length ()
    3453                 :      26392 :               || ctx.m_known_contexts[i].useless_p ())
    3454                 :            :             {
    3455                 :         16 :               if (i < m_known_contexts.length ()
    3456                 :         16 :                   && !m_known_contexts[i].useless_p ())
    3457                 :            :                 return false;
    3458                 :          0 :               continue;
    3459                 :            :             }
    3460                 :      26376 :           if (!m_known_contexts[i].equal_to
    3461                 :      26376 :                  (ctx.m_known_contexts[i]))
    3462                 :            :             return false;
    3463                 :            :         }
    3464                 :            :     }
    3465                 :    1766200 :   if (m_known_aggs.exists () || ctx.m_known_aggs.exists ())
    3466                 :            :     {
    3467                 :    4885560 :       for (unsigned int i = 0; i < nargs; i++)
    3468                 :            :         {
    3469                 :    3119880 :           if (!ipa_is_param_used_by_indirect_call (params_summary, i))
    3470                 :    3050230 :             continue;
    3471                 :      70781 :           if (i >= m_known_aggs.length () || m_known_aggs[i].is_empty ())
    3472                 :            :             {
    3473                 :      68511 :               if (i < ctx.m_known_aggs.length ()
    3474                 :      68511 :                   && !ctx.m_known_aggs[i].is_empty ())
    3475                 :            :                 return false;
    3476                 :      68305 :               continue;
    3477                 :            :             }
    3478                 :       1135 :           if (i >= ctx.m_known_aggs.length ()
    3479                 :       1135 :               || ctx.m_known_aggs[i].is_empty ())
    3480                 :            :             {
    3481                 :    2294990 :               if (i < m_known_aggs.length ()
    3482                 :    2294990 :                   && !m_known_aggs[i].is_empty ())
    3483                 :            :                 return false;
    3484                 :            :               continue;
    3485                 :            :             }
    3486                 :        924 :           if (!m_known_aggs[i].equal_to (ctx.m_known_aggs[i]))
    3487                 :            :             return false;
    3488                 :            :         }
    3489                 :            :     }
    3490                 :            :   return true;
    3491                 :            : }
    3492                 :            : 
    3493                 :            : /* Estimate size and time needed to execute call in the given context.
    3494                 :            :    Additionally determine hints determined by the context.  Finally compute
    3495                 :            :    minimal size needed for the call that is independent on the call context and
    3496                 :            :    can be used for fast estimates.  Return the values in RET_SIZE,
    3497                 :            :    RET_MIN_SIZE, RET_TIME and RET_HINTS.  */
    3498                 :            : 
    3499                 :            : void
    3500                 :    9928880 : ipa_call_context::estimate_size_and_time (int *ret_size,
    3501                 :            :                                           int *ret_min_size,
    3502                 :            :                                           sreal *ret_time,
    3503                 :            :                                           sreal *ret_nonspecialized_time,
    3504                 :            :                                           ipa_hints *ret_hints)
    3505                 :            : {
    3506                 :    9928880 :   class ipa_fn_summary *info = ipa_fn_summaries->get (m_node);
    3507                 :    9928880 :   size_time_entry *e;
    3508                 :    9928880 :   int size = 0;
    3509                 :    9928880 :   sreal time = 0;
    3510                 :    9928880 :   int min_size = 0;
    3511                 :    9928880 :   ipa_hints hints = 0;
    3512                 :    9928880 :   int i;
    3513                 :            : 
    3514                 :    9928880 :   if (dump_file && (dump_flags & TDF_DETAILS))
    3515                 :            :     {
    3516                 :       1150 :       bool found = false;
    3517                 :       2300 :       fprintf (dump_file, "   Estimating body: %s\n"
    3518                 :       1150 :                "   Known to be false: ", m_node->dump_name ());
    3519                 :            : 
    3520                 :       3173 :       for (i = predicate::not_inlined_condition;
    3521                 :       6346 :            i < (predicate::first_dynamic_condition
    3522                 :       4828 :                 + (int) vec_safe_length (info->conds)); i++)
    3523                 :       2023 :         if (!(m_possible_truths & (1 << i)))
    3524                 :            :           {
    3525                 :       1392 :             if (found)
    3526                 :        289 :               fprintf (dump_file, ", ");
    3527                 :       1392 :             found = true;
    3528                 :       1392 :             dump_condition (dump_file, info->conds, i);
    3529                 :            :           }
    3530                 :            :     }
    3531                 :            : 
    3532                 :    9928880 :   if (m_node->callees || m_node->indirect_calls)
    3533                 :   11886200 :     estimate_calls_size_and_time (m_node, &size, &min_size,
    3534                 :            :                                   ret_time ? &time : NULL,
    3535                 :            :                                   ret_hints ? &hints : NULL, m_possible_truths,
    3536                 :            :                                   m_known_vals, m_known_contexts, m_known_aggs);
    3537                 :            : 
    3538                 :    9928880 :   sreal nonspecialized_time = time;
    3539                 :            : 
    3540                 :    9928880 :   min_size += (*info->size_time_table)[0].size;
    3541                 :   50203500 :   for (i = 0; vec_safe_iterate (info->size_time_table, i, &e); i++)
    3542                 :            :     {
    3543                 :   40274600 :       bool exec = e->exec_predicate.evaluate (m_nonspec_possible_truths);
    3544                 :            : 
    3545                 :            :       /* Because predicates are conservative, it can happen that nonconst is 1
    3546                 :            :          but exec is 0.  */
    3547                 :   40274600 :       if (exec)
    3548                 :            :         {
    3549                 :   39781500 :           bool nonconst = e->nonconst_predicate.evaluate (m_possible_truths);
    3550                 :            : 
    3551                 :   39781500 :           gcc_checking_assert (e->time >= 0);
    3552                 :   39781500 :           gcc_checking_assert (time >= 0);
    3553                 :            : 
    3554                 :            :           /* We compute specialized size only because size of nonspecialized
    3555                 :            :              copy is context independent.
    3556                 :            : 
    3557                 :            :              The difference between nonspecialized execution and specialized is
    3558                 :            :              that nonspecialized is not going to have optimized out computations
    3559                 :            :              known to be constant in a specialized setting.  */
    3560                 :   39781500 :           if (nonconst)
    3561                 :   21502400 :             size += e->size;
    3562                 :   39781500 :           if (!ret_time)
    3563                 :   26984900 :             continue;
    3564                 :   12796700 :           nonspecialized_time += e->time;
    3565                 :   12796700 :           if (!nonconst)
    3566                 :            :             ;
    3567                 :    7303400 :           else if (!m_inline_param_summary.exists ())
    3568                 :            :             {
    3569                 :     718114 :               if (nonconst)
    3570                 :     718114 :                 time += e->time;
    3571                 :            :             }
    3572                 :            :           else
    3573                 :            :             {
    3574                 :    6585280 :               int prob = e->nonconst_predicate.probability 
    3575                 :    6585280 :                                                (info->conds, m_possible_truths,
    3576                 :            :                                                 m_inline_param_summary);
    3577                 :    6585280 :               gcc_checking_assert (prob >= 0);
    3578                 :    6585280 :               gcc_checking_assert (prob <= REG_BR_PROB_BASE);
    3579                 :    6585280 :               if (prob == REG_BR_PROB_BASE)
    3580                 :    4817230 :                 time += e->time;
    3581                 :            :               else
    3582                 :    1768060 :                 time += e->time * prob / REG_BR_PROB_BASE;
    3583                 :            :             }
    3584                 :   12796700 :           gcc_checking_assert (time >= 0);
    3585                 :            :         }
    3586                 :            :      }
    3587                 :    9928880 :   gcc_checking_assert ((*info->size_time_table)[0].exec_predicate == true);
    3588                 :    9928880 :   gcc_checking_assert ((*info->size_time_table)[0].nonconst_predicate == true);
    3589                 :    9928880 :   gcc_checking_assert (min_size >= 0);
    3590                 :    9928880 :   gcc_checking_assert (size >= 0);
    3591                 :    9928880 :   gcc_checking_assert (time >= 0);
    3592                 :            :   /* nonspecialized_time should be always bigger than specialized time.
    3593                 :            :      Roundoff issues however may get into the way.  */
    3594                 :    9928880 :   gcc_checking_assert ((nonspecialized_time - time * 99 / 100) >= -1);
    3595                 :            : 
    3596                 :            :   /* Roundoff issues may make specialized time bigger than nonspecialized
    3597                 :            :      time.  We do not really want that to happen because some heuristics
    3598                 :            :      may get confused by seeing negative speedups.  */
    3599                 :    9928880 :   if (time > nonspecialized_time)
    3600                 :          0 :     time = nonspecialized_time;
    3601                 :            : 
    3602                 :    9928880 :   if (ret_hints)
    3603                 :            :     {
    3604                 :    2406500 :       if (info->loop_iterations
    3605                 :    2406500 :           && !info->loop_iterations->evaluate (m_possible_truths))
    3606                 :      39020 :         hints |= INLINE_HINT_loop_iterations;
    3607                 :    2406500 :       if (info->loop_stride
    3608                 :    2406500 :           && !info->loop_stride->evaluate (m_possible_truths))
    3609                 :       4539 :         hints |= INLINE_HINT_loop_stride;
    3610                 :    2406500 :       if (info->scc_no)
    3611                 :      65386 :         hints |= INLINE_HINT_in_scc;
    3612                 :    2406500 :       if (DECL_DECLARED_INLINE_P (m_node->decl))
    3613                 :    1553400 :         hints |= INLINE_HINT_declared_inline;
    3614                 :            :     }
    3615                 :            : 
    3616                 :    9928880 :   size = RDIV (size, ipa_fn_summary::size_scale);
    3617                 :    9928880 :   min_size = RDIV (min_size, ipa_fn_summary::size_scale);
    3618                 :            : 
    3619                 :    9928880 :   if (dump_file && (dump_flags & TDF_DETAILS))
    3620                 :       1150 :     fprintf (dump_file, "\n   size:%i time:%f nonspec time:%f\n", (int) size,
    3621                 :            :              time.to_double (), nonspecialized_time.to_double ());
    3622                 :    9928880 :   if (ret_time)
    3623                 :    2406500 :     *ret_time = time;
    3624                 :    9928880 :   if (ret_nonspecialized_time)
    3625                 :    2406500 :     *ret_nonspecialized_time = nonspecialized_time;
    3626                 :    9928880 :   if (ret_size)
    3627                 :    9928880 :     *ret_size = size;
    3628                 :    9928880 :   if (ret_min_size)
    3629                 :    2282700 :     *ret_min_size = min_size;
    3630                 :    9928880 :   if (ret_hints)
    3631                 :    2406500 :     *ret_hints = hints;
    3632                 :    9928880 :   return;
    3633                 :            : }
    3634                 :            : 
    3635                 :            : 
    3636                 :            : /* Estimate size and time needed to execute callee of EDGE assuming that
    3637                 :            :    parameters known to be constant at caller of EDGE are propagated.
    3638                 :            :    KNOWN_VALS and KNOWN_CONTEXTS are vectors of assumed known constant values
    3639                 :            :    and types for parameters.  */
    3640                 :            : 
    3641                 :            : void
    3642                 :     123800 : estimate_ipcp_clone_size_and_time (struct cgraph_node *node,
    3643                 :            :                                    vec<tree> known_vals,
    3644                 :            :                                    vec<ipa_polymorphic_call_context>
    3645                 :            :                                    known_contexts,
    3646                 :            :                                    vec<ipa_agg_value_set> known_aggs,
    3647                 :            :                                    int *ret_size, sreal *ret_time,
    3648                 :            :                                    sreal *ret_nonspec_time,
    3649                 :            :                                    ipa_hints *hints)
    3650                 :            : {
    3651                 :     123800 :   clause_t clause, nonspec_clause;
    3652                 :            : 
    3653                 :            :   /* TODO: Also pass known value ranges.  */
    3654                 :     123800 :   evaluate_conditions_for_known_args (node, false, known_vals, vNULL,
    3655                 :            :                                       known_aggs, &clause, &nonspec_clause);
    3656                 :     123800 :   ipa_call_context ctx (node, clause, nonspec_clause,
    3657                 :            :                         known_vals, known_contexts,
    3658                 :     123800 :                         known_aggs, vNULL);
    3659                 :     123800 :   ctx.estimate_size_and_time (ret_size, NULL, ret_time,
    3660                 :            :                               ret_nonspec_time, hints);
    3661                 :     123800 : }
    3662                 :            : 
    3663                 :            : /* Return stack frame offset where frame of NODE is supposed to start inside
    3664                 :            :    of the function it is inlined to.
    3665                 :            :    Return 0 for functions that are not inlined.  */
    3666                 :            : 
    3667                 :            : HOST_WIDE_INT
    3668                 :    2822770 : ipa_get_stack_frame_offset (struct cgraph_node *node)
    3669                 :            : {
    3670                 :    2822770 :   HOST_WIDE_INT offset = 0;
    3671                 :    2822770 :   if (!node->inlined_to)
    3672                 :            :     return 0;
    3673                 :    2298700 :   node = node->callers->caller;
    3674                 :    2855730 :   while (true)
    3675                 :            :     {
    3676                 :    2577210 :       offset += ipa_size_summaries->get (node)->estimated_self_stack_size;
    3677                 :    2577210 :       if (!node->inlined_to)
    3678                 :    2298700 :         return offset;
    3679                 :     278515 :       node = node->callers->caller;
    3680                 :            :     }
    3681                 :            : }
    3682                 :            : 
    3683                 :            : 
    3684                 :            : /* Update summary information of inline clones after inlining.
    3685                 :            :    Compute peak stack usage.  */
    3686                 :            : 
    3687                 :            : static void
    3688                 :    2511740 : inline_update_callee_summaries (struct cgraph_node *node, int depth)
    3689                 :            : {
    3690                 :    2511740 :   struct cgraph_edge *e;
    3691                 :            : 
    3692                 :    2511740 :   ipa_propagate_frequency (node);
    3693                 :    4282390 :   for (e = node->callees; e; e = e->next_callee)
    3694                 :            :     {
    3695                 :    1770660 :       if (!e->inline_failed)
    3696                 :     213663 :         inline_update_callee_summaries (e->callee, depth);
    3697                 :            :       else
    3698                 :    1556990 :         ipa_call_summaries->get (e)->loop_depth += depth;
    3699                 :            :     }
    3700                 :    2591320 :   for (e = node->indirect_calls; e; e = e->next_callee)
    3701                 :      79582 :     ipa_call_summaries->get (e)->loop_depth += depth;
    3702                 :    2511740 : }
    3703                 :            : 
    3704                 :            : /* Update change_prob of EDGE after INLINED_EDGE has been inlined.
    3705                 :            :    When function A is inlined in B and A calls C with parameter that
    3706                 :            :    changes with probability PROB1 and C is known to be passthrough
    3707                 :            :    of argument if B that change with probability PROB2, the probability
    3708                 :            :    of change is now PROB1*PROB2.  */
    3709                 :            : 
    3710                 :            : static void
    3711                 :    1636720 : remap_edge_change_prob (struct cgraph_edge *inlined_edge,
    3712                 :            :                         struct cgraph_edge *edge)
    3713                 :            : {
    3714                 :    1636720 :   if (ipa_node_params_sum)
    3715                 :            :     {
    3716                 :    1121980 :       int i;
    3717                 :    1121980 :       class ipa_edge_args *args = IPA_EDGE_REF (edge);
    3718                 :    1121980 :       if (!args)
    3719                 :     737223 :         return;
    3720                 :     384758 :       class ipa_call_summary *es = ipa_call_summaries->get (edge);
    3721                 :     384758 :       class ipa_call_summary *inlined_es
    3722                 :     384758 :         = ipa_call_summaries->get (inlined_edge);
    3723                 :            : 
    3724                 :     384758 :       if (es->param.length () == 0)
    3725                 :            :         return;
    3726                 :            : 
    3727                 :    2176540 :       for (i = 0; i < ipa_get_cs_argument_count (args); i++)
    3728                 :            :         {
    3729                 :     738528 :           struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, i);
    3730                 :     738528 :           if (jfunc->type == IPA_JF_PASS_THROUGH
    3731                 :     545164 :               || jfunc->type == IPA_JF_ANCESTOR)
    3732                 :            :             {
    3733                 :     260289 :               int id = jfunc->type == IPA_JF_PASS_THROUGH
    3734                 :     260289 :                        ? ipa_get_jf_pass_through_formal_id (jfunc)
    3735                 :      66925 :                        : ipa_get_jf_ancestor_formal_id (jfunc);
    3736                 :     520493 :               if (id < (int) inlined_es->param.length ())
    3737                 :            :                 {
    3738                 :     260196 :                   int prob1 = es->param[i].change_prob;
    3739                 :     260196 :                   int prob2 = inlined_es->param[id].change_prob;
    3740                 :     260196 :                   int prob = combine_probabilities (prob1, prob2);
    3741                 :            : 
    3742                 :     260196 :                   if (prob1 && prob2 && !prob)
    3743                 :       1258 :                     prob = 1;
    3744                 :            : 
    3745                 :     260196 :                   es->param[i].change_prob = prob;
    3746                 :            :                 }
    3747                 :            :             }
    3748                 :            :         }
    3749                 :            :     }
    3750                 :            : }
    3751                 :            : 
    3752                 :            : /* Update edge summaries of NODE after INLINED_EDGE has been inlined.
    3753                 :            : 
    3754                 :            :    Remap predicates of callees of NODE.  Rest of arguments match
    3755                 :            :    remap_predicate.
    3756                 :            : 
    3757                 :            :    Also update change probabilities.  */
    3758                 :            : 
    3759                 :            : static void
    3760                 :    2511740 : remap_edge_summaries (struct cgraph_edge *inlined_edge,
    3761                 :            :                       struct cgraph_node *node,
    3762                 :            :                       class ipa_fn_summary *info,
    3763                 :            :                       class ipa_node_params *params_summary,
    3764                 :            :                       class ipa_fn_summary *callee_info,
    3765                 :            :                       vec<int> operand_map,
    3766                 :            :                       vec<int> offset_map,
    3767                 :            :                       clause_t possible_truths,
    3768                 :            :                       predicate *toplev_predicate)
    3769                 :            : {
    3770                 :    2511740 :   struct cgraph_edge *e, *next;
    3771                 :    4282120 :   for (e = node->callees; e; e = next)
    3772                 :            :     {
    3773                 :    1770380 :       predicate p;
    3774                 :    1770380 :       next = e->next_callee;
    3775                 :            : 
    3776                 :    1770380 :       if (e->inline_failed)
    3777                 :            :         {
    3778                 :    1556720 :           class ipa_call_summary *es = ipa_call_summaries->get (e);
    3779                 :    1556720 :           remap_edge_change_prob (inlined_edge, e);
    3780                 :            : 
    3781                 :    1556720 :           if (es->predicate)
    3782                 :            :             {
    3783                 :     292785 :               p = es->predicate->remap_after_inlining
    3784                 :            :                                      (info, params_summary,
    3785                 :            :                                       callee_info, operand_map,
    3786                 :            :                                       offset_map, possible_truths,
    3787                 :     292785 :                                       *toplev_predicate);
    3788                 :     292785 :               edge_set_predicate (e, &p);
    3789                 :            :             }
    3790                 :            :           else
    3791                 :    1263930 :             edge_set_predicate (e, toplev_predicate);
    3792                 :            :         }
    3793                 :            :       else
    3794                 :     213663 :         remap_edge_summaries (inlined_edge, e->callee, info,
    3795                 :            :                               params_summary, callee_info,
    3796                 :            :                               operand_map, offset_map, possible_truths,
    3797                 :            :                               toplev_predicate);
    3798                 :            :     }
    3799                 :    2591740 :   for (e = node->indirect_calls; e; e = next)
    3800                 :            :     {
    3801                 :      80003 :       class ipa_call_summary *es = ipa_call_summaries->get (e);
    3802                 :      80003 :       predicate p;
    3803                 :      80003 :       next = e->next_callee;
    3804                 :            : 
    3805                 :      80003 :       remap_edge_change_prob (inlined_edge, e);
    3806                 :      80003 :       if (es->predicate)
    3807                 :            :         {
    3808                 :      16376 :           p = es->predicate->remap_after_inlining
    3809                 :            :                                  (info, params_summary,
    3810                 :            :                                   callee_info, operand_map, offset_map,
    3811                 :      16376 :                                   possible_truths, *toplev_predicate);
    3812                 :      16376 :           edge_set_predicate (e, &p);
    3813                 :            :         }
    3814                 :            :       else
    3815                 :      63627 :         edge_set_predicate (e, toplev_predicate);
    3816                 :            :     }
    3817                 :    2511740 : }
    3818                 :            : 
    3819                 :            : /* Same as remap_predicate, but set result into hint *HINT.  */
    3820                 :            : 
    3821                 :            : static void
    3822                 :    4596150 : remap_hint_predicate (class ipa_fn_summary *info,
    3823                 :            :                       class ipa_node_params *params_summary,
    3824                 :            :                       class ipa_fn_summary *callee_info,
    3825                 :            :                       predicate **hint,
    3826                 :            :                       vec<int> operand_map,
    3827                 :            :                       vec<int> offset_map,
    3828                 :            :                       clause_t possible_truths,
    3829                 :            :                       predicate *toplev_predicate)
    3830                 :            : {
    3831                 :    4596150 :   predicate p;
    3832                 :            : 
    3833                 :    4596150 :   if (!*hint)
    3834                 :    4585930 :     return;
    3835                 :      10218 :   p = (*hint)->remap_after_inlining
    3836                 :            :                          (info, params_summary, callee_info,
    3837                 :            :                           operand_map, offset_map,
    3838                 :      10218 :                           possible_truths, *toplev_predicate);
    3839                 :      17112 :   if (p != false && p != true)
    3840                 :            :     {
    3841                 :       2674 :       if (!*hint)
    3842                 :          0 :         set_hint_predicate (hint, p);
    3843                 :            :       else
    3844                 :       2674 :         **hint &= p;
    3845                 :            :     }
    3846                 :            : }
    3847                 :            : 
    3848                 :            : /* We inlined EDGE.  Update summary of the function we inlined into.  */
    3849                 :            : 
    3850                 :            : void
    3851                 :    2298070 : ipa_merge_fn_summary_after_inlining (struct cgraph_edge *edge)
    3852                 :            : {
    3853                 :    2298070 :   ipa_fn_summary *callee_info = ipa_fn_summaries->get (edge->callee);
    3854                 :    4596150 :   struct cgraph_node *to = (edge->caller->inlined_to
    3855                 :    2298070 :                             ? edge->caller->inlined_to : edge->caller);
    3856                 :    2298070 :   class ipa_fn_summary *info = ipa_fn_summaries->get (to);
    3857                 :    2298070 :   clause_t clause = 0;  /* not_inline is known to be false.  */
    3858                 :    2298070 :   size_time_entry *e;
    3859                 :    2298070 :   auto_vec<int, 8> operand_map;
    3860                 :    2298070 :   auto_vec<int, 8> offset_map;
    3861                 :    2298070 :   int i;
    3862                 :    2298070 :   predicate toplev_predicate;
    3863                 :    2298070 :   class ipa_call_summary *es = ipa_call_summaries->get (edge);
    3864                 :    4596150 :   class ipa_node_params *params_summary = (ipa_node_params_sum
    3865                 :    2298070 :                                            ? IPA_NODE_REF (to) : NULL);
    3866                 :            : 
    3867                 :    2298070 :   if (es->predicate)
    3868                 :     163891 :     toplev_predicate = *es->predicate;
    3869                 :            :   else
    3870                 :    2134180 :     toplev_predicate = true;
    3871                 :            : 
    3872                 :    2298070 :   info->fp_expressions |= callee_info->fp_expressions;
    3873                 :            : 
    3874                 :    2298070 :   if (callee_info->conds)
    3875                 :            :     {
    3876                 :    2623500 :       auto_vec<tree, 32> known_vals;
    3877                 :    1311750 :       auto_vec<ipa_agg_value_set, 32> known_aggs;
    3878                 :    1311750 :       evaluate_properties_for_edge (edge, true, &clause, NULL,
    3879                 :            :                                     &known_vals, NULL, &known_aggs);
    3880                 :            :     }
    3881                 :    2298070 :   if (ipa_node_params_sum && callee_info->conds)
    3882                 :            :     {
    3883                 :     353341 :       class ipa_edge_args *args = IPA_EDGE_REF (edge);
    3884                 :     353341 :       int count = args ? ipa_get_cs_argument_count (args) : 0;
    3885                 :     353341 :       int i;
    3886                 :            : 
    3887                 :     353341 :       if (count)
    3888                 :            :         {
    3889                 :     353176 :           operand_map.safe_grow_cleared (count);
    3890                 :     353176 :           offset_map.safe_grow_cleared (count);
    3891                 :            :         }
    3892                 :    1062580 :       for (i = 0; i < count; i++)
    3893                 :            :         {
    3894                 :     709239 :           struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, i);
    3895                 :     709239 :           int map = -1;
    3896                 :            : 
    3897                 :            :           /* TODO: handle non-NOPs when merging.  */
    3898                 :     709239 :           if (jfunc->type == IPA_JF_PASS_THROUGH)
    3899                 :            :             {
    3900                 :     135066 :               if (ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
    3901                 :     133380 :                 map = ipa_get_jf_pass_through_formal_id (jfunc);
    3902                 :     135066 :               if (!ipa_get_jf_pass_through_agg_preserved (jfunc))
    3903                 :      92296 :                 offset_map[i] = -1;
    3904                 :            :             }
    3905                 :     574173 :           else if (jfunc->type == IPA_JF_ANCESTOR)
    3906                 :            :             {
    3907                 :      44686 :               HOST_WIDE_INT offset = ipa_get_jf_ancestor_offset (jfunc);
    3908                 :      44686 :               if (offset >= 0 && offset < INT_MAX)
    3909                 :            :                 {
    3910                 :      44686 :                   map = ipa_get_jf_ancestor_formal_id (jfunc);
    3911                 :      44686 :                   if (!ipa_get_jf_ancestor_agg_preserved (jfunc))
    3912                 :      32657 :                     offset = -1;
    3913                 :      44686 :                   offset_map[i] = offset;
    3914                 :            :                 }
    3915                 :            :             }
    3916                 :     709239 :           operand_map[i] = map;
    3917                 :    1255420 :           gcc_assert (map < ipa_get_param_count (params_summary));
    3918                 :            :         }
    3919                 :            :     }
    3920                 :    2298070 :   sreal freq =  edge->sreal_frequency ();
    3921                 :   10102400 :   for (i = 0; vec_safe_iterate (callee_info->size_time_table, i, &e); i++)
    3922                 :            :     {
    3923                 :    7804340 :       predicate p;
    3924                 :    7804340 :       p = e->exec_predicate.remap_after_inlining
    3925                 :            :                              (info, params_summary,
    3926                 :            :                               callee_info, operand_map,
    3927                 :            :                               offset_map, clause,
    3928                 :    7804340 :                               toplev_predicate);
    3929                 :    7804340 :       predicate nonconstp;
    3930                 :    7804340 :       nonconstp = e->nonconst_predicate.remap_after_inlining
    3931                 :            :                                      (info, params_summary,
    3932                 :            :                                       callee_info, operand_map,
    3933                 :            :                                       offset_map, clause,
    3934                 :    7804340 :                                       toplev_predicate);
    3935                 :   11992100 :       if (p != false && nonconstp != false)
    3936                 :            :         {
    3937                 :    4044440 :           sreal add_time = ((sreal)e->time * freq);
    3938                 :    4044440 :           int prob = e->nonconst_predicate.probability (callee_info->conds,
    3939                 :            :                                                         clause, es->param);
    3940                 :    4044440 :           if (prob != REG_BR_PROB_BASE)
    3941                 :     574583 :             add_time = add_time * prob / REG_BR_PROB_BASE;
    3942                 :    4044440 :           if (prob != REG_BR_PROB_BASE
    3943                 :    4044440 :               && dump_file && (dump_flags & TDF_DETAILS))
    3944                 :            :             {
    3945                 :          6 :               fprintf (dump_file, "\t\tScaling time by probability:%f\n",
    3946                 :          6 :                        (double) prob / REG_BR_PROB_BASE);
    3947                 :            :             }
    3948                 :    4044440 :           info->account_size_time (e->size, add_time, p, nonconstp);
    3949                 :            :         }
    3950                 :            :     }
    3951                 :    2298070 :   remap_edge_summaries (edge, edge->callee, info, params_summary,
    3952                 :            :                         callee_info, operand_map,
    3953                 :            :                         offset_map, clause, &toplev_predicate);
    3954                 :    2298070 :   remap_hint_predicate (info, params_summary, callee_info,
    3955                 :            :                         &callee_info->loop_iterations,
    3956                 :            :                         operand_map, offset_map, clause, &toplev_predicate);
    3957                 :    2298070 :   remap_hint_predicate (info, params_summary, callee_info,
    3958                 :            :                         &callee_info->loop_stride,
    3959                 :            :                         operand_map, offset_map, clause, &toplev_predicate);
    3960                 :            : 
    3961                 :    2298070 :   HOST_WIDE_INT stack_frame_offset = ipa_get_stack_frame_offset (edge->callee);
    3962                 :    2298070 :   HOST_WIDE_INT peak = stack_frame_offset + callee_info->estimated_stack_size;
    3963                 :            : 
    3964                 :    2298070 :   if (info->estimated_stack_size < peak)
    3965                 :      64487 :     info->estimated_stack_size = peak;
    3966                 :            : 
    3967                 :    2298070 :   inline_update_callee_summaries (edge->callee, es->loop_depth);
    3968                 :    2298070 :   if (info->call_size_time_table)
    3969                 :            :     {
    3970                 :     463842 :       int edge_size = 0;
    3971                 :     463842 :       sreal edge_time = 0;
    3972                 :            : 
    3973                 :     463842 :       estimate_edge_size_and_time (edge, &edge_size, NULL, &edge_time, vNULL,
    3974                 :            :                                    vNULL, vNULL, 0);
    3975                 :            :       /* Unaccount size and time of the optimized out call.  */
    3976                 :     463842 :       info->account_size_time (-edge_size, -edge_time,
    3977                 :     463842 :                                es->predicate ? *es->predicate : true,
    3978                 :     877877 :                                es->predicate ? *es->predicate : true,
    3979                 :            :                                true);
    3980                 :            :       /* Account new calls.  */
    3981                 :     463842 :       summarize_calls_size_and_time (edge->callee, info);
    3982                 :            :     }
    3983                 :            : 
    3984                 :            :   /* Free summaries that are not maintained for inline clones/edges.  */
    3985                 :    2298070 :   ipa_call_summaries->remove (edge);
    3986                 :    2298070 :   ipa_fn_summaries->remove (edge->callee);
    3987                 :    2298070 :   ipa_remove_from_growth_caches (edge);
    3988                 :    2298070 : }
    3989                 :            : 
    3990                 :            : /* For performance reasons ipa_merge_fn_summary_after_inlining is not updating
    3991                 :            :    overall size and time.  Recompute it.
    3992                 :            :    If RESET is true also recompute call_time_size_table.  */
    3993                 :            : 
    3994                 :            : void
    3995                 :    5843900 : ipa_update_overall_fn_summary (struct cgraph_node *node, bool reset)
    3996                 :            : {
    3997                 :    5843900 :   class ipa_fn_summary *info = ipa_fn_summaries->get (node);
    3998                 :    5843900 :   class ipa_size_summary *size_info = ipa_size_summaries->get (node);
    3999                 :    5843900 :   size_time_entry *e;
    4000                 :    5843900 :   int i;
    4001                 :            : 
    4002                 :    5843900 :   size_info->size = 0;
    4003                 :    5843900 :   info->time = 0;
    4004                 :   24887500 :   for (i = 0; vec_safe_iterate (info->size_time_table, i, &e); i++)
    4005                 :            :     {
    4006                 :   19043600 :       size_info->size += e->size;
    4007                 :   19043600 :       info->time += e->time;
    4008                 :            :     }
    4009                 :    5843900 :   info->min_size = (*info->size_time_table)[0].size;
    4010                 :    5843900 :   if (reset)
    4011                 :    5404730 :     vec_free (info->call_size_time_table);
    4012                 :    5843900 :   if (node->callees || node->indirect_calls)
    4013                 :    4369540 :     estimate_calls_size_and_time (node, &size_info->size, &info->min_size,
    4014                 :            :                                   &info->time, NULL,
    4015                 :            :                                   ~(clause_t) (1 << predicate::false_condition),
    4016                 :            :                                   vNULL, vNULL, vNULL);
    4017                 :    5843900 :   size_info->size = RDIV (size_info->size, ipa_fn_summary::size_scale);
    4018                 :    5843900 :   info->min_size = RDIV (info->min_size, ipa_fn_summary::size_scale);
    4019                 :    5843900 : }
    4020                 :            : 
    4021                 :            : 
    4022                 :            : /* This function performs intraprocedural analysis in NODE that is required to
    4023                 :            :    inline indirect calls.  */
    4024                 :            : 
    4025                 :            : static void
    4026                 :     893395 : inline_indirect_intraprocedural_analysis (struct cgraph_node *node)
    4027                 :            : {
    4028                 :     893395 :   ipa_analyze_node (node);
    4029                 :     893395 :   if (dump_file && (dump_flags & TDF_DETAILS))
    4030                 :            :     {
    4031                 :         14 :       ipa_print_node_params (dump_file, node);
    4032                 :         14 :       ipa_print_node_jump_functions (dump_file, node);
    4033                 :            :     }
    4034                 :     893395 : }
    4035                 :            : 
    4036                 :            : 
    4037                 :            : /* Note function body size.  */
    4038                 :            : 
    4039                 :            : void
    4040                 :     902559 : inline_analyze_function (struct cgraph_node *node)
    4041                 :            : {
    4042                 :     902559 :   push_cfun (DECL_STRUCT_FUNCTION (node->decl));
    4043                 :            : 
    4044                 :     902559 :   if (dump_file)
    4045                 :        102 :     fprintf (dump_file, "\nAnalyzing function: %s\n", node->dump_name ());
    4046                 :     902559 :   if (opt_for_fn (node->decl, optimize) && !node->thunk.thunk_p)
    4047                 :     893395 :     inline_indirect_intraprocedural_analysis (node);
    4048                 :     902559 :   compute_fn_summary (node, false);
    4049                 :     902559 :   if (!optimize)
    4050                 :            :     {
    4051                 :       8037 :       struct cgraph_edge *e;
    4052                 :      21099 :       for (e = node->callees; e; e = e->next_callee)
    4053                 :      13062 :         e->inline_failed = CIF_FUNCTION_NOT_OPTIMIZED;
    4054                 :       8096 :       for (e = node->indirect_calls; e; e = e->next_callee)
    4055                 :         59 :         e->inline_failed = CIF_FUNCTION_NOT_OPTIMIZED;
    4056                 :            :     }
    4057                 :            : 
    4058                 :     902559 :   pop_cfun ();
    4059                 :     902559 : }
    4060                 :            : 
    4061                 :            : 
    4062                 :            : /* Called when new function is inserted to callgraph late.  */
    4063                 :            : 
    4064                 :            : void
    4065                 :      19385 : ipa_fn_summary_t::insert (struct cgraph_node *node, ipa_fn_summary *)
    4066                 :            : {
    4067                 :      19385 :   inline_analyze_function (node);
    4068                 :      19385 : }
    4069                 :            : 
    4070                 :            : /* Note function body size.  */
    4071                 :            : 
    4072                 :            : static void
    4073                 :     163373 : ipa_fn_summary_generate (void)
    4074                 :            : {
    4075                 :     163373 :   struct cgraph_node *node;
    4076                 :            : 
    4077                 :    2686300 :   FOR_EACH_DEFINED_FUNCTION (node)
    4078                 :    1179780 :     if (DECL_STRUCT_FUNCTION (node->decl))
    4079                 :    1167720 :       node->versionable = tree_versionable_function_p (node->decl);
    4080                 :            : 
    4081                 :     163373 :   ipa_fn_summary_alloc ();
    4082                 :            : 
    4083                 :     163373 :   ipa_fn_summaries->enable_insertion_hook ();
    4084                 :            : 
    4085                 :     163373 :   ipa_register_cgraph_hooks ();
    4086                 :            : 
    4087                 :    2686300 :   FOR_EACH_DEFINED_FUNCTION (node)
    4088                 :    1179780 :     if (!node->alias
    4089                 :    1179780 :         && (flag_generate_lto || flag_generate_offload|| flag_wpa
    4090                 :    1028810 :             || opt_for_fn (node->decl, optimize)))
    4091                 :     864741 :       inline_analyze_function (node);
    4092                 :     163373 : }
    4093                 :            : 
    4094                 :            : 
    4095                 :            : /* Write inline summary for edge E to OB.  */
    4096                 :            : 
    4097                 :            : static void
    4098                 :     200863 : read_ipa_call_summary (class lto_input_block *ib, struct cgraph_edge *e,
    4099                 :            :                        bool prevails)
    4100                 :            : {
    4101                 :     200863 :   class ipa_call_summary *es = prevails
    4102                 :     200863 :                                 ? ipa_call_summaries->get_create (e) : NULL;
    4103                 :     200863 :   predicate p;
    4104                 :     200863 :   int length, i;
    4105                 :            : 
    4106                 :     200863 :   int size = streamer_read_uhwi (ib);
    4107                 :     200863 :   int time = streamer_read_uhwi (ib);
    4108                 :     200863 :   int depth = streamer_read_uhwi (ib);
    4109                 :            : 
    4110                 :     200863 :   if (es)
    4111                 :            :     {
    4112                 :     200816 :       es->call_stmt_size = size;
    4113                 :     200816 :       es->call_stmt_time = time;
    4114                 :     200816 :       es->loop_depth = depth;
    4115                 :            :     }
    4116                 :            : 
    4117                 :     200863 :   bitpack_d bp = streamer_read_bitpack (ib);
    4118                 :     200863 :   if (es)
    4119                 :     200816 :     es->is_return_callee_uncaptured = bp_unpack_value (&bp, 1);  
    4120                 :            :   else
    4121                 :         47 :     bp_unpack_value (&bp, 1);       
    4122                 :            : 
    4123                 :     200863 :   p.stream_in (ib);
    4124                 :     200863 :   if (es)
    4125                 :     200816 :     edge_set_predicate (e, &p);
    4126                 :     200863 :   length = streamer_read_uhwi (ib);
    4127                 :     200863 :   if (length && es && e->possibly_call_in_translation_unit_p ())
    4128                 :            :     {
    4129                 :      57256 :       es->param.safe_grow_cleared (length);
    4130                 :     150131 :       for (i = 0; i < length; i++)
    4131                 :      92875 :         es->param[i].change_prob = streamer_read_uhwi (ib);
    4132                 :            :     }
    4133                 :            :   else
    4134                 :            :     {
    4135                 :     247054 :       for (i = 0; i < length; i++)
    4136                 :     103447 :         streamer_read_uhwi (ib);
    4137                 :            :     }
    4138                 :     200863 : }
    4139                 :            : 
    4140                 :            : 
    4141                 :            : /* Stream in inline summaries from the section.  */
    4142                 :            : 
    4143                 :            : static void
    4144                 :       9568 : inline_read_section (struct lto_file_decl_data *file_data, const char *data,
    4145                 :            :                      size_t len)
    4146                 :            : {
    4147                 :       9568 :   const struct lto_function_header *header =
    4148                 :            :     (const struct lto_function_header *) data;
    4149                 :       9568 :   const int cfg_offset = sizeof (struct lto_function_header);
    4150                 :       9568 :   const int main_offset = cfg_offset + header->cfg_size;
    4151                 :       9568 :   const int string_offset = main_offset + header->main_size;
    4152                 :       9568 :   class data_in *data_in;
    4153                 :       9568 :   unsigned int i, count2, j;
    4154                 :       9568 :   unsigned int f_count;
    4155                 :            : 
    4156                 :       9568 :   lto_input_block ib ((const char *) data + main_offset, header->main_size,
    4157                 :       9568 :                       file_data->mode_table);
    4158                 :            : 
    4159                 :       9568 :   data_in =
    4160                 :      19136 :     lto_data_in_create (file_data, (const char *) data + string_offset,
    4161                 :       9568 :                         header->string_size, vNULL);
    4162                 :       9568 :   f_count = streamer_read_uhwi (&ib);
    4163                 :      83301 :   for (i = 0; i < f_count; i++)
    4164                 :            :     {
    4165                 :      73733 :       unsigned int index;
    4166                 :      73733 :       struct cgraph_node *node;
    4167                 :      73733 :       class ipa_fn_summary *info;
    4168                 :      73733 :       class ipa_node_params *params_summary;
    4169                 :      73733 :       class ipa_size_summary *size_info;
    4170                 :      73733 :       lto_symtab_encoder_t encoder;
    4171                 :      73733 :       struct bitpack_d bp;
    4172                 :      73733 :       struct cgraph_edge *e;
    4173                 :      73733 :       predicate p;
    4174                 :            : 
    4175                 :      73733 :       index = streamer_read_uhwi (&ib);
    4176                 :      73733 :       encoder = file_data->symtab_node_encoder;
    4177                 :     147466 :       node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
    4178                 :            :                                                                 index));
    4179                 :      73733 :       info = node->prevailing_p () ? ipa_fn_summaries->get_create (node) : NULL;
    4180                 :      73733 :       params_summary = node->prevailing_p () ? IPA_NODE_REF (node) : NULL;
    4181                 :      73733 :       size_info = node->prevailing_p ()
    4182                 :      73733 :                   ? ipa_size_summaries->get_create (node) : NULL;
    4183                 :            : 
    4184                 :      73733 :       int stack_size = streamer_read_uhwi (&ib);
    4185                 :      73733 :       int size = streamer_read_uhwi (&ib);
    4186                 :      73733 :       sreal time = sreal::stream_in (&ib);
    4187                 :            : 
    4188                 :      73733 :       if (info)
    4189                 :            :         {
    4190                 :      73679 :           info->estimated_stack_size
    4191                 :      73679 :             = size_info->estimated_self_stack_size = stack_size;
    4192                 :      73679 :           size_info->size = size_info->self_size = size;
    4193                 :      73679 :           info->time = time;
    4194                 :            :         }
    4195                 :            : 
    4196                 :      73733 :       bp = streamer_read_bitpack (&ib);
    4197                 :      73733 :       if (info)
    4198                 :            :         {
    4199                 :      73679 :           info->inlinable = bp_unpack_value (&bp, 1);
    4200                 :      73679 :           info->fp_expressions = bp_unpack_value (&bp, 1);
    4201                 :            :         }
    4202                 :            :       else
    4203                 :            :         {
    4204                 :         54 :           bp_unpack_value (&bp, 1);
    4205                 :         54 :           bp_unpack_value (&bp, 1);
    4206                 :            :         }
    4207                 :            : 
    4208                 :      73733 :       count2 = streamer_read_uhwi (&ib);
    4209                 :      73733 :       gcc_assert (!info || !info->conds);
    4210                 :      73733 :       if (info)
    4211                 :      73679 :         vec_safe_reserve_exact (info->conds, count2);
    4212                 :     131332 :       for (j = 0; j < count2; j++)
    4213                 :            :         {
    4214                 :      57599 :           struct condition c;
    4215                 :      57599 :           unsigned int k, count3;
    4216                 :      57599 :           c.operand_num = streamer_read_uhwi (&ib);
    4217                 :      57599 :           c.code = (enum tree_code) streamer_read_uhwi (&ib);
    4218                 :      57599 :           c.type = stream_read_tree (&ib, data_in);
    4219                 :      57599 :           c.val = stream_read_tree (&ib, data_in);
    4220                 :      57599 :           bp = streamer_read_bitpack (&ib);
    4221                 :      57599 :           c.agg_contents = bp_unpack_value (&bp, 1);
    4222                 :      57599 :           c.by_ref = bp_unpack_value (&bp, 1);
    4223                 :      57599 :           if (c.agg_contents)
    4224                 :       7077 :             c.offset = streamer_read_uhwi (&ib);
    4225                 :      57599 :           count3 = streamer_read_uhwi (&ib);
    4226                 :      57599 :           c.param_ops = NULL;
    4227                 :      57599 :           if (info)
    4228                 :      57599 :             vec_safe_reserve_exact (c.param_ops, count3);
    4229                 :      57599 :           if (params_summary)
    4230                 :      57599 :             ipa_set_param_used_by_ipa_predicates
    4231                 :      57599 :                     (params_summary, c.operand_num, true);
    4232                 :      59052 :           for (k = 0; k < count3; k++)
    4233                 :            :             {
    4234                 :       1453 :               struct expr_eval_op op;
    4235                 :       1453 :               enum gimple_rhs_class rhs_class;
    4236                 :       1453 :               op.code = (enum tree_code) streamer_read_uhwi (&ib);
    4237                 :       1453 :               op.type = stream_read_tree (&ib, data_in);
    4238                 :       1453 :               switch (rhs_class = get_gimple_rhs_class (op.code))
    4239                 :            :                 {
    4240                 :        523 :                 case GIMPLE_UNARY_RHS:
    4241                 :        523 :                   op.index = 0;
    4242                 :        523 :                   op.val[0] = NULL_TREE;
    4243                 :        523 :                   op.val[1] = NULL_TREE;
    4244                 :        523 :                   break;
    4245                 :            : 
    4246                 :        930 :                 case GIMPLE_BINARY_RHS:
    4247                 :        930 :                 case GIMPLE_TERNARY_RHS:
    4248                 :        930 :                   bp = streamer_read_bitpack (&ib);
    4249                 :        930 :                   op.index = bp_unpack_value (&bp, 2);
    4250                 :        930 :                   op.val[0] = stream_read_tree (&ib, data_in);
    4251                 :        930 :                   if (rhs_class == GIMPLE_BINARY_RHS)
    4252                 :        930 :                     op.val[1] = NULL_TREE;
    4253                 :            :                   else
    4254                 :          0 :                     op.val[1] = stream_read_tree (&ib, data_in);
    4255                 :            :                   break;
    4256                 :            : 
    4257                 :          0 :                 default:
    4258                 :          0 :                   fatal_error (UNKNOWN_LOCATION,
    4259                 :            :                                "invalid fnsummary in LTO stream");
    4260                 :            :                 }
    4261                 :       1453 :               if (info)
    4262                 :       1453 :                 c.param_ops->quick_push (op);
    4263                 :            :             }
    4264                 :      57599 :           if (info)
    4265                 :      57599 :             info->conds->quick_push (c);
    4266                 :            :         }
    4267                 :      73733 :       count2 = streamer_read_uhwi (&ib);
    4268                 :      73733 :       gcc_assert (!info || !info->size_time_table);
    4269                 :      73733 :       if (info && count2)
    4270                 :      73679 :         vec_safe_reserve_exact (info->size_time_table, count2);
    4271                 :     268948 :       for (j = 0; j < count2; j++)
    4272                 :            :         {
    4273                 :     195215 :           class size_time_entry e;
    4274                 :            : 
    4275                 :     195215 :           e.size = streamer_read_uhwi (&ib);
    4276                 :     195215 :           e.time = sreal::stream_in (&ib);
    4277                 :     195215 :           e.exec_predicate.stream_in (&ib);
    4278                 :     195215 :           e.nonconst_predicate.stream_in (&ib);
    4279                 :            : 
    4280                 :     195215 :           if (info)
    4281                 :     195107 :             info->size_time_table->quick_push (e);
    4282                 :            :         }
    4283                 :            : 
    4284                 :      73733 :       p.stream_in (&ib);
    4285                 :      73733 :       if (info)
    4286                 :      73679 :         set_hint_predicate (&info->loop_iterations, p);
    4287                 :      73733 :       p.stream_in (&ib);
    4288                 :      73733 :       if (info)
    4289                 :      73679 :         set_hint_predicate (&info->loop_stride, p);
    4290                 :     273483 :       for (e = node->callees; e; e = e->next_callee)
    4291                 :     199750 :         read_ipa_call_summary (&ib, e, info != NULL);
    4292                 :      74846 :       for (e = node->indirect_calls; e; e = e->next_callee)
    4293                 :       1113 :         read_ipa_call_summary (&ib, e, info != NULL);
    4294                 :            :     }
    4295                 :            : 
    4296                 :       9568 :   lto_free_section_data (file_data, LTO_section_ipa_fn_summary, NULL, data,
    4297                 :            :                          len);
    4298                 :       9568 :   lto_data_in_delete (data_in);
    4299                 :       9568 : }
    4300                 :            : 
    4301                 :            : 
    4302                 :            : /* Read inline summary.  Jump functions are shared among ipa-cp
    4303                 :            :    and inliner, so when ipa-cp is active, we don't need to write them
    4304                 :            :    twice.  */
    4305                 :            : 
    4306                 :            : static void
    4307                 :       8631 : ipa_fn_summary_read (void)
    4308                 :            : {
    4309                 :       8631 :   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
    4310                 :       8631 :   struct lto_file_decl_data *file_data;
    4311                 :       8631 :   unsigned int j = 0;
    4312                 :            : 
    4313                 :       8631 :   ipa_fn_summary_alloc ();
    4314                 :            : 
    4315                 :      18199 :   while ((file_data = file_data_vec[j++]))
    4316                 :            :     {
    4317                 :       9568 :       size_t len;
    4318                 :       9568 :       const char *data
    4319                 :       9568 :         = lto_get_summary_section_data (file_data, LTO_section_ipa_fn_summary,
    4320                 :            :                                         &len);
    4321                 :       9568 :       if (data)
    4322                 :       9568 :         inline_read_section (file_data, data, len);
    4323                 :            :       else
    4324                 :            :         /* Fatal error here.  We do not want to support compiling ltrans units
    4325                 :            :            with different version of compiler or different flags than the WPA
    4326                 :            :            unit, so this should never happen.  */
    4327                 :          0 :         fatal_error (input_location,
    4328                 :            :                      "ipa inline summary is missing in input file");
    4329                 :            :     }
    4330                 :       8631 :   ipa_register_cgraph_hooks ();
    4331                 :       8631 :   if (!flag_ipa_cp)
    4332                 :        725 :     ipa_prop_read_jump_functions ();
    4333                 :            : 
    4334                 :       8631 :   gcc_assert (ipa_fn_summaries);
    4335                 :       8631 :   ipa_fn_summaries->enable_insertion_hook ();
    4336                 :       8631 : }
    4337                 :            : 
    4338                 :            : 
    4339                 :            : /* Write inline summary for edge E to OB.  */
    4340                 :            : 
    4341                 :            : static void
    4342                 :     227602 : write_ipa_call_summary (struct output_block *ob, struct cgraph_edge *e)
    4343                 :            : {
    4344                 :     227602 :   class ipa_call_summary *es = ipa_call_summaries->get (e);
    4345                 :     227602 :   int i;
    4346                 :            : 
    4347                 :     227602 :   streamer_write_uhwi (ob, es->call_stmt_size);
    4348                 :     227602 :   streamer_write_uhwi (ob, es->call_stmt_time);
    4349                 :     227602 :   streamer_write_uhwi (ob, es->loop_depth);
    4350                 :            : 
    4351                 :     227602 :   bitpack_d bp = bitpack_create (ob->main_stream);
    4352                 :     227602 :   bp_pack_value (&bp, es->is_return_callee_uncaptured, 1);
    4353                 :     227602 :   streamer_write_bitpack (&bp);
    4354                 :            : 
    4355                 :     227602 :   if (es->predicate)
    4356                 :       6190 :     es->predicate->stream_out (ob);
    4357                 :            :   else
    4358                 :     221412 :     streamer_write_uhwi (ob, 0);
    4359                 :     227602 :   streamer_write_uhwi (ob, es->param.length ());
    4360                 :     819040 :   for (i = 0; i < (int) es->param.length (); i++)
    4361                 :     232472 :     streamer_write_uhwi (ob, es->param[i].change_prob);
    4362                 :     227602 : }
    4363                 :            : 
    4364                 :            : 
    4365                 :            : /* Write inline summary for node in SET.
    4366                 :            :    Jump functions are shared among ipa-cp and inliner, so when ipa-cp is
    4367                 :            :    active, we don't need to write them twice.  */
    4368                 :            : 
    4369                 :            : static void
    4370                 :      16482 : ipa_fn_summary_write (void)
    4371                 :            : {
    4372                 :      16482 :   struct output_block *ob = create_output_block (LTO_section_ipa_fn_summary);
    4373                 :      16482 :   lto_symtab_encoder_iterator lsei;
    4374                 :      16482 :   lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
    4375                 :      16482 :   unsigned int count = 0;
    4376                 :            : 
    4377                 :     209444 :   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
    4378                 :      88341 :        lsei_next_function_in_partition (&lsei))
    4379                 :            :     {
    4380                 :      88341 :       cgraph_node *cnode = lsei_cgraph_node (lsei);
    4381                 :      88341 :       if (cnode->definition && !cnode->alias)
    4382                 :      85726 :         count++;
    4383                 :            :     }
    4384                 :      16482 :   streamer_write_uhwi (ob, count);
    4385                 :            : 
    4386                 :     209444 :   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
    4387                 :      88341 :        lsei_next_function_in_partition (&lsei))
    4388                 :            :     {
    4389                 :      88341 :       cgraph_node *cnode = lsei_cgraph_node (lsei);
    4390                 :      88341 :       if (cnode->definition && !cnode->alias)
    4391                 :            :         {
    4392                 :      85726 :           class ipa_fn_summary *info = ipa_fn_summaries->get (cnode);
    4393                 :      85726 :           class ipa_size_summary *size_info = ipa_size_summaries->get (cnode);
    4394                 :      85726 :           struct bitpack_d bp;
    4395                 :      85726 :           struct cgraph_edge *edge;
    4396                 :      85726 :           int i;
    4397                 :      85726 :           size_time_entry *e;
    4398                 :      85726 :           struct condition *c;
    4399                 :            : 
    4400                 :      85726 :           streamer_write_uhwi (ob, lto_symtab_encoder_encode (encoder, cnode));
    4401                 :      85726 :           streamer_write_hwi (ob, size_info->estimated_self_stack_size);
    4402                 :      85726 :           streamer_write_hwi (ob, size_info->self_size);
    4403                 :      85726 :           info->time.stream_out (ob);
    4404                 :      85726 :           bp = bitpack_create (ob->main_stream);
    4405                 :      85726 :           bp_pack_value (&bp, info->inlinable, 1);
    4406                 :      85726 :           bp_pack_value (&bp, false, 1);
    4407                 :      85726 :           bp_pack_value (&bp, info->fp_expressions, 1);
    4408                 :      85726 :           streamer_write_bitpack (&bp);
    4409                 :      85726 :           streamer_write_uhwi (ob, vec_safe_length (info->conds));
    4410                 :     152598 :           for (i = 0; vec_safe_iterate (info->conds, i, &c); i++)
    4411                 :            :             {
    4412                 :      66872 :               int j;
    4413                 :      66872 :               struct expr_eval_op *op;
    4414                 :            : 
    4415                 :      66872 :               streamer_write_uhwi (ob, c->operand_num);
    4416                 :      66872 :               streamer_write_uhwi (ob, c->code);
    4417                 :      66872 :               stream_write_tree (ob, c->type, true);
    4418                 :      66872 :               stream_write_tree (ob, c->val, true);
    4419                 :      66872 :               bp = bitpack_create (ob->main_stream);
    4420                 :      66872 :               bp_pack_value (&bp, c->agg_contents, 1);
    4421                 :      66872 :               bp_pack_value (&bp, c->by_ref, 1);
    4422                 :      66872 :               streamer_write_bitpack (&bp);
    4423                 :      66872 :               if (c->agg_contents)
    4424                 :       9323 :                 streamer_write_uhwi (ob, c->offset);
    4425                 :      66872 :               streamer_write_uhwi (ob, vec_safe_length (c->param_ops));
    4426                 :      70204 :               for (j = 0; vec_safe_iterate (c->param_ops, j, &op); j++)
    4427                 :            :                 {
    4428                 :       1900 :                   streamer_write_uhwi (ob, op->code);
    4429                 :       1900 :                   stream_write_tree (ob, op->type, true);
    4430                 :       1900 :                   if (op->val[0])
    4431                 :            :                     {
    4432                 :       1198 :                       bp = bitpack_create (ob->main_stream);
    4433                 :       1198 :                       bp_pack_value (&bp, op->index, 2);
    4434                 :       1198 :                       streamer_write_bitpack (&bp);
    4435                 :       1198 :                       stream_write_tree (ob, op->val[0], true);
    4436                 :       1198 :                       if (op->val[1])
    4437                 :          0 :                         stream_write_tree (ob, op->val[1], true);
    4438                 :            :                     }
    4439                 :            :                 }
    4440                 :            :             }
    4441                 :      85726 :           streamer_write_uhwi (ob, vec_safe_length (info->size_time_table));
    4442                 :     313631 :           for (i = 0; vec_safe_iterate (info->size_time_table, i, &e); i++)
    4443                 :            :             {
    4444                 :     227905 :               streamer_write_uhwi (ob, e->size);
    4445                 :     227905 :               e->time.stream_out (ob);
    4446                 :     227905 :               e->exec_predicate.stream_out (ob);
    4447                 :     227905 :               e->nonconst_predicate.stream_out (ob);
    4448                 :            :             }
    4449                 :      85726 :           if (info->loop_iterations)
    4450                 :       1094 :             info->loop_iterations->stream_out (ob);
    4451                 :            :           else
    4452                 :      84632 :             streamer_write_uhwi (ob, 0);
    4453                 :      85726 :           if (info->loop_stride)
    4454                 :        157 :             info->loop_stride->stream_out (ob);
    4455                 :            :           else
    4456                 :      85569 :             streamer_write_uhwi (ob, 0);
    4457                 :     311767 :           for (edge = cnode->callees; edge; edge = edge->next_callee)
    4458                 :     226041 :             write_ipa_call_summary (ob, edge);
    4459                 :      87287 :           for (edge = cnode->indirect_calls; edge; edge = edge->next_callee)
    4460                 :       1561 :             write_ipa_call_summary (ob, edge);
    4461                 :            :         }
    4462                 :            :     }
    4463                 :      16482 :   streamer_write_char_stream (ob->main_stream, 0);
    4464                 :      16482 :   produce_asm (ob, NULL);
    4465                 :      16482 :   destroy_output_block (ob);
    4466                 :            : 
    4467                 :      16482 :   if (!flag_ipa_cp)
    4468                 :       1451 :     ipa_prop_write_jump_functions ();
    4469                 :      16482 : }
    4470                 :            : 
    4471                 :            : 
    4472                 :            : /* Release function summary.  */
    4473                 :            : 
    4474                 :            : void
    4475                 :     328825 : ipa_free_fn_summary (void)
    4476                 :            : {
    4477                 :     328825 :   if (!ipa_call_summaries)
    4478                 :            :     return;
    4479                 :     313288 :   ggc_delete (ipa_fn_summaries);
    4480                 :     313288 :   ipa_fn_summaries = NULL;
    4481                 :     313288 :   delete ipa_call_summaries;
    4482                 :     313288 :   ipa_call_summaries = NULL;
    4483                 :     313288 :   edge_predicate_pool.release ();
    4484                 :            :   /* During IPA this is one of largest datastructures to release.  */
    4485                 :     313288 :   if (flag_wpa)
    4486                 :       5022 :     ggc_trim ();
    4487                 :            : }
    4488                 :            : 
    4489                 :            : /* Release function summary.  */
    4490                 :            : 
    4491                 :            : void
    4492                 :     327922 : ipa_free_size_summary (void)
    4493                 :            : {
    4494                 :     327922 :   if (!ipa_size_summaries)
    4495                 :            :     return;
    4496                 :     313288 :   delete ipa_size_summaries;
    4497                 :     313288 :   ipa_size_summaries = NULL;
    4498                 :            : }
    4499                 :            : 
    4500                 :            : namespace {
    4501                 :            : 
    4502                 :            : const pass_data pass_data_local_fn_summary =
    4503                 :            : {
    4504                 :            :   GIMPLE_PASS, /* type */
    4505                 :            :   "local-fnsummary", /* name */
    4506                 :            :   OPTGROUP_INLINE, /* optinfo_flags */
    4507                 :            :   TV_INLINE_PARAMETERS, /* tv_id */
    4508                 :            :   0, /* properties_required */
    4509                 :            :   0, /* properties_provided */
    4510                 :            :   0, /* properties_destroyed */
    4511                 :            :   0, /* todo_flags_start */
    4512                 :            :   0, /* todo_flags_finish */
    4513                 :            : };
    4514                 :            : 
    4515                 :            : class pass_local_fn_summary : public gimple_opt_pass
    4516                 :            : {
    4517                 :            : public:
    4518                 :     401546 :   pass_local_fn_summary (gcc::context *ctxt)
    4519                 :     803092 :     : gimple_opt_pass (pass_data_local_fn_summary, ctxt)
    4520                 :            :   {}
    4521                 :            : 
    4522                 :            :   /* opt_pass methods: */
    4523                 :     200773 :   opt_pass * clone () { return new pass_local_fn_summary (m_ctxt); }
    4524                 :    3694450 :   virtual unsigned int execute (function *)
    4525                 :            :     {
    4526                 :    3694450 :       return compute_fn_summary_for_current ();
    4527                 :            :     }
    4528                 :            : 
    4529                 :            : }; // class pass_local_fn_summary
    4530                 :            : 
    4531                 :            : } // anon namespace
    4532                 :            : 
    4533                 :            : gimple_opt_pass *
    4534                 :     200773 : make_pass_local_fn_summary (gcc::context *ctxt)
    4535                 :            : {
    4536                 :     200773 :   return new pass_local_fn_summary (ctxt);
    4537                 :            : }
    4538                 :            : 
    4539                 :            : 
    4540                 :            : /* Free inline summary.  */
    4541                 :            : 
    4542                 :            : namespace {
    4543                 :            : 
    4544                 :            : const pass_data pass_data_ipa_free_fn_summary =
    4545                 :            : {
    4546                 :            :   SIMPLE_IPA_PASS, /* type */
    4547                 :            :   "free-fnsummary", /* name */
    4548                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    4549                 :            :   TV_IPA_FREE_INLINE_SUMMARY, /* tv_id */
    4550                 :            :   0, /* properties_required */
    4551                 :            :   0, /* properties_provided */
    4552                 :            :   0, /* properties_destroyed */
    4553                 :            :   0, /* todo_flags_start */
    4554                 :            :   0, /* todo_flags_finish */
    4555                 :            : };
    4556                 :            : 
    4557                 :            : class pass_ipa_free_fn_summary : public simple_ipa_opt_pass
    4558                 :            : {
    4559                 :            : public:
    4560                 :     401546 :   pass_ipa_free_fn_summary (gcc::context *ctxt)
    4561                 :     401546 :     : simple_ipa_opt_pass (pass_data_ipa_free_fn_summary, ctxt),
    4562                 :     803092 :       small_p (false)
    4563                 :            :   {}
    4564                 :            : 
    4565                 :            :   /* opt_pass methods: */
    4566                 :     200773 :   opt_pass *clone () { return new pass_ipa_free_fn_summary (m_ctxt); }
    4567                 :     401546 :   void set_pass_param (unsigned int n, bool param)
    4568                 :            :     {
    4569                 :     401546 :       gcc_assert (n == 0);
    4570                 :     401546 :       small_p = param;
    4571                 :     401546 :     }
    4572                 :     341133 :   virtual bool gate (function *) { return true; }
    4573                 :     327142 :   virtual unsigned int execute (function *)
    4574                 :            :     {
    4575                 :     327142 :       ipa_free_fn_summary ();
    4576                 :     327142 :       if (!flag_wpa)
    4577                 :     322120 :         ipa_free_size_summary ();
    4578                 :     327142 :       return 0;
    4579                 :            :     }
    4580                 :            : 
    4581                 :            : private:
    4582                 :            :   bool small_p;
    4583                 :            : }; // class pass_ipa_free_fn_summary
    4584                 :            : 
    4585                 :            : } // anon namespace
    4586                 :            : 
    4587                 :            : simple_ipa_opt_pass *
    4588                 :     200773 : make_pass_ipa_free_fn_summary (gcc::context *ctxt)
    4589                 :            : {
    4590                 :     200773 :   return new pass_ipa_free_fn_summary (ctxt);
    4591                 :            : }
    4592                 :            : 
    4593                 :            : namespace {
    4594                 :            : 
    4595                 :            : const pass_data pass_data_ipa_fn_summary =
    4596                 :            : {
    4597                 :            :   IPA_PASS, /* type */
    4598                 :            :   "fnsummary", /* name */
    4599                 :            :   OPTGROUP_INLINE, /* optinfo_flags */
    4600                 :            :   TV_IPA_FNSUMMARY, /* tv_id */
    4601                 :            :   0, /* properties_required */
    4602                 :            :   0, /* properties_provided */
    4603                 :            :   0, /* properties_destroyed */
    4604                 :            :   0, /* todo_flags_start */
    4605                 :            :   ( TODO_dump_symtab ), /* todo_flags_finish */
    4606                 :            : };
    4607                 :            : 
    4608                 :            : class pass_ipa_fn_summary : public ipa_opt_pass_d
    4609                 :            : {
    4610                 :            : public:
    4611                 :     200773 :   pass_ipa_fn_summary (gcc::context *ctxt)
    4612                 :            :     : ipa_opt_pass_d (pass_data_ipa_fn_summary, ctxt,
    4613                 :            :                       ipa_fn_summary_generate, /* generate_summary */
    4614                 :            :                       ipa_fn_summary_write, /* write_summary */
    4615                 :            :                       ipa_fn_summary_read, /* read_summary */
    4616                 :            :                       NULL, /* write_optimization_summary */
    4617                 :            :                       NULL, /* read_optimization_summary */
    4618                 :            :                       NULL, /* stmt_fixup */
    4619                 :            :                       0, /* function_transform_todo_flags_start */
    4620                 :            :                       NULL, /* function_transform */
    4621                 :     401546 :                       NULL) /* variable_transform */
    4622                 :            :   {}
    4623                 :            : 
    4624                 :            :   /* opt_pass methods: */
    4625                 :     163705 :   virtual unsigned int execute (function *) { return 0; }
    4626                 :            : 
    4627                 :            : }; // class pass_ipa_fn_summary
    4628                 :            : 
    4629                 :            : } // anon namespace
    4630                 :            : 
    4631                 :            : ipa_opt_pass_d *
    4632                 :     200773 : make_pass_ipa_fn_summary (gcc::context *ctxt)
    4633                 :            : {
    4634                 :     200773 :   return new pass_ipa_fn_summary (ctxt);
    4635                 :            : }
    4636                 :            : 
    4637                 :            : /* Reset all state within ipa-fnsummary.c so that we can rerun the compiler
    4638                 :            :    within the same process.  For use by toplev::finalize.  */
    4639                 :            : 
    4640                 :            : void
    4641                 :        903 : ipa_fnsummary_c_finalize (void)
    4642                 :            : {
    4643                 :        903 :   ipa_free_fn_summary ();
    4644                 :        903 : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.