LCOV - code coverage report
Current view: top level - gcc - ipa-pure-const.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 94.6 % 1080 1022
Test Date: 2024-09-28 13:20:55 Functions: 96.6 % 58 56
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: - 0 0

             Branch data     Line data    Source code
       1                 :             : /* Callgraph based analysis of static variables.
       2                 :             :    Copyright (C) 2004-2024 Free Software Foundation, Inc.
       3                 :             :    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
       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                 :             : /* This file marks functions as being either const (TREE_READONLY) or
      22                 :             :    pure (DECL_PURE_P).  It can also set a variant of these that
      23                 :             :    are allowed to loop indefinitely (DECL_LOOPING_CONST_PURE_P).
      24                 :             : 
      25                 :             :    This must be run after inlining decisions have been made since
      26                 :             :    otherwise, the local sets will not contain information that is
      27                 :             :    consistent with post inlined state.  The global sets are not prone
      28                 :             :    to this problem since they are by definition transitive.  */
      29                 :             : 
      30                 :             : /* The code in this module is called by the ipa pass manager. It
      31                 :             :    should be one of the later passes since it's information is used by
      32                 :             :    the rest of the compilation. */
      33                 :             : 
      34                 :             : #include "config.h"
      35                 :             : #include "system.h"
      36                 :             : #include "coretypes.h"
      37                 :             : #include "backend.h"
      38                 :             : #include "target.h"
      39                 :             : #include "tree.h"
      40                 :             : #include "gimple.h"
      41                 :             : #include "tree-pass.h"
      42                 :             : #include "tree-streamer.h"
      43                 :             : #include "cgraph.h"
      44                 :             : #include "diagnostic.h"
      45                 :             : #include "calls.h"
      46                 :             : #include "cfganal.h"
      47                 :             : #include "tree-eh.h"
      48                 :             : #include "gimple-iterator.h"
      49                 :             : #include "gimple-walk.h"
      50                 :             : #include "tree-cfg.h"
      51                 :             : #include "tree-ssa-loop-niter.h"
      52                 :             : #include "langhooks.h"
      53                 :             : #include "ipa-utils.h"
      54                 :             : #include "gimple-pretty-print.h"
      55                 :             : #include "cfgloop.h"
      56                 :             : #include "tree-scalar-evolution.h"
      57                 :             : #include "intl.h"
      58                 :             : #include "opts.h"
      59                 :             : #include "ssa.h"
      60                 :             : #include "alloc-pool.h"
      61                 :             : #include "symbol-summary.h"
      62                 :             : #include "sreal.h"
      63                 :             : #include "ipa-cp.h"
      64                 :             : #include "ipa-prop.h"
      65                 :             : #include "ipa-fnsummary.h"
      66                 :             : #include "symtab-thunks.h"
      67                 :             : #include "dbgcnt.h"
      68                 :             : 
      69                 :             : /* Lattice values for const and pure functions.  Everything starts out
      70                 :             :    being const, then may drop to pure and then neither depending on
      71                 :             :    what is found.  */
      72                 :             : enum pure_const_state_e
      73                 :             : {
      74                 :             :   IPA_CONST,
      75                 :             :   IPA_PURE,
      76                 :             :   IPA_NEITHER
      77                 :             : };
      78                 :             : 
      79                 :             : static const char *pure_const_names[3] = {"const", "pure", "neither"};
      80                 :             : 
      81                 :             : enum malloc_state_e
      82                 :             : {
      83                 :             :   STATE_MALLOC_TOP,
      84                 :             :   STATE_MALLOC,
      85                 :             :   STATE_MALLOC_BOTTOM
      86                 :             : };
      87                 :             : 
      88                 :             : static const char *malloc_state_names[] = {"malloc_top", "malloc", "malloc_bottom"};
      89                 :             : 
      90                 :             : /* Holder for the const_state.  There is one of these per function
      91                 :             :    decl.  */
      92                 :             : class funct_state_d
      93                 :             : {
      94                 :             : public:
      95                 :     2449802 :   funct_state_d (): pure_const_state (IPA_NEITHER),
      96                 :     2449802 :     state_previously_known (IPA_NEITHER), looping_previously_known (true),
      97                 :     2449802 :     looping (true), can_throw (true), can_free (true),
      98                 :           0 :     malloc_state (STATE_MALLOC_BOTTOM) {}
      99                 :             : 
     100                 :     2343937 :   funct_state_d (const funct_state_d &s): pure_const_state (s.pure_const_state),
     101                 :     2343937 :     state_previously_known (s.state_previously_known),
     102                 :     2343937 :     looping_previously_known (s.looping_previously_known),
     103                 :     2343937 :     looping (s.looping), can_throw (s.can_throw), can_free (s.can_free),
     104                 :     2343937 :     malloc_state (s.malloc_state) {}
     105                 :             : 
     106                 :             :   /* See above.  */
     107                 :             :   enum pure_const_state_e pure_const_state;
     108                 :             :   /* What user set here; we can be always sure about this.  */
     109                 :             :   enum pure_const_state_e state_previously_known;
     110                 :             :   bool looping_previously_known;
     111                 :             : 
     112                 :             :   /* True if the function could possibly infinite loop.  There are a
     113                 :             :      lot of ways that this could be determined.  We are pretty
     114                 :             :      conservative here.  While it is possible to cse pure and const
     115                 :             :      calls, it is not legal to have dce get rid of the call if there
     116                 :             :      is a possibility that the call could infinite loop since this is
     117                 :             :      a behavioral change.  */
     118                 :             :   bool looping;
     119                 :             : 
     120                 :             :   bool can_throw;
     121                 :             : 
     122                 :             :   /* If function can call free, munmap or otherwise make previously
     123                 :             :      non-trapping memory accesses trapping.  */
     124                 :             :   bool can_free;
     125                 :             : 
     126                 :             :   enum malloc_state_e malloc_state;
     127                 :             : };
     128                 :             : 
     129                 :             : typedef class funct_state_d * funct_state;
     130                 :             : 
     131                 :             : /* The storage of the funct_state is abstracted because there is the
     132                 :             :    possibility that it may be desirable to move this to the cgraph
     133                 :             :    local info.  */
     134                 :             : 
     135                 :             : class funct_state_summary_t:
     136                 :             :   public fast_function_summary <funct_state_d *, va_heap>
     137                 :             : {
     138                 :             : public:
     139                 :      153686 :   funct_state_summary_t (symbol_table *symtab):
     140                 :      307372 :     fast_function_summary <funct_state_d *, va_heap> (symtab) {}
     141                 :             : 
     142                 :             :   void insert (cgraph_node *, funct_state_d *state) final override;
     143                 :             :   void duplicate (cgraph_node *src_node, cgraph_node *dst_node,
     144                 :             :                   funct_state_d *src_data,
     145                 :             :                   funct_state_d *dst_data) final override;
     146                 :             : };
     147                 :             : 
     148                 :             : static funct_state_summary_t *funct_state_summaries = NULL;
     149                 :             : 
     150                 :             : static bool gate_pure_const (void);
     151                 :             : 
     152                 :             : namespace {
     153                 :             : 
     154                 :             : const pass_data pass_data_ipa_pure_const =
     155                 :             : {
     156                 :             :   IPA_PASS, /* type */
     157                 :             :   "pure-const", /* name */
     158                 :             :   OPTGROUP_NONE, /* optinfo_flags */
     159                 :             :   TV_IPA_PURE_CONST, /* tv_id */
     160                 :             :   0, /* properties_required */
     161                 :             :   0, /* properties_provided */
     162                 :             :   0, /* properties_destroyed */
     163                 :             :   0, /* todo_flags_start */
     164                 :             :   0, /* todo_flags_finish */
     165                 :             : };
     166                 :             : 
     167                 :             : class pass_ipa_pure_const : public ipa_opt_pass_d
     168                 :             : {
     169                 :             : public:
     170                 :             :   pass_ipa_pure_const(gcc::context *ctxt);
     171                 :             : 
     172                 :             :   /* opt_pass methods: */
     173                 :     1130554 :   bool gate (function *) final override { return gate_pure_const (); }
     174                 :             :   unsigned int execute (function *fun) final override;
     175                 :             : 
     176                 :             :   void register_hooks (void);
     177                 :             : 
     178                 :             : private:
     179                 :             :   bool init_p;
     180                 :             : }; // class pass_ipa_pure_const
     181                 :             : 
     182                 :             : } // anon namespace
     183                 :             : 
     184                 :             : /* Try to guess if function body will always be visible to compiler
     185                 :             :    when compiling the call and whether compiler will be able
     186                 :             :    to propagate the information by itself.  */
     187                 :             : 
     188                 :             : static bool
     189                 :          26 : function_always_visible_to_compiler_p (tree decl)
     190                 :             : {
     191                 :          22 :   return (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl)
     192                 :          48 :           || DECL_COMDAT (decl));
     193                 :             : }
     194                 :             : 
     195                 :             : /* Emit suggestion about attribute ATTRIB_NAME for DECL.  KNOWN_FINITE
     196                 :             :    is true if the function is known to be finite.  The diagnostic is
     197                 :             :    controlled by OPTION.  WARNED_ABOUT is a hash_set<tree> unique for
     198                 :             :    OPTION, this function may initialize it and it is always returned
     199                 :             :    by the function.  */
     200                 :             : 
     201                 :             : static hash_set<tree> *
     202                 :     1131798 : suggest_attribute (diagnostic_option_id option, tree decl, bool known_finite,
     203                 :             :                    hash_set<tree> *warned_about,
     204                 :             :                    const char * attrib_name)
     205                 :             : {
     206                 :     1131798 :   if (!option_enabled (option.m_idx, lang_hooks.option_lang_mask (),
     207                 :             :                        &global_options))
     208                 :             :     return warned_about;
     209                 :          30 :   if (TREE_THIS_VOLATILE (decl)
     210                 :          30 :       || (known_finite && function_always_visible_to_compiler_p (decl)))
     211                 :             :     return warned_about;
     212                 :             : 
     213                 :          26 :   if (!warned_about)
     214                 :          14 :     warned_about = new hash_set<tree>;
     215                 :          26 :   if (warned_about->contains (decl))
     216                 :             :     return warned_about;
     217                 :          26 :   warned_about->add (decl);
     218                 :          30 :   warning_at (DECL_SOURCE_LOCATION (decl),
     219                 :             :               option,
     220                 :             :               known_finite
     221                 :             :               ? G_("function might be candidate for attribute %qs")
     222                 :             :               : G_("function might be candidate for attribute %qs"
     223                 :             :                    " if it is known to return normally"), attrib_name);
     224                 :          26 :   return warned_about;
     225                 :             : }
     226                 :             : 
     227                 :             : /* Emit suggestion about __attribute_((pure)) for DECL.  KNOWN_FINITE
     228                 :             :    is true if the function is known to be finite.  */
     229                 :             : 
     230                 :             : static void
     231                 :      321398 : warn_function_pure (tree decl, bool known_finite)
     232                 :             : {
     233                 :             :   /* Declaring a void function pure makes no sense and is diagnosed
     234                 :             :      by -Wattributes because calling it would have no effect.  */
     235                 :      321398 :   if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
     236                 :             :     return;
     237                 :             : 
     238                 :      294487 :   static hash_set<tree> *warned_about;
     239                 :      294487 :   warned_about
     240                 :      294487 :     = suggest_attribute (OPT_Wsuggest_attribute_pure, decl,
     241                 :             :                          known_finite, warned_about, "pure");
     242                 :             : }
     243                 :             : 
     244                 :             : /* Emit suggestion about __attribute_((const)) for DECL.  KNOWN_FINITE
     245                 :             :    is true if the function is known to be finite.  */
     246                 :             : 
     247                 :             : static void
     248                 :      880752 : warn_function_const (tree decl, bool known_finite)
     249                 :             : {
     250                 :             :   /* Declaring a void function const makes no sense is diagnosed
     251                 :             :      by -Wattributes because calling it would have no effect.  */
     252                 :      880752 :   if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (decl))))
     253                 :             :     return;
     254                 :             : 
     255                 :      621223 :   static hash_set<tree> *warned_about;
     256                 :      621223 :   warned_about
     257                 :      621223 :     = suggest_attribute (OPT_Wsuggest_attribute_const, decl,
     258                 :             :                          known_finite, warned_about, "const");
     259                 :             : }
     260                 :             : 
     261                 :             : /* Emit suggestion about __attribute__((malloc)) for DECL.  */
     262                 :             : 
     263                 :             : static void
     264                 :           3 : warn_function_malloc (tree decl)
     265                 :             : {
     266                 :           3 :   static hash_set<tree> *warned_about;
     267                 :           3 :   warned_about
     268                 :           3 :     = suggest_attribute (OPT_Wsuggest_attribute_malloc, decl,
     269                 :             :                          true, warned_about, "malloc");
     270                 :           3 : }
     271                 :             : 
     272                 :             : /* Emit suggestion about __attribute__((noreturn)) for DECL.  */
     273                 :             : 
     274                 :             : static void
     275                 :       29802 : warn_function_noreturn (tree decl)
     276                 :             : {
     277                 :       29802 :   tree original_decl = decl;
     278                 :             : 
     279                 :       29802 :   static hash_set<tree> *warned_about;
     280                 :       29802 :   if (!lang_hooks.missing_noreturn_ok_p (decl)
     281                 :       29802 :       && targetm.warn_func_return (decl))
     282                 :       18265 :     warned_about
     283                 :       18265 :       = suggest_attribute (OPT_Wsuggest_attribute_noreturn, original_decl,
     284                 :             :                            true, warned_about, "noreturn");
     285                 :       29802 : }
     286                 :             : 
     287                 :             : void
     288                 :       12998 : warn_function_cold (tree decl)
     289                 :             : {
     290                 :       12998 :   tree original_decl = decl;
     291                 :             : 
     292                 :       12998 :   static hash_set<tree> *warned_about;
     293                 :       12998 :   warned_about
     294                 :       12998 :     = suggest_attribute (OPT_Wsuggest_attribute_cold, original_decl,
     295                 :             :                          true, warned_about, "cold");
     296                 :       12998 : }
     297                 :             : 
     298                 :             : void
     299                 :      184822 : warn_function_returns_nonnull (tree decl)
     300                 :             : {
     301                 :      184822 :   static hash_set<tree> *warned_about;
     302                 :      184822 :   warned_about
     303                 :      184822 :     = suggest_attribute (OPT_Wsuggest_attribute_returns_nonnull, decl,
     304                 :             :                          true, warned_about, "returns_nonnull");
     305                 :      184822 : }
     306                 :             : 
     307                 :             : /* Check to see if the use (or definition when CHECKING_WRITE is true)
     308                 :             :    variable T is legal in a function that is either pure or const.  */
     309                 :             : 
     310                 :             : static inline void
     311                 :    20178548 : check_decl (funct_state local,
     312                 :             :             tree t, bool checking_write, bool ipa)
     313                 :             : {
     314                 :             :   /* Do not want to do anything with volatile except mark any
     315                 :             :      function that uses one to be not const or pure.  */
     316                 :    20178548 :   if (TREE_THIS_VOLATILE (t))
     317                 :             :     {
     318                 :     1440240 :       local->pure_const_state = IPA_NEITHER;
     319                 :     1440240 :       if (dump_file)
     320                 :          30 :         fprintf (dump_file, "    Volatile operand is not const/pure\n");
     321                 :     1440240 :       return;
     322                 :             :     }
     323                 :             : 
     324                 :             :   /* Do not care about a local automatic that is not static.  */
     325                 :    18738308 :   if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
     326                 :             :     return;
     327                 :             : 
     328                 :             :   /* If the variable has the "used" attribute, treat it as if it had a
     329                 :             :      been touched by the devil.  */
     330                 :     3352192 :   if (DECL_PRESERVE_P (t))
     331                 :             :     {
     332                 :        2990 :       local->pure_const_state = IPA_NEITHER;
     333                 :        2990 :       if (dump_file)
     334                 :           0 :         fprintf (dump_file, "    Used static/global variable is not const/pure\n");
     335                 :        2990 :       return;
     336                 :             :     }
     337                 :             : 
     338                 :             :   /* In IPA mode we are not interested in checking actual loads and stores;
     339                 :             :      they will be processed at propagation time using ipa_ref.  */
     340                 :     3349202 :   if (ipa)
     341                 :             :     return;
     342                 :             : 
     343                 :             :   /* Since we have dealt with the locals and params cases above, if we
     344                 :             :      are CHECKING_WRITE, this cannot be a pure or constant
     345                 :             :      function.  */
     346                 :     2155809 :   if (checking_write)
     347                 :             :     {
     348                 :      779956 :       local->pure_const_state = IPA_NEITHER;
     349                 :      779956 :       if (dump_file)
     350                 :           1 :         fprintf (dump_file, "    static/global memory write is not const/pure\n");
     351                 :      779956 :       return;
     352                 :             :     }
     353                 :             : 
     354                 :     1375853 :   if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
     355                 :             :     {
     356                 :             :       /* Readonly reads are safe.  */
     357                 :      791819 :       if (TREE_READONLY (t))
     358                 :             :         return; /* Read of a constant, do not change the function state.  */
     359                 :             :       else
     360                 :             :         {
     361                 :      788285 :           if (dump_file)
     362                 :           0 :             fprintf (dump_file, "    global memory read is not const\n");
     363                 :             :           /* Just a regular read.  */
     364                 :      788285 :           if (local->pure_const_state == IPA_CONST)
     365                 :      160729 :             local->pure_const_state = IPA_PURE;
     366                 :             :         }
     367                 :             :     }
     368                 :             :   else
     369                 :             :     {
     370                 :             :       /* Compilation level statics can be read if they are readonly
     371                 :             :          variables.  */
     372                 :      584034 :       if (TREE_READONLY (t))
     373                 :             :         return;
     374                 :             : 
     375                 :      558321 :       if (dump_file)
     376                 :           1 :         fprintf (dump_file, "    static memory read is not const\n");
     377                 :             :       /* Just a regular read.  */
     378                 :      558321 :       if (local->pure_const_state == IPA_CONST)
     379                 :       31537 :         local->pure_const_state = IPA_PURE;
     380                 :             :     }
     381                 :             : }
     382                 :             : 
     383                 :             : 
     384                 :             : /* Check to see if the use (or definition when CHECKING_WRITE is true)
     385                 :             :    variable T is legal in a function that is either pure or const.  */
     386                 :             : 
     387                 :             : static inline void
     388                 :    16173753 : check_op (funct_state local, tree t, bool checking_write)
     389                 :             : {
     390                 :    16173753 :   t = get_base_address (t);
     391                 :    16173753 :   if (t && TREE_THIS_VOLATILE (t))
     392                 :             :     {
     393                 :       32453 :       local->pure_const_state = IPA_NEITHER;
     394                 :       32453 :       if (dump_file)
     395                 :           2 :         fprintf (dump_file, "    Volatile indirect ref is not const/pure\n");
     396                 :       32453 :       return;
     397                 :             :     }
     398                 :    16141300 :   else if (refs_local_or_readonly_memory_p (t))
     399                 :             :     {
     400                 :     3504162 :       if (dump_file)
     401                 :          10 :         fprintf (dump_file, "    Indirect ref to local or readonly "
     402                 :             :                  "memory is OK\n");
     403                 :     3504162 :       return;
     404                 :             :     }
     405                 :    12637138 :   else if (checking_write)
     406                 :             :     {
     407                 :     4453519 :       local->pure_const_state = IPA_NEITHER;
     408                 :     4453519 :       if (dump_file)
     409                 :          65 :         fprintf (dump_file, "    Indirect ref write is not const/pure\n");
     410                 :     4453519 :       return;
     411                 :             :     }
     412                 :             :   else
     413                 :             :     {
     414                 :     8183619 :       if (dump_file)
     415                 :         175 :         fprintf (dump_file, "    Indirect ref read is not const\n");
     416                 :     8183619 :       if (local->pure_const_state == IPA_CONST)
     417                 :     1179142 :         local->pure_const_state = IPA_PURE;
     418                 :             :     }
     419                 :             : }
     420                 :             : 
     421                 :             : /* compute state based on ECF FLAGS and store to STATE and LOOPING.  */
     422                 :             : 
     423                 :             : static void
     424                 :    14757682 : state_from_flags (enum pure_const_state_e *state, bool *looping,
     425                 :             :                   int flags, bool cannot_lead_to_return)
     426                 :             : {
     427                 :    14757682 :   *looping = false;
     428                 :    14757682 :   if (flags & ECF_LOOPING_CONST_OR_PURE)
     429                 :             :     {
     430                 :      192525 :       *looping = true;
     431                 :      192525 :       if (dump_file && (dump_flags & TDF_DETAILS))
     432                 :           0 :         fprintf (dump_file, " looping\n");
     433                 :             :     }
     434                 :    14757682 :   if (flags & ECF_CONST)
     435                 :             :     {
     436                 :     1044620 :       *state = IPA_CONST;
     437                 :     1044620 :       if (dump_file && (dump_flags & TDF_DETAILS))
     438                 :           3 :         fprintf (dump_file, " const\n");
     439                 :             :     }
     440                 :    13713062 :   else if (flags & ECF_PURE)
     441                 :             :     {
     442                 :     1148727 :       *state = IPA_PURE;
     443                 :     1148727 :       if (dump_file && (dump_flags & TDF_DETAILS))
     444                 :           3 :         fprintf (dump_file, " pure\n");
     445                 :             :     }
     446                 :    12564335 :   else if (cannot_lead_to_return)
     447                 :             :     {
     448                 :      886645 :       *state = IPA_PURE;
     449                 :      886645 :       *looping = true;
     450                 :      886645 :       if (dump_file && (dump_flags & TDF_DETAILS))
     451                 :           1 :         fprintf (dump_file, " ignoring side effects->pure looping\n");
     452                 :             :     }
     453                 :             :   else
     454                 :             :     {
     455                 :    11677690 :       if (dump_file && (dump_flags & TDF_DETAILS))
     456                 :          42 :         fprintf (dump_file, " neither\n");
     457                 :    11677690 :       *state = IPA_NEITHER;
     458                 :    11677690 :       *looping = true;
     459                 :             :     }
     460                 :    14757682 : }
     461                 :             : 
     462                 :             : /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
     463                 :             :    into STATE and LOOPING better of the two variants.
     464                 :             :    Be sure to merge looping correctly.  IPA_NEITHER functions
     465                 :             :    have looping 0 even if they don't have to return.  */
     466                 :             : 
     467                 :             : static inline void
     468                 :     6405428 : better_state (enum pure_const_state_e *state, bool *looping,
     469                 :             :               enum pure_const_state_e state2, bool looping2)
     470                 :             : {
     471                 :     6405428 :   if (state2 < *state)
     472                 :             :     {
     473                 :       30131 :       if (*state == IPA_NEITHER)
     474                 :       29410 :         *looping = looping2;
     475                 :             :       else
     476                 :        1442 :         *looping = MIN (*looping, looping2);
     477                 :       30131 :       *state = state2;
     478                 :             :     }
     479                 :     6375297 :   else if (state2 != IPA_NEITHER)
     480                 :     1867202 :     *looping = MIN (*looping, looping2);
     481                 :     6405428 : }
     482                 :             : 
     483                 :             : /* Merge STATE and STATE2 and LOOPING and LOOPING2 and store
     484                 :             :    into STATE and LOOPING worse of the two variants.
     485                 :             :    N is the actual node called.  */
     486                 :             : 
     487                 :             : static inline void
     488                 :    13661034 : worse_state (enum pure_const_state_e *state, bool *looping,
     489                 :             :              enum pure_const_state_e state2, bool looping2,
     490                 :             :              struct symtab_node *from,
     491                 :             :              struct symtab_node *to)
     492                 :             : {
     493                 :             :   /* Consider function:
     494                 :             : 
     495                 :             :      bool a(int *p)
     496                 :             :      {
     497                 :             :        return *p==*p;
     498                 :             :      }
     499                 :             : 
     500                 :             :      During early optimization we will turn this into:
     501                 :             : 
     502                 :             :      bool a(int *p)
     503                 :             :      {
     504                 :             :        return true;
     505                 :             :      }
     506                 :             : 
     507                 :             :      Now if this function will be detected as CONST however when interposed it
     508                 :             :      may end up being just pure.  We always must assume the worst scenario here.
     509                 :             :    */
     510                 :    13661034 :   if (*state == IPA_CONST && state2 == IPA_CONST
     511                 :    13661034 :       && to && !TREE_READONLY (to->decl) && !to->binds_to_current_def_p (from))
     512                 :             :     {
     513                 :        2679 :       if (dump_file && (dump_flags & TDF_DETAILS))
     514                 :           0 :         fprintf (dump_file, "Dropping state to PURE because call to %s may not "
     515                 :             :                  "bind to current def.\n", to->dump_name ());
     516                 :             :       state2 = IPA_PURE;
     517                 :             :     }
     518                 :    13661034 :   *state = MAX (*state, state2);
     519                 :    13661034 :   *looping = MAX (*looping, looping2);
     520                 :    13661034 : }
     521                 :             : 
     522                 :             : /* Recognize special cases of builtins that are by themselves not const
     523                 :             :    but function using them is.  */
     524                 :             : bool
     525                 :    22194602 : builtin_safe_for_const_function_p (bool *looping, tree callee)
     526                 :             : {
     527                 :    22194602 :   if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
     528                 :     5929980 :     switch (DECL_FUNCTION_CODE (callee))
     529                 :             :       {
     530                 :      531565 :       case BUILT_IN_RETURN:
     531                 :      531565 :       case BUILT_IN_UNREACHABLE:
     532                 :      531565 :       CASE_BUILT_IN_ALLOCA:
     533                 :      531565 :       case BUILT_IN_STACK_SAVE:
     534                 :      531565 :       case BUILT_IN_STACK_RESTORE:
     535                 :      531565 :       case BUILT_IN_EH_POINTER:
     536                 :      531565 :       case BUILT_IN_EH_FILTER:
     537                 :      531565 :       case BUILT_IN_UNWIND_RESUME:
     538                 :      531565 :       case BUILT_IN_CXA_END_CLEANUP:
     539                 :      531565 :       case BUILT_IN_EH_COPY_VALUES:
     540                 :      531565 :       case BUILT_IN_FRAME_ADDRESS:
     541                 :      531565 :       case BUILT_IN_APPLY_ARGS:
     542                 :      531565 :       case BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT:
     543                 :      531565 :       case BUILT_IN_ASAN_AFTER_DYNAMIC_INIT:
     544                 :      531565 :       case BUILT_IN_DWARF_CFA:
     545                 :      531565 :       case BUILT_IN_RETURN_ADDRESS:
     546                 :      531565 :         *looping = false;
     547                 :      531565 :         return true;
     548                 :       10103 :       case BUILT_IN_PREFETCH:
     549                 :       10103 :         *looping = true;
     550                 :       10103 :         return true;
     551                 :             :       default:
     552                 :             :         break;
     553                 :             :       }
     554                 :             :   return false;
     555                 :             : }
     556                 :             : 
     557                 :             : /* Check the parameters of a function call to CALL_EXPR to see if
     558                 :             :    there are any references in the parameters that are not allowed for
     559                 :             :    pure or const functions.  Also check to see if this is either an
     560                 :             :    indirect call, a call outside the compilation unit, or has special
     561                 :             :    attributes that may also effect the purity.  The CALL_EXPR node for
     562                 :             :    the entire call expression.  */
     563                 :             : 
     564                 :             : static void
     565                 :    14438659 : check_call (funct_state local, gcall *call, bool ipa)
     566                 :             : {
     567                 :    14438659 :   int flags = gimple_call_flags (call);
     568                 :    14438659 :   tree callee_t = gimple_call_fndecl (call);
     569                 :    14438659 :   bool possibly_throws = stmt_could_throw_p (cfun, call);
     570                 :    14438659 :   bool possibly_throws_externally = (possibly_throws
     571                 :    14438659 :                                      && stmt_can_throw_external (cfun, call));
     572                 :             : 
     573                 :     5400058 :   if (possibly_throws)
     574                 :             :     {
     575                 :             :       unsigned int i;
     576                 :    32381806 :       for (i = 0; i < gimple_num_ops (call); i++)
     577                 :    26981748 :         if (gimple_op (call, i)
     578                 :    26981748 :             && tree_could_throw_p (gimple_op (call, i)))
     579                 :             :           {
     580                 :       80180 :             if (possibly_throws && cfun->can_throw_non_call_exceptions)
     581                 :             :               {
     582                 :       80180 :                 if (dump_file)
     583                 :           0 :                   fprintf (dump_file, "    operand can throw; looping\n");
     584                 :       80180 :                 local->looping = true;
     585                 :             :               }
     586                 :       80180 :             if (possibly_throws_externally)
     587                 :             :               {
     588                 :       66824 :                 if (dump_file)
     589                 :           0 :                   fprintf (dump_file, "    operand can throw externally\n");
     590                 :       66824 :                 local->can_throw = true;
     591                 :             :               }
     592                 :             :           }
     593                 :             :     }
     594                 :             : 
     595                 :             :   /* The const and pure flags are set by a variety of places in the
     596                 :             :      compiler (including here).  If someone has already set the flags
     597                 :             :      for the callee, (such as for some of the builtins) we will use
     598                 :             :      them, otherwise we will compute our own information.
     599                 :             : 
     600                 :             :      Const and pure functions have less clobber effects than other
     601                 :             :      functions so we process these first.  Otherwise if it is a call
     602                 :             :      outside the compilation unit or an indirect call we punt.  This
     603                 :             :      leaves local calls which will be processed by following the call
     604                 :             :      graph.  */
     605                 :    14438659 :   if (callee_t)
     606                 :             :     {
     607                 :    13529954 :       bool call_looping;
     608                 :             : 
     609                 :    13529954 :       if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
     610                 :    13529954 :           && !nonfreeing_call_p (call))
     611                 :      641928 :         local->can_free = true;
     612                 :             : 
     613                 :    13529954 :       if (builtin_safe_for_const_function_p (&call_looping, callee_t))
     614                 :             :         {
     615                 :      176432 :           worse_state (&local->pure_const_state, &local->looping,
     616                 :             :                        IPA_CONST, call_looping,
     617                 :             :                        NULL, NULL);
     618                 :      176432 :           return;
     619                 :             :         }
     620                 :             :       /* When bad things happen to bad functions, they cannot be const
     621                 :             :          or pure.  */
     622                 :    13353522 :       if (setjmp_call_p (callee_t))
     623                 :             :         {
     624                 :        2474 :           if (dump_file)
     625                 :           0 :             fprintf (dump_file, "    setjmp is not const/pure\n");
     626                 :        2474 :           local->looping = true;
     627                 :        2474 :           local->pure_const_state = IPA_NEITHER;
     628                 :             :         }
     629                 :             : 
     630                 :    13353522 :       if (DECL_BUILT_IN_CLASS (callee_t) == BUILT_IN_NORMAL)
     631                 :     3093583 :         switch (DECL_FUNCTION_CODE (callee_t))
     632                 :             :           {
     633                 :        1856 :           case BUILT_IN_LONGJMP:
     634                 :        1856 :           case BUILT_IN_NONLOCAL_GOTO:
     635                 :        1856 :             if (dump_file)
     636                 :           0 :               fprintf (dump_file,
     637                 :             :                        "    longjmp and nonlocal goto is not const/pure\n");
     638                 :        1856 :             local->pure_const_state = IPA_NEITHER;
     639                 :        1856 :             local->looping = true;
     640                 :        1856 :             break;
     641                 :             :           default:
     642                 :             :             break;
     643                 :             :           }
     644                 :             :     }
     645                 :      908705 :   else if (gimple_call_internal_p (call) && !nonfreeing_call_p (call))
     646                 :      139129 :     local->can_free = true;
     647                 :             : 
     648                 :             :   /* When not in IPA mode, we can still handle self recursion.  */
     649                 :    14262227 :   if (!ipa && callee_t
     650                 :    14262227 :       && recursive_call_p (current_function_decl, callee_t))
     651                 :             :     {
     652                 :       19048 :       if (dump_file)
     653                 :           0 :         fprintf (dump_file, "    Recursive call can loop.\n");
     654                 :       19048 :       local->looping = true;
     655                 :             :     }
     656                 :             :   /* Either callee is unknown or we are doing local analysis.
     657                 :             :      Look to see if there are any bits available for the callee (such as by
     658                 :             :      declaration or because it is builtin) and process solely on the basis of
     659                 :             :      those bits.  Handle internal calls always, those calls don't have
     660                 :             :      corresponding cgraph edges and thus aren't processed during
     661                 :             :      the propagation.  */
     662                 :    14243179 :   else if (!ipa || gimple_call_internal_p (call))
     663                 :             :     {
     664                 :     9314900 :       enum pure_const_state_e call_state;
     665                 :     9314900 :       bool call_looping;
     666                 :     9314900 :       if (possibly_throws && cfun->can_throw_non_call_exceptions)
     667                 :             :         {
     668                 :     2147013 :           if (dump_file)
     669                 :           0 :             fprintf (dump_file, "    can throw; looping\n");
     670                 :     2147013 :           local->looping = true;
     671                 :             :         }
     672                 :     9314900 :       if (possibly_throws_externally)
     673                 :             :         {
     674                 :     2509755 :           if (dump_file)
     675                 :             :             {
     676                 :           0 :               fprintf (dump_file, "    can throw externally to lp %i\n",
     677                 :             :                        lookup_stmt_eh_lp (call));
     678                 :           0 :               if (callee_t)
     679                 :           0 :                 fprintf (dump_file, "     callee:%s\n",
     680                 :           0 :                          IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (callee_t)));
     681                 :             :             }
     682                 :     2509755 :           local->can_throw = true;
     683                 :             :         }
     684                 :     9314900 :       if (dump_file && (dump_flags & TDF_DETAILS))
     685                 :          22 :         fprintf (dump_file, "    checking flags for call:");
     686                 :     9314900 :       state_from_flags (&call_state, &call_looping, flags,
     687                 :     9314900 :                         ((flags & (ECF_NORETURN | ECF_NOTHROW))
     688                 :             :                          == (ECF_NORETURN | ECF_NOTHROW))
     689                 :     9314900 :                         || (!flag_exceptions && (flags & ECF_NORETURN)));
     690                 :     9314900 :       worse_state (&local->pure_const_state, &local->looping,
     691                 :             :                    call_state, call_looping, NULL, NULL);
     692                 :             :     }
     693                 :             :   /* Direct functions calls are handled by IPA propagation.  */
     694                 :             : }
     695                 :             : 
     696                 :             : /* Wrapper around check_decl for loads in local more.  */
     697                 :             : 
     698                 :             : static bool
     699                 :    11677775 : check_load (gimple *, tree op, tree, void *data)
     700                 :             : {
     701                 :    11677775 :   if (DECL_P (op))
     702                 :     5252322 :     check_decl ((funct_state)data, op, false, false);
     703                 :             :   else
     704                 :     6425453 :     check_op ((funct_state)data, op, false);
     705                 :    11677775 :   return false;
     706                 :             : }
     707                 :             : 
     708                 :             : /* Wrapper around check_decl for stores in local more.  */
     709                 :             : 
     710                 :             : static bool
     711                 :    12776746 : check_store (gimple *, tree op, tree, void *data)
     712                 :             : {
     713                 :    12776746 :   if (DECL_P (op))
     714                 :     7781422 :     check_decl ((funct_state)data, op, true, false);
     715                 :             :   else
     716                 :     4995324 :     check_op ((funct_state)data, op, true);
     717                 :    12776746 :   return false;
     718                 :             : }
     719                 :             : 
     720                 :             : /* Wrapper around check_decl for loads in ipa mode.  */
     721                 :             : 
     722                 :             : static bool
     723                 :     5855085 : check_ipa_load (gimple *, tree op, tree, void *data)
     724                 :             : {
     725                 :     5855085 :   if (DECL_P (op))
     726                 :     2990370 :     check_decl ((funct_state)data, op, false, true);
     727                 :             :   else
     728                 :     2864715 :     check_op ((funct_state)data, op, false);
     729                 :     5855085 :   return false;
     730                 :             : }
     731                 :             : 
     732                 :             : /* Wrapper around check_decl for stores in ipa mode.  */
     733                 :             : 
     734                 :             : static bool
     735                 :     6042695 : check_ipa_store (gimple *, tree op, tree, void *data)
     736                 :             : {
     737                 :     6042695 :   if (DECL_P (op))
     738                 :     4154434 :     check_decl ((funct_state)data, op, true, true);
     739                 :             :   else
     740                 :     1888261 :     check_op ((funct_state)data, op, true);
     741                 :     6042695 :   return false;
     742                 :             : }
     743                 :             : 
     744                 :             : /* Look into pointer pointed to by GSIP and figure out what interesting side
     745                 :             :    effects it has.  */
     746                 :             : static void
     747                 :   162467504 : check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
     748                 :             : {
     749                 :   162467504 :   gimple *stmt = gsi_stmt (*gsip);
     750                 :             : 
     751                 :   162467504 :   if (is_gimple_debug (stmt))
     752                 :             :     return;
     753                 :             : 
     754                 :             :   /* Do consider clobber as side effects before IPA, so we rather inline
     755                 :             :      C++ destructors and keep clobber semantics than eliminate them.
     756                 :             : 
     757                 :             :      Similar logic is in ipa-modref.
     758                 :             : 
     759                 :             :      TODO: We may get smarter during early optimizations on these and let
     760                 :             :      functions containing only clobbers to be optimized more.  This is a common
     761                 :             :      case of C++ destructors.  */
     762                 :             : 
     763                 :    86383600 :   if ((ipa || cfun->after_inlining) && gimple_clobber_p (stmt))
     764                 :             :     return;
     765                 :             : 
     766                 :    84113882 :   if (dump_file)
     767                 :             :     {
     768                 :        1711 :       fprintf (dump_file, "  scanning: ");
     769                 :        1711 :       print_gimple_stmt (dump_file, stmt, 0);
     770                 :             :     }
     771                 :             : 
     772                 :    84113882 :   if (gimple_has_volatile_ops (stmt)
     773                 :    71836130 :       && !gimple_clobber_p (stmt))
     774                 :             :     {
     775                 :     1483006 :       local->pure_const_state = IPA_NEITHER;
     776                 :     1483006 :       if (dump_file)
     777                 :          33 :         fprintf (dump_file, "    Volatile stmt is not const/pure\n");
     778                 :             :     }
     779                 :             : 
     780                 :             :   /* Look for loads and stores.  */
     781                 :   140921877 :   walk_stmt_load_store_ops (stmt, local,
     782                 :             :                             ipa ? check_ipa_load : check_load,
     783                 :             :                             ipa ? check_ipa_store :  check_store);
     784                 :             : 
     785                 :    84113882 :   if (gimple_code (stmt) != GIMPLE_CALL
     786                 :    84113882 :       && stmt_could_throw_p (cfun, stmt))
     787                 :             :     {
     788                 :     2519184 :       if (cfun->can_throw_non_call_exceptions)
     789                 :             :         {
     790                 :     2213224 :           if (dump_file)
     791                 :           0 :             fprintf (dump_file, "    can throw; looping\n");
     792                 :     2213224 :           local->looping = true;
     793                 :             :         }
     794                 :     2519184 :       if (stmt_can_throw_external (cfun, stmt))
     795                 :             :         {
     796                 :     2083001 :           if (dump_file)
     797                 :           6 :             fprintf (dump_file, "    can throw externally\n");
     798                 :     2083001 :           local->can_throw = true;
     799                 :             :         }
     800                 :             :       else
     801                 :      436183 :         if (dump_file)
     802                 :           0 :           fprintf (dump_file, "    can throw\n");
     803                 :             :     }
     804                 :    84113882 :   switch (gimple_code (stmt))
     805                 :             :     {
     806                 :    14438659 :     case GIMPLE_CALL:
     807                 :    14438659 :       check_call (local, as_a <gcall *> (stmt), ipa);
     808                 :    14438659 :       break;
     809                 :     1657989 :     case GIMPLE_LABEL:
     810                 :     1657989 :       if (DECL_NONLOCAL (gimple_label_label (as_a <glabel *> (stmt))))
     811                 :             :         /* Target of long jump. */
     812                 :             :         {
     813                 :         812 :           if (dump_file)
     814                 :           0 :             fprintf (dump_file, "    nonlocal label is not const/pure\n");
     815                 :         812 :           local->pure_const_state = IPA_NEITHER;
     816                 :             :         }
     817                 :             :       break;
     818                 :      258740 :     case GIMPLE_ASM:
     819                 :      258740 :       if (gimple_asm_clobbers_memory_p (as_a <gasm *> (stmt)))
     820                 :             :         {
     821                 :      118181 :           if (dump_file)
     822                 :           3 :             fprintf (dump_file, "    memory asm clobber is not const/pure\n");
     823                 :             :           /* Abandon all hope, ye who enter here. */
     824                 :      118181 :           local->pure_const_state = IPA_NEITHER;
     825                 :      118181 :           local->can_free = true;
     826                 :             :         }
     827                 :      258740 :       if (gimple_asm_volatile_p (as_a <gasm *> (stmt)))
     828                 :             :         {
     829                 :      236480 :           if (dump_file)
     830                 :           3 :             fprintf (dump_file, "    volatile is not const/pure\n");
     831                 :             :           /* Abandon all hope, ye who enter here. */
     832                 :      236480 :           local->pure_const_state = IPA_NEITHER;
     833                 :      236480 :           local->looping = true;
     834                 :      236480 :           local->can_free = true;
     835                 :             :         }
     836                 :             :       return;
     837                 :             :     default:
     838                 :             :       break;
     839                 :             :     }
     840                 :             : }
     841                 :             : 
     842                 :             : /* Check that RETVAL is used only in STMT and in comparisons against 0.
     843                 :             :    RETVAL is return value of the function and STMT is return stmt.  */
     844                 :             : 
     845                 :             : static bool
     846                 :      413988 : check_retval_uses (tree retval, gimple *stmt)
     847                 :             : {
     848                 :      413988 :   imm_use_iterator use_iter;
     849                 :      413988 :   gimple *use_stmt;
     850                 :             : 
     851                 :      890004 :   FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, retval)
     852                 :      594034 :     if (gcond *cond = dyn_cast<gcond *> (use_stmt))
     853                 :             :       {
     854                 :       12909 :         tree op2 = gimple_cond_rhs (cond);
     855                 :       12909 :         if (!integer_zerop (op2))
     856                 :             :           return false;
     857                 :             :       }
     858                 :      581125 :     else if (gassign *ga = dyn_cast<gassign *> (use_stmt))
     859                 :             :       {
     860                 :       78329 :         enum tree_code code = gimple_assign_rhs_code (ga);
     861                 :       78329 :         if (TREE_CODE_CLASS (code) != tcc_comparison)
     862                 :             :           return false;
     863                 :        2662 :         if (!integer_zerop (gimple_assign_rhs2 (ga)))
     864                 :             :           return false;
     865                 :             :       }
     866                 :      502796 :     else if (is_gimple_debug (use_stmt))
     867                 :             :       ;
     868                 :      408389 :     else if (use_stmt != stmt)
     869                 :      413988 :       return false;
     870                 :             : 
     871                 :      295970 :   return true;
     872                 :             : }
     873                 :             : 
     874                 :             : /* malloc_candidate_p() checks if FUN can possibly be annotated with malloc
     875                 :             :    attribute. Currently this function does a very conservative analysis.
     876                 :             :    FUN is considered to be a candidate if
     877                 :             :    1) It returns a value of pointer type.
     878                 :             :    2) SSA_NAME_DEF_STMT (return_value) is either a function call or
     879                 :             :       a phi, and element of phi is either NULL or
     880                 :             :       SSA_NAME_DEF_STMT(element) is function call.
     881                 :             :    3) The return-value has immediate uses only within comparisons (gcond or gassign)
     882                 :             :       and return_stmt (and likewise a phi arg has immediate use only within comparison
     883                 :             :       or the phi stmt).  */
     884                 :             : 
     885                 :             : #define DUMP_AND_RETURN(reason)  \
     886                 :             : {  \
     887                 :             :   if (dump_file && (dump_flags & TDF_DETAILS))  \
     888                 :             :     fprintf (dump_file, "\n%s is not a malloc candidate, reason: %s\n", \
     889                 :             :              (node->dump_name ()), (reason));  \
     890                 :             :   return false;  \
     891                 :             : }
     892                 :             : 
     893                 :             : static bool
     894                 :      354887 : malloc_candidate_p_1 (function *fun, tree retval, gimple *ret_stmt, bool ipa,
     895                 :             :                       bitmap visited)
     896                 :             : {
     897                 :      354887 :   cgraph_node *node = cgraph_node::get_create (fun->decl);
     898                 :      354887 :   if (!bitmap_set_bit (visited, SSA_NAME_VERSION (retval)))
     899                 :             :     return true;
     900                 :             : 
     901                 :      354887 :   if (!check_retval_uses (retval, ret_stmt))
     902                 :       92087 :     DUMP_AND_RETURN("Return value has uses outside return stmt"
     903                 :             :                     " and comparisons against 0.")
     904                 :             : 
     905                 :      262800 :   gimple *def = SSA_NAME_DEF_STMT (retval);
     906                 :             : 
     907                 :      262800 :   if (gcall *call_stmt = dyn_cast<gcall *> (def))
     908                 :             :     {
     909                 :       61773 :       tree callee_decl = gimple_call_fndecl (call_stmt);
     910                 :       61773 :       if (!callee_decl)
     911                 :             :         return false;
     912                 :             : 
     913                 :      111696 :       if (!ipa && !DECL_IS_MALLOC (callee_decl))
     914                 :       33431 :         DUMP_AND_RETURN("callee_decl does not have malloc attribute for"
     915                 :             :                         " non-ipa mode.")
     916                 :             : 
     917                 :       26962 :       cgraph_edge *cs = node->get_edge (call_stmt);
     918                 :       26962 :       if (cs)
     919                 :             :         {
     920                 :        9090 :           ipa_call_summary *es = ipa_call_summaries->get_create (cs);
     921                 :        9090 :           es->is_return_callee_uncaptured = true;
     922                 :             :         }
     923                 :             :     }
     924                 :             : 
     925                 :      201027 :     else if (gphi *phi = dyn_cast<gphi *> (def))
     926                 :             :       {
     927                 :             :         bool all_args_zero = true;
     928                 :       82363 :         for (unsigned i = 0; i < gimple_phi_num_args (phi); ++i)
     929                 :             :           {
     930                 :       78110 :             tree arg = gimple_phi_arg_def (phi, i);
     931                 :       78110 :             if (integer_zerop (arg))
     932                 :       16431 :               continue;
     933                 :             : 
     934                 :       61679 :             all_args_zero = false;
     935                 :       61679 :             if (TREE_CODE (arg) != SSA_NAME)
     936                 :        2578 :               DUMP_AND_RETURN ("phi arg is not SSA_NAME.");
     937                 :       59101 :             if (!check_retval_uses (arg, phi))
     938                 :       25931 :               DUMP_AND_RETURN ("phi arg has uses outside phi"
     939                 :             :                                  " and comparisons against 0.")
     940                 :             : 
     941                 :       33170 :             gimple *arg_def = SSA_NAME_DEF_STMT (arg);
     942                 :       33170 :             if (is_a<gphi *> (arg_def))
     943                 :             :               {
     944                 :        3394 :                 if (!malloc_candidate_p_1 (fun, arg, phi, ipa, visited))
     945                 :        3310 :                     DUMP_AND_RETURN ("nested phi fail")
     946                 :          84 :                 continue;
     947                 :             :               }
     948                 :             : 
     949                 :       29776 :             gcall *call_stmt = dyn_cast<gcall *> (arg_def);
     950                 :       29776 :             if (!call_stmt)
     951                 :       15196 :               DUMP_AND_RETURN ("phi arg is a not a call_stmt.")
     952                 :             : 
     953                 :       14580 :             tree callee_decl = gimple_call_fndecl (call_stmt);
     954                 :       14580 :             if (!callee_decl)
     955                 :             :               return false;
     956                 :       18637 :             if (!ipa && !DECL_IS_MALLOC (callee_decl))
     957                 :        4013 :               DUMP_AND_RETURN("callee_decl does not have malloc attribute"
     958                 :             :                               " for non-ipa mode.")
     959                 :             : 
     960                 :        7706 :             cgraph_edge *cs = node->get_edge (call_stmt);
     961                 :        7706 :             if (cs)
     962                 :             :               {
     963                 :        4951 :                 ipa_call_summary *es = ipa_call_summaries->get_create (cs);
     964                 :        4951 :                 es->is_return_callee_uncaptured = true;
     965                 :             :               }
     966                 :             :           }
     967                 :             : 
     968                 :        4253 :         if (all_args_zero)
     969                 :           4 :           DUMP_AND_RETURN ("Return value is a phi with all args equal to 0.")
     970                 :             :       }
     971                 :             : 
     972                 :             :     else
     973                 :      142885 :       DUMP_AND_RETURN("def_stmt of return value is not a call or phi-stmt.")
     974                 :             : 
     975                 :             :   return true;
     976                 :             : }
     977                 :             : 
     978                 :             : static bool
     979                 :     5608381 : malloc_candidate_p (function *fun, bool ipa)
     980                 :             : {
     981                 :     5608381 :   basic_block exit_block = EXIT_BLOCK_PTR_FOR_FN (fun);
     982                 :     5608381 :   edge e;
     983                 :     5608381 :   edge_iterator ei;
     984                 :     5608381 :   cgraph_node *node = cgraph_node::get_create (fun->decl);
     985                 :             : 
     986                 :     5608381 :   if (EDGE_COUNT (exit_block->preds) == 0
     987                 :     5606099 :       || !flag_delete_null_pointer_checks)
     988                 :             :     return false;
     989                 :             : 
     990                 :     5478622 :   auto_bitmap visited;
     991                 :     5509749 :   FOR_EACH_EDGE (e, ei, exit_block->preds)
     992                 :             :     {
     993                 :     5478622 :       gimple_stmt_iterator gsi = gsi_last_bb (e->src);
     994                 :    10924866 :       greturn *ret_stmt = dyn_cast<greturn *> (gsi_stmt (gsi));
     995                 :             : 
     996                 :     5477371 :       if (!ret_stmt)
     997                 :     5478622 :         return false;
     998                 :             : 
     999                 :     5477371 :       tree retval = gimple_return_retval (ret_stmt);
    1000                 :     5477371 :       if (!retval)
    1001                 :     2476405 :         DUMP_AND_RETURN("No return value.")
    1002                 :             : 
    1003                 :     3000966 :       if (TREE_CODE (retval) != SSA_NAME
    1004                 :     3000966 :           || TREE_CODE (TREE_TYPE (retval)) != POINTER_TYPE)
    1005                 :     2649473 :         DUMP_AND_RETURN("Return value is not SSA_NAME or not a pointer type.")
    1006                 :             : 
    1007                 :      351493 :       if (!malloc_candidate_p_1 (fun, retval, ret_stmt, ipa, visited))
    1008                 :             :         return false;
    1009                 :             :     }
    1010                 :             : 
    1011                 :       31127 :   if (dump_file && (dump_flags & TDF_DETAILS))
    1012                 :           8 :     fprintf (dump_file, "\nFound %s to be candidate for malloc attribute\n",
    1013                 :           4 :              IDENTIFIER_POINTER (DECL_NAME (fun->decl)));
    1014                 :             :   return true;
    1015                 :     5478622 : }
    1016                 :             : 
    1017                 :             : #undef DUMP_AND_RETURN
    1018                 :             : 
    1019                 :             : /* Return true if function is known to be finite.  */
    1020                 :             : 
    1021                 :             : bool
    1022                 :     3966455 : finite_function_p ()
    1023                 :             : {
    1024                 :             :   /* Const functions cannot have back edges (an
    1025                 :             :      indication of possible infinite loop side
    1026                 :             :      effect.  */
    1027                 :     3966455 :   bool finite = true;
    1028                 :     3966455 :   if (mark_dfs_back_edges ())
    1029                 :             :     {
    1030                 :             :       /* Preheaders are needed for SCEV to work.
    1031                 :             :          Simple latches and recorded exits improve chances that loop will
    1032                 :             :          proved to be finite in testcases such as in loop-15.c
    1033                 :             :          and loop-24.c  */
    1034                 :      380186 :       loop_optimizer_init (LOOPS_HAVE_PREHEADERS
    1035                 :             :                            | LOOPS_HAVE_SIMPLE_LATCHES
    1036                 :             :                            | LOOPS_HAVE_RECORDED_EXITS);
    1037                 :      380186 :       if (dump_file && (dump_flags & TDF_DETAILS))
    1038                 :           0 :         flow_loops_dump (dump_file, NULL, 0);
    1039                 :      380186 :       if (mark_irreducible_loops ())
    1040                 :             :         {
    1041                 :        1872 :           if (dump_file)
    1042                 :           0 :             fprintf (dump_file, "    has irreducible loops\n");
    1043                 :             :           finite = false;
    1044                 :             :         }
    1045                 :             :       else
    1046                 :             :         {
    1047                 :      378314 :           scev_initialize ();
    1048                 :     1884656 :           for (auto loop : loops_list (cfun, 0))
    1049                 :      821792 :             if (!finite_loop_p (loop))
    1050                 :             :               {
    1051                 :       72078 :                 if (dump_file)
    1052                 :           1 :                   fprintf (dump_file, "    cannot prove finiteness of "
    1053                 :             :                            "loop %i\n", loop->num);
    1054                 :             :                 finite =false;
    1055                 :             :                 break;
    1056                 :      378314 :               }
    1057                 :      378314 :           scev_finalize ();
    1058                 :             :         }
    1059                 :      380186 :       loop_optimizer_finalize ();
    1060                 :             :     }
    1061                 :     3966455 :   return finite;
    1062                 :             : }
    1063                 :             : 
    1064                 :             : /* This is the main routine for finding the reference patterns for
    1065                 :             :    global variables within a function FN.  */
    1066                 :             : 
    1067                 :             : static funct_state
    1068                 :     4414290 : analyze_function (struct cgraph_node *fn, bool ipa)
    1069                 :             : {
    1070                 :     4414290 :   tree decl = fn->decl;
    1071                 :     4414290 :   funct_state l;
    1072                 :     4414290 :   basic_block this_block;
    1073                 :             : 
    1074                 :     4414290 :   l = XCNEW (class funct_state_d);
    1075                 :     4414290 :   l->pure_const_state = IPA_CONST;
    1076                 :     4414290 :   l->state_previously_known = IPA_NEITHER;
    1077                 :     4414290 :   l->looping_previously_known = true;
    1078                 :     4414290 :   l->looping = false;
    1079                 :     4414290 :   l->can_throw = false;
    1080                 :     4414290 :   l->can_free = false;
    1081                 :     4414290 :   state_from_flags (&l->state_previously_known, &l->looping_previously_known,
    1082                 :     4414290 :                     flags_from_decl_or_type (fn->decl),
    1083                 :     4414290 :                     fn->cannot_return_p ());
    1084                 :             : 
    1085                 :     4414290 :   if (fn->thunk || fn->alias)
    1086                 :             :     {
    1087                 :             :       /* Thunk gets propagated through, so nothing interesting happens.  */
    1088                 :       62303 :       gcc_assert (ipa);
    1089                 :       62303 :       if (fn->thunk && thunk_info::get (fn)->virtual_offset_p)
    1090                 :         739 :         l->pure_const_state = IPA_NEITHER;
    1091                 :       62303 :       return l;
    1092                 :             :     }
    1093                 :             : 
    1094                 :     4351987 :   if (dump_file)
    1095                 :             :     {
    1096                 :         189 :       fprintf (dump_file, "\n\n local analysis of %s\n ",
    1097                 :             :                fn->dump_name ());
    1098                 :             :     }
    1099                 :             : 
    1100                 :     4351987 :   push_cfun (DECL_STRUCT_FUNCTION (decl));
    1101                 :             : 
    1102                 :    33390894 :   FOR_EACH_BB_FN (this_block, cfun)
    1103                 :             :     {
    1104                 :    29103418 :       gimple_stmt_iterator gsi;
    1105                 :    29103418 :       struct walk_stmt_info wi;
    1106                 :             : 
    1107                 :    29103418 :       memset (&wi, 0, sizeof (wi));
    1108                 :    58206836 :       for (gsi = gsi_start_bb (this_block);
    1109                 :   191506411 :            !gsi_end_p (gsi);
    1110                 :   162402993 :            gsi_next (&gsi))
    1111                 :             :         {
    1112                 :             :           /* NULL memory accesses terminates BB.  These accesses are known
    1113                 :             :              to trip undefined behaviour.  gimple-ssa-isolate-paths turns them
    1114                 :             :              to volatile accesses and adds builtin_trap call which would
    1115                 :             :              confuse us otherwise.  */
    1116                 :   162469645 :           if (infer_nonnull_range_by_dereference (gsi_stmt (gsi),
    1117                 :             :                                                   null_pointer_node))
    1118                 :             :             {
    1119                 :        2141 :               if (dump_file)
    1120                 :           0 :                 fprintf (dump_file, "  NULL memory access; terminating BB%s\n",
    1121                 :           0 :                          flag_non_call_exceptions ? "; looping" : "");
    1122                 :        2141 :               if (flag_non_call_exceptions)
    1123                 :             :                 {
    1124                 :         401 :                   l->looping = true;
    1125                 :         401 :                   if (stmt_can_throw_external (cfun, gsi_stmt (gsi)))
    1126                 :             :                     {
    1127                 :         305 :                       if (dump_file)
    1128                 :           0 :                         fprintf (dump_file, "    can throw externally\n");
    1129                 :         305 :                       l->can_throw = true;
    1130                 :             :                     }
    1131                 :             :                 }
    1132                 :             :               break;
    1133                 :             :             }
    1134                 :   162467504 :           check_stmt (&gsi, l, ipa);
    1135                 :   162467504 :           if (l->pure_const_state == IPA_NEITHER
    1136                 :   105822411 :               && l->looping
    1137                 :    85868839 :               && l->can_throw
    1138                 :    42330303 :               && l->can_free)
    1139                 :       64511 :             goto end;
    1140                 :             :         }
    1141                 :             :     }
    1142                 :             : 
    1143                 :     4287476 : end:
    1144                 :     4351987 :   if (l->pure_const_state != IPA_NEITHER
    1145                 :     1910914 :       && !l->looping
    1146                 :     6083854 :       && !finite_function_p ())
    1147                 :       23243 :     l->looping = true;
    1148                 :             : 
    1149                 :     4351987 :   if (dump_file && (dump_flags & TDF_DETAILS))
    1150                 :          22 :     fprintf (dump_file, "    checking previously known:");
    1151                 :             : 
    1152                 :     4351987 :   better_state (&l->pure_const_state, &l->looping,
    1153                 :             :                 l->state_previously_known,
    1154                 :     4351987 :                 l->looping_previously_known);
    1155                 :     4351987 :   if (TREE_NOTHROW (decl))
    1156                 :     2957409 :     l->can_throw = false;
    1157                 :             : 
    1158                 :     4351987 :   l->malloc_state = STATE_MALLOC_BOTTOM;
    1159                 :     4351987 :   if (DECL_IS_MALLOC (decl))
    1160                 :        6113 :     l->malloc_state = STATE_MALLOC;
    1161                 :     4345874 :   else if (ipa && malloc_candidate_p (DECL_STRUCT_FUNCTION (decl), true))
    1162                 :       10849 :     l->malloc_state = STATE_MALLOC_TOP;
    1163                 :     4335025 :   else if (malloc_candidate_p (DECL_STRUCT_FUNCTION (decl), false))
    1164                 :       20278 :     l->malloc_state = STATE_MALLOC;
    1165                 :             : 
    1166                 :     4351987 :   pop_cfun ();
    1167                 :     4351987 :   if (dump_file)
    1168                 :             :     {
    1169                 :         189 :       if (l->looping)
    1170                 :          50 :         fprintf (dump_file, "Function is locally looping.\n");
    1171                 :         189 :       if (l->can_throw)
    1172                 :           6 :         fprintf (dump_file, "Function is locally throwing.\n");
    1173                 :         189 :       if (l->pure_const_state == IPA_CONST)
    1174                 :         102 :         fprintf (dump_file, "Function is locally const.\n");
    1175                 :         189 :       if (l->pure_const_state == IPA_PURE)
    1176                 :           7 :         fprintf (dump_file, "Function is locally pure.\n");
    1177                 :         189 :       if (l->can_free)
    1178                 :           3 :         fprintf (dump_file, "Function can locally free.\n");
    1179                 :         189 :       if (l->malloc_state == STATE_MALLOC)
    1180                 :           8 :         fprintf (dump_file, "Function is locally malloc.\n");
    1181                 :             :     }
    1182                 :             :   return l;
    1183                 :             : }
    1184                 :             : 
    1185                 :             : void
    1186                 :       18253 : funct_state_summary_t::insert (cgraph_node *node, funct_state_d *state)
    1187                 :             : {
    1188                 :             :   /* There are some shared nodes, in particular the initializers on
    1189                 :             :      static declarations.  We do not need to scan them more than once
    1190                 :             :      since all we would be interested in are the addressof
    1191                 :             :      operations.  */
    1192                 :       18253 :   if (opt_for_fn (node->decl, flag_ipa_pure_const))
    1193                 :             :     {
    1194                 :       18252 :       funct_state_d *a = analyze_function (node, true);
    1195                 :       18252 :       new (state) funct_state_d (*a);
    1196                 :       18252 :       free (a);
    1197                 :             :     }
    1198                 :             :   else
    1199                 :             :     /* Do not keep stale summaries.  */
    1200                 :           1 :     funct_state_summaries->remove (node);
    1201                 :       18253 : }
    1202                 :             : 
    1203                 :             : /* Called when new clone is inserted to callgraph late.  */
    1204                 :             : 
    1205                 :             : void
    1206                 :     1002818 : funct_state_summary_t::duplicate (cgraph_node *, cgraph_node *dst,
    1207                 :             :                                   funct_state_d *src_data,
    1208                 :             :                                   funct_state_d *dst_data)
    1209                 :             : {
    1210                 :     1002818 :   new (dst_data) funct_state_d (*src_data);
    1211                 :     1002818 :   if (dst_data->malloc_state == STATE_MALLOC
    1212                 :     1002818 :       && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (dst->decl))))
    1213                 :          11 :     dst_data->malloc_state = STATE_MALLOC_BOTTOM;
    1214                 :     1002818 : }
    1215                 :             : 
    1216                 :             : 
    1217                 :             : void
    1218                 :      153686 : pass_ipa_pure_const::
    1219                 :             : register_hooks (void)
    1220                 :             : {
    1221                 :      153686 :   if (init_p)
    1222                 :             :     return;
    1223                 :             : 
    1224                 :      153686 :   init_p = true;
    1225                 :             : 
    1226                 :      153686 :   funct_state_summaries = new funct_state_summary_t (symtab);
    1227                 :             : }
    1228                 :             : 
    1229                 :             : 
    1230                 :             : /* Analyze each function in the cgraph to see if it is locally PURE or
    1231                 :             :    CONST.  */
    1232                 :             : 
    1233                 :             : static void
    1234                 :      141914 : pure_const_generate_summary (void)
    1235                 :             : {
    1236                 :      141914 :   struct cgraph_node *node;
    1237                 :             : 
    1238                 :      141914 :   pass_ipa_pure_const *pass = static_cast <pass_ipa_pure_const *> (current_pass);
    1239                 :      141914 :   pass->register_hooks ();
    1240                 :             : 
    1241                 :             :   /* Process all of the functions.
    1242                 :             : 
    1243                 :             :      We process AVAIL_INTERPOSABLE functions.  We cannot use the results
    1244                 :             :      by default, but the info can be used at LTO with -fwhole-program or
    1245                 :             :      when function got cloned and the clone is AVAILABLE.  */
    1246                 :             : 
    1247                 :     1464948 :   FOR_EACH_DEFINED_FUNCTION (node)
    1248                 :     1323034 :     if (opt_for_fn (node->decl, flag_ipa_pure_const))
    1249                 :             :       {
    1250                 :     1322867 :         funct_state_d *a = analyze_function (node, true);
    1251                 :     1322867 :         new (funct_state_summaries->get_create (node)) funct_state_d (*a);
    1252                 :     1322867 :         free (a);
    1253                 :             :       }
    1254                 :      141914 : }
    1255                 :             : 
    1256                 :             : 
    1257                 :             : /* Serialize the ipa info for lto.  */
    1258                 :             : 
    1259                 :             : static void
    1260                 :       18801 : pure_const_write_summary (void)
    1261                 :             : {
    1262                 :       18801 :   struct cgraph_node *node;
    1263                 :       18801 :   struct lto_simple_output_block *ob
    1264                 :       18801 :     = lto_create_simple_output_block (LTO_section_ipa_pure_const);
    1265                 :       18801 :   unsigned int count = 0;
    1266                 :       18801 :   lto_symtab_encoder_iterator lsei;
    1267                 :       18801 :   lto_symtab_encoder_t encoder;
    1268                 :             : 
    1269                 :       18801 :   encoder = lto_get_out_decl_state ()->symtab_node_encoder;
    1270                 :             : 
    1271                 :      216842 :   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
    1272                 :       89717 :        lsei_next_function_in_partition (&lsei))
    1273                 :             :     {
    1274                 :       89717 :       node = lsei_cgraph_node (lsei);
    1275                 :       89717 :       if (node->definition && funct_state_summaries->exists (node))
    1276                 :       89564 :         count++;
    1277                 :             :     }
    1278                 :             : 
    1279                 :       18801 :   streamer_write_uhwi_stream (ob->main_stream, count);
    1280                 :             : 
    1281                 :             :   /* Process all of the functions.  */
    1282                 :      216842 :   for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
    1283                 :       89717 :        lsei_next_function_in_partition (&lsei))
    1284                 :             :     {
    1285                 :       89717 :       node = lsei_cgraph_node (lsei);
    1286                 :       89717 :       funct_state_d *fs = funct_state_summaries->get (node);
    1287                 :       89717 :       if (node->definition && fs != NULL)
    1288                 :             :         {
    1289                 :       89564 :           struct bitpack_d bp;
    1290                 :       89564 :           int node_ref;
    1291                 :       89564 :           lto_symtab_encoder_t encoder;
    1292                 :             : 
    1293                 :       89564 :           encoder = ob->decl_state->symtab_node_encoder;
    1294                 :       89564 :           node_ref = lto_symtab_encoder_encode (encoder, node);
    1295                 :       89564 :           streamer_write_uhwi_stream (ob->main_stream, node_ref);
    1296                 :             : 
    1297                 :             :           /* Note that flags will need to be read in the opposite
    1298                 :             :              order as we are pushing the bitflags into FLAGS.  */
    1299                 :       89564 :           bp = bitpack_create (ob->main_stream);
    1300                 :       89564 :           bp_pack_value (&bp, fs->pure_const_state, 2);
    1301                 :       89564 :           bp_pack_value (&bp, fs->state_previously_known, 2);
    1302                 :       89564 :           bp_pack_value (&bp, fs->looping_previously_known, 1);
    1303                 :       89564 :           bp_pack_value (&bp, fs->looping, 1);
    1304                 :       89564 :           bp_pack_value (&bp, fs->can_throw, 1);
    1305                 :       89564 :           bp_pack_value (&bp, fs->can_free, 1);
    1306                 :       89564 :           bp_pack_value (&bp, fs->malloc_state, 2);
    1307                 :       89564 :           streamer_write_bitpack (&bp);
    1308                 :             :         }
    1309                 :             :     }
    1310                 :             : 
    1311                 :       18801 :   lto_destroy_simple_output_block (ob);
    1312                 :       18801 : }
    1313                 :             : 
    1314                 :             : 
    1315                 :             : /* Deserialize the ipa info for lto.  */
    1316                 :             : 
    1317                 :             : static void
    1318                 :       11772 : pure_const_read_summary (void)
    1319                 :             : {
    1320                 :       11772 :   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
    1321                 :       11772 :   struct lto_file_decl_data *file_data;
    1322                 :       11772 :   unsigned int j = 0;
    1323                 :             : 
    1324                 :       11772 :   pass_ipa_pure_const *pass = static_cast <pass_ipa_pure_const *> (current_pass);
    1325                 :       11772 :   pass->register_hooks ();
    1326                 :             : 
    1327                 :       36326 :   while ((file_data = file_data_vec[j++]))
    1328                 :             :     {
    1329                 :       12782 :       const char *data;
    1330                 :       12782 :       size_t len;
    1331                 :       12782 :       class lto_input_block *ib
    1332                 :       12782 :         = lto_create_simple_input_block (file_data,
    1333                 :             :                                          LTO_section_ipa_pure_const,
    1334                 :             :                                          &data, &len);
    1335                 :       12782 :       if (ib)
    1336                 :             :         {
    1337                 :       10220 :           unsigned int i;
    1338                 :       10220 :           unsigned int count = streamer_read_uhwi (ib);
    1339                 :             : 
    1340                 :       84919 :           for (i = 0; i < count; i++)
    1341                 :             :             {
    1342                 :       74699 :               unsigned int index;
    1343                 :       74699 :               struct cgraph_node *node;
    1344                 :       74699 :               struct bitpack_d bp;
    1345                 :       74699 :               funct_state fs;
    1346                 :       74699 :               lto_symtab_encoder_t encoder;
    1347                 :             : 
    1348                 :       74699 :               index = streamer_read_uhwi (ib);
    1349                 :       74699 :               encoder = file_data->symtab_node_encoder;
    1350                 :       74699 :               node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
    1351                 :             :                                                                         index));
    1352                 :             : 
    1353                 :       74699 :               fs = funct_state_summaries->get_create (node);
    1354                 :             :               /* Note that the flags must be read in the opposite
    1355                 :             :                  order in which they were written (the bitflags were
    1356                 :             :                  pushed into FLAGS).  */
    1357                 :       74699 :               bp = streamer_read_bitpack (ib);
    1358                 :       74699 :               fs->pure_const_state
    1359                 :       74699 :                         = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
    1360                 :       74699 :               fs->state_previously_known
    1361                 :       74699 :                         = (enum pure_const_state_e) bp_unpack_value (&bp, 2);
    1362                 :       74699 :               fs->looping_previously_known = bp_unpack_value (&bp, 1);
    1363                 :       74699 :               fs->looping = bp_unpack_value (&bp, 1);
    1364                 :       74699 :               fs->can_throw = bp_unpack_value (&bp, 1);
    1365                 :       74699 :               fs->can_free = bp_unpack_value (&bp, 1);
    1366                 :       74699 :               fs->malloc_state
    1367                 :       74699 :                         = (enum malloc_state_e) bp_unpack_value (&bp, 2);
    1368                 :             : 
    1369                 :       74699 :               if (dump_file)
    1370                 :             :                 {
    1371                 :           0 :                   int flags = flags_from_decl_or_type (node->decl);
    1372                 :           0 :                   fprintf (dump_file, "Read info for %s ", node->dump_name ());
    1373                 :           0 :                   if (flags & ECF_CONST)
    1374                 :           0 :                     fprintf (dump_file, " const");
    1375                 :           0 :                   if (flags & ECF_PURE)
    1376                 :           0 :                     fprintf (dump_file, " pure");
    1377                 :           0 :                   if (flags & ECF_NOTHROW)
    1378                 :           0 :                     fprintf (dump_file, " nothrow");
    1379                 :           0 :                   fprintf (dump_file, "\n  pure const state: %s\n",
    1380                 :           0 :                            pure_const_names[fs->pure_const_state]);
    1381                 :           0 :                   fprintf (dump_file, "  previously known state: %s\n",
    1382                 :           0 :                            pure_const_names[fs->state_previously_known]);
    1383                 :           0 :                   if (fs->looping)
    1384                 :           0 :                     fprintf (dump_file,"  function is locally looping\n");
    1385                 :           0 :                   if (fs->looping_previously_known)
    1386                 :           0 :                     fprintf (dump_file,"  function is previously known looping\n");
    1387                 :           0 :                   if (fs->can_throw)
    1388                 :           0 :                     fprintf (dump_file,"  function is locally throwing\n");
    1389                 :           0 :                   if (fs->can_free)
    1390                 :           0 :                     fprintf (dump_file,"  function can locally free\n");
    1391                 :           0 :                   fprintf (dump_file, "\n malloc state: %s\n",
    1392                 :           0 :                            malloc_state_names[fs->malloc_state]);
    1393                 :             :                 }
    1394                 :             :             }
    1395                 :             : 
    1396                 :       10220 :           lto_destroy_simple_input_block (file_data,
    1397                 :             :                                           LTO_section_ipa_pure_const,
    1398                 :             :                                           ib, data, len);
    1399                 :             :         }
    1400                 :             :     }
    1401                 :       11772 : }
    1402                 :             : 
    1403                 :             : /* We only propagate across edges that can throw externally and their callee
    1404                 :             :    is not interposable.  */
    1405                 :             : 
    1406                 :             : static bool
    1407                 :     6516173 : ignore_edge_for_nothrow (struct cgraph_edge *e)
    1408                 :             : {
    1409                 :     6516173 :   if (!e->can_throw_external || TREE_NOTHROW (e->callee->decl))
    1410                 :             :     return true;
    1411                 :             : 
    1412                 :     1925935 :   enum availability avail;
    1413                 :     1925935 :   cgraph_node *ultimate_target
    1414                 :     1925935 :     = e->callee->function_or_virtual_thunk_symbol (&avail, e->caller);
    1415                 :     1925935 :   if (avail <= AVAIL_INTERPOSABLE || TREE_NOTHROW (ultimate_target->decl))
    1416                 :             :     return true;
    1417                 :      630313 :   return ((opt_for_fn (e->callee->decl, flag_non_call_exceptions)
    1418                 :      201703 :            && !e->callee->binds_to_current_def_p (e->caller))
    1419                 :      630265 :           || !opt_for_fn (e->caller->decl, flag_ipa_pure_const)
    1420                 :     1259554 :           || !opt_for_fn (ultimate_target->decl, flag_ipa_pure_const));
    1421                 :             : }
    1422                 :             : 
    1423                 :             : /* Return true if NODE is self recursive function.
    1424                 :             :    Indirectly recursive functions appears as non-trivial strongly
    1425                 :             :    connected components, so we need to care about self recursion
    1426                 :             :    only.  */
    1427                 :             : 
    1428                 :             : static bool
    1429                 :     1851984 : self_recursive_p (struct cgraph_node *node)
    1430                 :             : {
    1431                 :     1851984 :   struct cgraph_edge *e;
    1432                 :     7118841 :   for (e = node->callees; e; e = e->next_callee)
    1433                 :     5270194 :     if (e->callee->function_symbol () == node)
    1434                 :             :       return true;
    1435                 :             :   return false;
    1436                 :             : }
    1437                 :             : 
    1438                 :             : /* Return true if N is cdtor that is not const or pure.  In this case we may
    1439                 :             :    need to remove unreachable function if it is marked const/pure.  */
    1440                 :             : 
    1441                 :             : static bool
    1442                 :       48662 : cdtor_p (cgraph_node *n, void *)
    1443                 :             : {
    1444                 :       48662 :   if (DECL_STATIC_CONSTRUCTOR (n->decl) || DECL_STATIC_DESTRUCTOR (n->decl))
    1445                 :           3 :     return ((!TREE_READONLY (n->decl) && !DECL_PURE_P (n->decl))
    1446                 :           3 :             || DECL_LOOPING_CONST_OR_PURE_P (n->decl));
    1447                 :             :   return false;
    1448                 :             : }
    1449                 :             : 
    1450                 :             : /* Skip edges from and to nodes without ipa_pure_const enabled.
    1451                 :             :    Ignore not available symbols.  */
    1452                 :             : 
    1453                 :             : static bool
    1454                 :     6516173 : ignore_edge_for_pure_const (struct cgraph_edge *e)
    1455                 :             : {
    1456                 :     6516173 :   enum availability avail;
    1457                 :     6516173 :   cgraph_node *ultimate_target
    1458                 :     6516173 :     = e->callee->function_or_virtual_thunk_symbol (&avail, e->caller);
    1459                 :             : 
    1460                 :     6516173 :   return (avail <= AVAIL_INTERPOSABLE
    1461                 :     2256653 :           || !opt_for_fn (e->caller->decl, flag_ipa_pure_const)
    1462                 :     8764074 :           || !opt_for_fn (ultimate_target->decl,
    1463                 :     6516173 :                           flag_ipa_pure_const));
    1464                 :             : }
    1465                 :             : 
    1466                 :             : /* Return true if function should be skipped for local pure const analysis.  */
    1467                 :             : 
    1468                 :             : static bool
    1469                 :     4376386 : skip_function_for_local_pure_const (struct cgraph_node *node)
    1470                 :             : {
    1471                 :             :   /* Because we do not schedule pass_fixup_cfg over whole program after early
    1472                 :             :      optimizations we must not promote functions that are called by already
    1473                 :             :      processed functions.  */
    1474                 :             : 
    1475                 :     4376386 :   if (function_called_by_processed_nodes_p ())
    1476                 :             :     {
    1477                 :        4772 :       if (dump_file)
    1478                 :           1 :         fprintf (dump_file, "Function called in recursive cycle; ignoring\n");
    1479                 :        4772 :       return true;
    1480                 :             :     }
    1481                 :             :   /* Save some work and do not analyze functions which are interposable and
    1482                 :             :      do not have any non-interposable aliases.  */
    1483                 :     4371614 :   if (node->get_availability () <= AVAIL_INTERPOSABLE
    1484                 :      200195 :       && !flag_lto
    1485                 :     4565467 :       && !node->has_aliases_p ())
    1486                 :             :     {
    1487                 :      184138 :       if (dump_file)
    1488                 :           0 :         fprintf (dump_file,
    1489                 :             :                  "Function is interposable; not analyzing.\n");
    1490                 :      184138 :       return true;
    1491                 :             :     }
    1492                 :             :   return false;
    1493                 :             : }
    1494                 :             : 
    1495                 :             : /* Make function const and output warning.  If LOCAL is true,
    1496                 :             :    return true if anything changed.  Otherwise return true if
    1497                 :             :    we may have introduced removale ctors.  */
    1498                 :             : 
    1499                 :             : bool
    1500                 :     1494116 : ipa_make_function_const (struct cgraph_node *node, bool looping, bool local)
    1501                 :             : {
    1502                 :     1494116 :   bool cdtor = false;
    1503                 :             : 
    1504                 :     1494116 :   if (TREE_READONLY (node->decl)
    1505                 :     1494116 :       && (looping || !DECL_LOOPING_CONST_OR_PURE_P (node->decl)))
    1506                 :             :     return false;
    1507                 :      880752 :   warn_function_const (node->decl, !looping);
    1508                 :      880752 :   if (local && skip_function_for_local_pure_const (node))
    1509                 :             :     return false;
    1510                 :      862174 :   if (dump_file)
    1511                 :          58 :     fprintf (dump_file, "Function found to be %sconst: %s\n",
    1512                 :             :              looping ? "looping " : "",
    1513                 :             :              node->dump_name ());
    1514                 :      862174 :   if (!local && !looping)
    1515                 :       42504 :     cdtor = node->call_for_symbol_and_aliases (cdtor_p, NULL, true);
    1516                 :      862174 :   if (!dbg_cnt (ipa_attr))
    1517                 :             :     return false;
    1518                 :      862174 :   if (node->set_const_flag (true, looping))
    1519                 :             :     {
    1520                 :      485151 :       if (dump_file)
    1521                 :          58 :         fprintf (dump_file,
    1522                 :             :                  "Declaration updated to be %sconst: %s\n",
    1523                 :             :                  looping ? "looping " : "",
    1524                 :             :                  node->dump_name ());
    1525                 :      485151 :       if (local)
    1526                 :             :         return true;
    1527                 :        2577 :       return cdtor;
    1528                 :             :     }
    1529                 :             :   return false;
    1530                 :             : }
    1531                 :             : 
    1532                 :             : /* Make function const and output warning.  If LOCAL is true,
    1533                 :             :    return true if anything changed.  Otherwise return true if
    1534                 :             :    we may have introduced removale ctors.  */
    1535                 :             : 
    1536                 :             : bool
    1537                 :      942281 : ipa_make_function_pure (struct cgraph_node *node, bool looping, bool local)
    1538                 :             : {
    1539                 :      942281 :   bool cdtor = false;
    1540                 :             : 
    1541                 :      942281 :   if (TREE_READONLY (node->decl)
    1542                 :      942281 :       || (DECL_PURE_P (node->decl)
    1543                 :      620463 :           && (looping || !DECL_LOOPING_CONST_OR_PURE_P (node->decl))))
    1544                 :             :     return false;
    1545                 :      321398 :   warn_function_pure (node->decl, !looping);
    1546                 :      321398 :   if (local && skip_function_for_local_pure_const (node))
    1547                 :             :     return false;
    1548                 :      312690 :   if (dump_file)
    1549                 :           8 :     fprintf (dump_file, "Function found to be %spure: %s\n",
    1550                 :             :              looping ? "looping " : "",
    1551                 :             :              node->dump_name ());
    1552                 :      312690 :   if (!local && !looping)
    1553                 :        3202 :     cdtor = node->call_for_symbol_and_aliases (cdtor_p, NULL, true);
    1554                 :      312690 :   if (!dbg_cnt (ipa_attr))
    1555                 :             :     return false;
    1556                 :      312690 :   if (node->set_pure_flag (true, looping))
    1557                 :             :     {
    1558                 :      301547 :       if (dump_file)
    1559                 :           8 :         fprintf (dump_file,
    1560                 :             :                  "Declaration updated to be %spure: %s\n",
    1561                 :             :                  looping ? "looping " : "",
    1562                 :             :                  node->dump_name ());
    1563                 :      301547 :       if (local)
    1564                 :             :         return true;
    1565                 :        7311 :       return cdtor;
    1566                 :             :     }
    1567                 :             :   return false;
    1568                 :             : }
    1569                 :             : 
    1570                 :             : /* Produce transitive closure over the callgraph and compute pure/const
    1571                 :             :    attributes.  */
    1572                 :             : 
    1573                 :             : static bool
    1574                 :      144942 : propagate_pure_const (void)
    1575                 :             : {
    1576                 :      144942 :   struct cgraph_node *node;
    1577                 :      144942 :   struct cgraph_node *w;
    1578                 :      144942 :   struct cgraph_node **order =
    1579                 :      144942 :     XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
    1580                 :      144942 :   int order_pos;
    1581                 :      144942 :   int i;
    1582                 :      144942 :   struct ipa_dfs_info * w_info;
    1583                 :      144942 :   bool remove_p = false;
    1584                 :             : 
    1585                 :      144942 :   order_pos = ipa_reduced_postorder (order, true,
    1586                 :             :                                      ignore_edge_for_pure_const);
    1587                 :      144942 :   if (dump_file)
    1588                 :             :     {
    1589                 :          29 :       cgraph_node::dump_cgraph (dump_file);
    1590                 :          29 :       ipa_print_order (dump_file, "reduced", order, order_pos);
    1591                 :             :     }
    1592                 :             : 
    1593                 :             :   /* Propagate the local information through the call graph to produce
    1594                 :             :      the global information.  All the nodes within a cycle will have
    1595                 :             :      the same info so we collapse cycles first.  Then we can do the
    1596                 :             :      propagation in one pass from the leaves to the roots.  */
    1597                 :     2295775 :   for (i = 0; i < order_pos; i++ )
    1598                 :             :     {
    1599                 :     2150833 :       enum pure_const_state_e pure_const_state = IPA_CONST;
    1600                 :     2150833 :       bool looping = false;
    1601                 :     2150833 :       int count = 0;
    1602                 :     2150833 :       node = order[i];
    1603                 :             : 
    1604                 :     2150833 :       if (node->alias)
    1605                 :       37348 :         continue;
    1606                 :             : 
    1607                 :     2113485 :       if (dump_file && (dump_flags & TDF_DETAILS))
    1608                 :           5 :         fprintf (dump_file, "Starting cycle\n");
    1609                 :             : 
    1610                 :             :       /* Find the worst state for any node in the cycle.  */
    1611                 :             :       w = node;
    1612                 :     3572560 :       while (w && pure_const_state != IPA_NEITHER)
    1613                 :             :         {
    1614                 :     2116261 :           struct cgraph_edge *e;
    1615                 :     2116261 :           struct cgraph_edge *ie;
    1616                 :     2116261 :           int i;
    1617                 :     2116261 :           struct ipa_ref *ref = NULL;
    1618                 :             : 
    1619                 :     2116261 :           funct_state w_l = funct_state_summaries->get_create (w);
    1620                 :     2116261 :           if (dump_file && (dump_flags & TDF_DETAILS))
    1621                 :           6 :             fprintf (dump_file, "  Visiting %s state:%s looping %i\n",
    1622                 :             :                      w->dump_name (),
    1623                 :           6 :                      pure_const_names[w_l->pure_const_state],
    1624                 :           6 :                      w_l->looping);
    1625                 :             : 
    1626                 :             :           /* First merge in function body properties.
    1627                 :             :              We are safe to pass NULL as FROM and TO because we will take care
    1628                 :             :              of possible interposition when walking callees.  */
    1629                 :     2116261 :           worse_state (&pure_const_state, &looping,
    1630                 :     2116261 :                        w_l->pure_const_state, w_l->looping,
    1631                 :             :                        NULL, NULL);
    1632                 :     2116261 :           if (pure_const_state == IPA_NEITHER)
    1633                 :             :             break;
    1634                 :             : 
    1635                 :     1459075 :           count++;
    1636                 :             : 
    1637                 :             :           /* We consider recursive cycles as possibly infinite.
    1638                 :             :              This might be relaxed since infinite recursion leads to stack
    1639                 :             :              overflow.  */
    1640                 :     1459075 :           if (count > 1)
    1641                 :        2776 :             looping = true;
    1642                 :             : 
    1643                 :             :           /* Now walk the edges and merge in callee properties.  */
    1644                 :     2181683 :           for (e = w->callees; e && pure_const_state != IPA_NEITHER;
    1645                 :      722608 :                e = e->next_callee)
    1646                 :             :             {
    1647                 :     1693011 :               enum availability avail;
    1648                 :     1693011 :               struct cgraph_node *y = e->callee->
    1649                 :     3386022 :                                 function_or_virtual_thunk_symbol (&avail,
    1650                 :     1693011 :                                                                   e->caller);
    1651                 :     1693011 :               enum pure_const_state_e edge_state = IPA_CONST;
    1652                 :     1693011 :               bool edge_looping = false;
    1653                 :             : 
    1654                 :     1693011 :               if (e->recursive_p ())
    1655                 :        5797 :                 looping = true;
    1656                 :             : 
    1657                 :     1693011 :               if (dump_file && (dump_flags & TDF_DETAILS))
    1658                 :             :                 {
    1659                 :           7 :                   fprintf (dump_file, "    Call to %s",
    1660                 :           7 :                            e->callee->dump_name ());
    1661                 :             :                 }
    1662                 :     1693011 :               if (avail > AVAIL_INTERPOSABLE)
    1663                 :             :                 {
    1664                 :      579118 :                   funct_state y_l = funct_state_summaries->get_create (y);
    1665                 :             : 
    1666                 :      579118 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    1667                 :             :                     {
    1668                 :           2 :                       fprintf (dump_file,
    1669                 :             :                                " state:%s looping:%i\n",
    1670                 :           2 :                                pure_const_names[y_l->pure_const_state],
    1671                 :           2 :                                y_l->looping);
    1672                 :             :                     }
    1673                 :      579118 :                   if (y_l->pure_const_state > IPA_PURE
    1674                 :      579118 :                       && e->cannot_lead_to_return_p ())
    1675                 :             :                     {
    1676                 :        8091 :                       if (dump_file && (dump_flags & TDF_DETAILS))
    1677                 :           0 :                         fprintf (dump_file,
    1678                 :             :                                  "        Ignoring side effects"
    1679                 :             :                                  " -> pure, looping\n");
    1680                 :        8091 :                       edge_state = IPA_PURE;
    1681                 :        8091 :                       edge_looping = true;
    1682                 :             :                     }
    1683                 :             :                   else
    1684                 :             :                     {
    1685                 :      571027 :                       edge_state = y_l->pure_const_state;
    1686                 :      571027 :                       edge_looping = y_l->looping;
    1687                 :             :                     }
    1688                 :             :                 }
    1689                 :     1113893 :               else if (builtin_safe_for_const_function_p (&edge_looping,
    1690                 :             :                                                            y->decl))
    1691                 :             :                 edge_state = IPA_CONST;
    1692                 :             :               else
    1693                 :     1002858 :                 state_from_flags (&edge_state, &edge_looping,
    1694                 :     1002858 :                                   flags_from_decl_or_type (y->decl),
    1695                 :     1002858 :                                   e->cannot_lead_to_return_p ());
    1696                 :             : 
    1697                 :             :               /* Merge the results with what we already know.  */
    1698                 :     1693011 :               better_state (&edge_state, &edge_looping,
    1699                 :             :                             w_l->state_previously_known,
    1700                 :     1693011 :                             w_l->looping_previously_known);
    1701                 :     1693011 :               worse_state (&pure_const_state, &looping,
    1702                 :     1693011 :                            edge_state, edge_looping, e->caller, e->callee);
    1703                 :     1693011 :               if (pure_const_state == IPA_NEITHER)
    1704                 :             :                 break;
    1705                 :             :             }
    1706                 :             : 
    1707                 :             :           /* Now process the indirect call.  */
    1708                 :     1459075 :           for (ie = w->indirect_calls;
    1709                 :     1459775 :                ie && pure_const_state != IPA_NEITHER; ie = ie->next_callee)
    1710                 :             :             {
    1711                 :       25634 :               enum pure_const_state_e edge_state = IPA_CONST;
    1712                 :       25634 :               bool edge_looping = false;
    1713                 :             : 
    1714                 :       25634 :               if (dump_file && (dump_flags & TDF_DETAILS))
    1715                 :           0 :                 fprintf (dump_file, "    Indirect call");
    1716                 :       51268 :               state_from_flags (&edge_state, &edge_looping,
    1717                 :       25634 :                                 ie->indirect_info->ecf_flags,
    1718                 :       25634 :                                 ie->cannot_lead_to_return_p ());
    1719                 :             :               /* Merge the results with what we already know.  */
    1720                 :       25634 :               better_state (&edge_state, &edge_looping,
    1721                 :             :                             w_l->state_previously_known,
    1722                 :       25634 :                             w_l->looping_previously_known);
    1723                 :       25634 :               worse_state (&pure_const_state, &looping,
    1724                 :             :                            edge_state, edge_looping, NULL, NULL);
    1725                 :       25634 :               if (pure_const_state == IPA_NEITHER)
    1726                 :             :                 break;
    1727                 :             :             }
    1728                 :             : 
    1729                 :             :           /* And finally all loads and stores.  */
    1730                 :      308704 :           for (i = 0; w->iterate_reference (i, ref)
    1731                 :     2386515 :                && pure_const_state != IPA_NEITHER; i++)
    1732                 :             :             {
    1733                 :      334796 :               enum pure_const_state_e ref_state = IPA_CONST;
    1734                 :      334796 :               bool ref_looping = false;
    1735                 :      334796 :               switch (ref->use)
    1736                 :             :                 {
    1737                 :      212304 :                 case IPA_REF_LOAD:
    1738                 :             :                   /* readonly reads are safe.  */
    1739                 :      212304 :                   if (TREE_READONLY (ref->referred->decl))
    1740                 :             :                     break;
    1741                 :      199110 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    1742                 :           0 :                     fprintf (dump_file, "    nonreadonly global var read\n");
    1743                 :      199110 :                   ref_state = IPA_PURE;
    1744                 :      199110 :                   break;
    1745                 :       87711 :                 case IPA_REF_STORE:
    1746                 :       87711 :                   if (ref->cannot_lead_to_return ())
    1747                 :             :                     break;
    1748                 :       26150 :                   ref_state = IPA_NEITHER;
    1749                 :       26150 :                   if (dump_file && (dump_flags & TDF_DETAILS))
    1750                 :           0 :                     fprintf (dump_file, "    global var write\n");
    1751                 :             :                   break;
    1752                 :             :                 case IPA_REF_ADDR:
    1753                 :             :                   break;
    1754                 :           0 :                 default:
    1755                 :           0 :                   gcc_unreachable ();
    1756                 :             :                 }
    1757                 :      334796 :               better_state (&ref_state, &ref_looping,
    1758                 :             :                             w_l->state_previously_known,
    1759                 :      334796 :                             w_l->looping_previously_known);
    1760                 :      334796 :               worse_state (&pure_const_state, &looping,
    1761                 :             :                            ref_state, ref_looping, NULL, NULL);
    1762                 :      334796 :               if (pure_const_state == IPA_NEITHER)
    1763                 :             :                 break;
    1764                 :             :             }
    1765                 :     1459075 :           w_info = (struct ipa_dfs_info *) w->aux;
    1766                 :     1459075 :           w = w_info->next_cycle;
    1767                 :             :         }
    1768                 :     2113485 :       if (dump_file && (dump_flags & TDF_DETAILS))
    1769                 :           5 :         fprintf (dump_file, "Result %s looping %i\n",
    1770                 :           5 :                  pure_const_names [pure_const_state],
    1771                 :             :                  looping);
    1772                 :             : 
    1773                 :             :       /* Find the worst state of can_free for any node in the cycle.  */
    1774                 :             :       bool can_free = false;
    1775                 :             :       w = node;
    1776                 :     4230237 :       while (w && !can_free)
    1777                 :             :         {
    1778                 :     2116752 :           struct cgraph_edge *e;
    1779                 :     2116752 :           funct_state w_l = funct_state_summaries->get (w);
    1780                 :             : 
    1781                 :     2116752 :           if (w_l->can_free
    1782                 :     1940731 :               || w->get_availability () == AVAIL_INTERPOSABLE
    1783                 :     3981525 :               || w->indirect_calls)
    1784                 :             :             can_free = true;
    1785                 :             : 
    1786                 :     3650535 :           for (e = w->callees; e && !can_free; e = e->next_callee)
    1787                 :             :             {
    1788                 :     1533783 :               enum availability avail;
    1789                 :     1533783 :               struct cgraph_node *y = e->callee->
    1790                 :     3067566 :                                 function_or_virtual_thunk_symbol (&avail,
    1791                 :     1533783 :                                                                   e->caller);
    1792                 :             : 
    1793                 :     1533783 :               if (avail > AVAIL_INTERPOSABLE)
    1794                 :      708838 :                 can_free = funct_state_summaries->get (y)->can_free;
    1795                 :             :               else
    1796                 :             :                 can_free = true;
    1797                 :             :             }
    1798                 :     2116752 :           w_info = (struct ipa_dfs_info *) w->aux;
    1799                 :     2116752 :           w = w_info->next_cycle;
    1800                 :             :         }
    1801                 :             : 
    1802                 :             :       /* Copy back the region's pure_const_state which is shared by
    1803                 :             :          all nodes in the region.  */
    1804                 :             :       w = node;
    1805                 :     4247671 :       while (w)
    1806                 :             :         {
    1807                 :     2134186 :           funct_state w_l = funct_state_summaries->get (w);
    1808                 :     2134186 :           enum pure_const_state_e this_state = pure_const_state;
    1809                 :     2134186 :           bool this_looping = looping;
    1810                 :             : 
    1811                 :     2134186 :           w_l->can_free = can_free;
    1812                 :     2134186 :           w->nonfreeing_fn = !can_free;
    1813                 :     2134186 :           if (!can_free && dump_file)
    1814                 :          28 :             fprintf (dump_file, "Function found not to call free: %s\n",
    1815                 :             :                      w->dump_name ());
    1816                 :             : 
    1817                 :     2134186 :           if (w_l->state_previously_known != IPA_NEITHER
    1818                 :      350470 :               && this_state > w_l->state_previously_known)
    1819                 :             :             {
    1820                 :         940 :               if (this_state == IPA_NEITHER)
    1821                 :          50 :                 this_looping = w_l->looping_previously_known;
    1822                 :             :               this_state = w_l->state_previously_known;
    1823                 :             :             }
    1824                 :     2134186 :           if (!this_looping && self_recursive_p (w))
    1825                 :             :             this_looping = true;
    1826                 :     2134186 :           if (!w_l->looping_previously_known)
    1827                 :      267485 :             this_looping = false;
    1828                 :             : 
    1829                 :             :           /* All nodes within a cycle share the same info.  */
    1830                 :     2134186 :           w_l->pure_const_state = this_state;
    1831                 :     2134186 :           w_l->looping = this_looping;
    1832                 :             : 
    1833                 :             :           /* Inline clones share declaration with their offline copies;
    1834                 :             :              do not modify their declarations since the offline copy may
    1835                 :             :              be different.  */
    1836                 :     2134186 :           if (!w->inlined_to)
    1837                 :      999885 :             switch (this_state)
    1838                 :             :               {
    1839                 :      155651 :               case IPA_CONST:
    1840                 :      155651 :                 remove_p |= ipa_make_function_const (w, this_looping, false);
    1841                 :      155651 :                 break;
    1842                 :             : 
    1843                 :       94415 :               case IPA_PURE:
    1844                 :       94415 :                 remove_p |= ipa_make_function_pure (w, this_looping, false);
    1845                 :       94415 :                 break;
    1846                 :             : 
    1847                 :             :               default:
    1848                 :             :                 break;
    1849                 :             :               }
    1850                 :     2134186 :           w_info = (struct ipa_dfs_info *) w->aux;
    1851                 :     2134186 :           w = w_info->next_cycle;
    1852                 :             :         }
    1853                 :             :     }
    1854                 :             : 
    1855                 :      144942 :   ipa_free_postorder_info ();
    1856                 :      144942 :   free (order);
    1857                 :      144942 :   return remove_p;
    1858                 :             : }
    1859                 :             : 
    1860                 :             : /* Produce transitive closure over the callgraph and compute nothrow
    1861                 :             :    attributes.  */
    1862                 :             : 
    1863                 :             : static void
    1864                 :      144942 : propagate_nothrow (void)
    1865                 :             : {
    1866                 :      144942 :   struct cgraph_node *node;
    1867                 :      144942 :   struct cgraph_node *w;
    1868                 :      144942 :   struct cgraph_node **order =
    1869                 :      144942 :     XCNEWVEC (struct cgraph_node *, symtab->cgraph_count);
    1870                 :      144942 :   int order_pos;
    1871                 :      144942 :   int i;
    1872                 :      144942 :   struct ipa_dfs_info * w_info;
    1873                 :             : 
    1874                 :      144942 :   order_pos = ipa_reduced_postorder (order, true,
    1875                 :             :                                      ignore_edge_for_nothrow);
    1876                 :      144942 :   if (dump_file)
    1877                 :             :     {
    1878                 :          29 :       cgraph_node::dump_cgraph (dump_file);
    1879                 :          29 :       ipa_print_order (dump_file, "reduced for nothrow", order, order_pos);
    1880                 :             :     }
    1881                 :             : 
    1882                 :             :   /* Propagate the local information through the call graph to produce
    1883                 :             :      the global information.  All the nodes within a cycle will have
    1884                 :             :      the same info so we collapse cycles first.  Then we can do the
    1885                 :             :      propagation in one pass from the leaves to the roots.  */
    1886                 :     2311548 :   for (i = 0; i < order_pos; i++ )
    1887                 :             :     {
    1888                 :     2166606 :       bool can_throw = false;
    1889                 :     2166606 :       node = order[i];
    1890                 :             : 
    1891                 :     2166606 :       if (node->alias)
    1892                 :       37348 :         continue;
    1893                 :             : 
    1894                 :             :       /* Find the worst state for any node in the cycle.  */
    1895                 :             :       w = node;
    1896                 :     4258669 :       while (w && !can_throw)
    1897                 :             :         {
    1898                 :     2129411 :           struct cgraph_edge *e, *ie;
    1899                 :             : 
    1900                 :     2129411 :           if (!TREE_NOTHROW (w->decl))
    1901                 :             :             {
    1902                 :      849678 :               funct_state w_l = funct_state_summaries->get_create (w);
    1903                 :             : 
    1904                 :      849678 :               if (w_l->can_throw
    1905                 :      849678 :                   || w->get_availability () == AVAIL_INTERPOSABLE)
    1906                 :             :                 can_throw = true;
    1907                 :             : 
    1908                 :     1543729 :               for (e = w->callees; e && !can_throw; e = e->next_callee)
    1909                 :             :                 {
    1910                 :      694051 :                   enum availability avail;
    1911                 :             : 
    1912                 :      694051 :                   if (!e->can_throw_external || TREE_NOTHROW (e->callee->decl))
    1913                 :      164465 :                     continue;
    1914                 :             : 
    1915                 :      529586 :                   struct cgraph_node *y = e->callee->
    1916                 :     1059172 :                                    function_or_virtual_thunk_symbol (&avail,
    1917                 :      529586 :                                                                      e->caller);
    1918                 :             : 
    1919                 :             :                   /* We can use info about the callee only if we know it
    1920                 :             :                      cannot be interposed.
    1921                 :             :                      When callee is compiled with non-call exceptions we also
    1922                 :             :                      must check that the declaration is bound to current
    1923                 :             :                      body as other semantically equivalent body may still
    1924                 :             :                      throw.  */
    1925                 :      529586 :                   if (avail <= AVAIL_INTERPOSABLE
    1926                 :      529586 :                       || (!TREE_NOTHROW (y->decl)
    1927                 :      254115 :                           && (funct_state_summaries->get_create (y)->can_throw
    1928                 :        2085 :                               || (opt_for_fn (y->decl, flag_non_call_exceptions)
    1929                 :         485 :                                   && !e->callee->binds_to_current_def_p (w)))))
    1930                 :             :                     can_throw = true;
    1931                 :             :                 }
    1932                 :      863407 :               for (ie = w->indirect_calls; ie && !can_throw;
    1933                 :       13729 :                    ie = ie->next_callee)
    1934                 :       13729 :                 if (ie->can_throw_external
    1935                 :       12313 :                     && !(ie->indirect_info->ecf_flags & ECF_NOTHROW))
    1936                 :       13729 :                   can_throw = true;
    1937                 :             :             }
    1938                 :     2129411 :           w_info = (struct ipa_dfs_info *) w->aux;
    1939                 :     2129411 :           w = w_info->next_cycle;
    1940                 :             :         }
    1941                 :             : 
    1942                 :             :       /* Copy back the region's pure_const_state which is shared by
    1943                 :             :          all nodes in the region.  */
    1944                 :             :       w = node;
    1945                 :     4263444 :       while (w)
    1946                 :             :         {
    1947                 :     2134186 :           funct_state w_l = funct_state_summaries->get_create (w);
    1948                 :     2134186 :           if (!can_throw && !TREE_NOTHROW (w->decl))
    1949                 :             :             {
    1950                 :             :               /* Inline clones share declaration with their offline copies;
    1951                 :             :                  do not modify their declarations since the offline copy may
    1952                 :             :                  be different.  */
    1953                 :       12280 :               if (!w->inlined_to)
    1954                 :             :                 {
    1955                 :        2833 :                   w->set_nothrow_flag (true);
    1956                 :        2833 :                   if (dump_file)
    1957                 :           0 :                     fprintf (dump_file, "Function found to be nothrow: %s\n",
    1958                 :             :                              w->dump_name ());
    1959                 :             :                 }
    1960                 :             :             }
    1961                 :      842137 :           else if (can_throw && !TREE_NOTHROW (w->decl))
    1962                 :      842137 :             w_l->can_throw = true;
    1963                 :     2134186 :           w_info = (struct ipa_dfs_info *) w->aux;
    1964                 :     2134186 :           w = w_info->next_cycle;
    1965                 :             :         }
    1966                 :             :     }
    1967                 :             : 
    1968                 :      144942 :   ipa_free_postorder_info ();
    1969                 :      144942 :   free (order);
    1970                 :      144942 : }
    1971                 :             : 
    1972                 :             : /* Debugging function to dump state of malloc lattice.  */
    1973                 :             : 
    1974                 :             : DEBUG_FUNCTION
    1975                 :             : static void
    1976                 :      289884 : dump_malloc_lattice (FILE *dump_file, const char *s)
    1977                 :             : {
    1978                 :      289884 :   if (!dump_file)
    1979                 :             :     return;
    1980                 :             : 
    1981                 :          58 :   fprintf (dump_file, "\n\nMALLOC LATTICE %s:\n", s);
    1982                 :          58 :   cgraph_node *node;
    1983                 :         580 :   FOR_EACH_FUNCTION (node)
    1984                 :             :     {
    1985                 :         232 :       funct_state fs = funct_state_summaries->get (node);
    1986                 :         232 :       if (fs)
    1987                 :         156 :         fprintf (dump_file, "%s: %s\n", node->dump_name (),
    1988                 :         156 :                  malloc_state_names[fs->malloc_state]);
    1989                 :             :     }
    1990                 :             : }
    1991                 :             : 
    1992                 :             : /* Propagate malloc attribute across the callgraph.  */
    1993                 :             : 
    1994                 :             : static void
    1995                 :      144942 : propagate_malloc (void)
    1996                 :             : {
    1997                 :      144942 :   cgraph_node *node;
    1998                 :     7387282 :   FOR_EACH_FUNCTION (node)
    1999                 :             :     {
    2000                 :     3548699 :       if (DECL_IS_MALLOC (node->decl))
    2001                 :       41720 :         if (!funct_state_summaries->exists (node))
    2002                 :             :           {
    2003                 :       20714 :             funct_state fs = funct_state_summaries->get_create (node);
    2004                 :       20714 :             fs->malloc_state = STATE_MALLOC;
    2005                 :             :           }
    2006                 :             :     }
    2007                 :             : 
    2008                 :      144942 :   dump_malloc_lattice (dump_file, "Initial");
    2009                 :      144942 :   struct cgraph_node **order
    2010                 :      144942 :     = XNEWVEC (struct cgraph_node *, symtab->cgraph_count);
    2011                 :      144942 :   int order_pos = ipa_reverse_postorder (order);
    2012                 :      144942 :   bool changed = true;
    2013                 :             : 
    2014                 :      436619 :   while (changed)
    2015                 :             :     {
    2016                 :      146735 :       changed = false;
    2017                 :             :       /* Walk in postorder.  */
    2018                 :     4355812 :       for (int i = order_pos - 1; i >= 0; --i)
    2019                 :             :         {
    2020                 :     4209077 :           cgraph_node *node = order[i];
    2021                 :     5771234 :           if (node->alias
    2022                 :     4209077 :               || !node->definition
    2023                 :     4209077 :               || !funct_state_summaries->exists (node))
    2024                 :     4159922 :             continue;
    2025                 :             : 
    2026                 :     2646920 :           funct_state l = funct_state_summaries->get (node);
    2027                 :             : 
    2028                 :             :           /* FIXME: add support for indirect-calls.  */
    2029                 :     2646920 :           if (node->indirect_calls)
    2030                 :             :             {
    2031                 :      139548 :               l->malloc_state = STATE_MALLOC_BOTTOM;
    2032                 :      139548 :               continue;
    2033                 :             :             }
    2034                 :             : 
    2035                 :     2507372 :           if (node->get_availability () <= AVAIL_INTERPOSABLE)
    2036                 :             :             {
    2037                 :       90035 :               l->malloc_state = STATE_MALLOC_BOTTOM;
    2038                 :       90035 :               continue;
    2039                 :             :             }
    2040                 :             : 
    2041                 :     2417337 :           if (l->malloc_state == STATE_MALLOC_BOTTOM)
    2042                 :     2368182 :             continue;
    2043                 :             : 
    2044                 :       49155 :           auto_vec<cgraph_node *, 16> callees;
    2045                 :      186356 :           for (cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
    2046                 :             :             {
    2047                 :      137201 :               ipa_call_summary *es = ipa_call_summaries->get_create (cs);
    2048                 :      137201 :               if (es && es->is_return_callee_uncaptured)
    2049                 :       12032 :                 callees.safe_push (cs->callee);
    2050                 :             :             }
    2051                 :             : 
    2052                 :       49155 :           malloc_state_e new_state = l->malloc_state;
    2053                 :      122374 :           for (unsigned j = 0; j < callees.length (); j++)
    2054                 :             :             {
    2055                 :       12032 :               cgraph_node *callee = callees[j];
    2056                 :       12032 :               if (!funct_state_summaries->exists (node))
    2057                 :             :                 {
    2058                 :             :                   new_state = STATE_MALLOC_BOTTOM;
    2059                 :             :                   break;
    2060                 :             :                 }
    2061                 :       12032 :               malloc_state_e callee_state
    2062                 :       12032 :                 = funct_state_summaries->get_create (callee)->malloc_state;
    2063                 :       12032 :               if (new_state < callee_state)
    2064                 :       10146 :                 new_state = callee_state;
    2065                 :             :             }
    2066                 :       49155 :           if (new_state != l->malloc_state)
    2067                 :             :             {
    2068                 :       10128 :               changed = true;
    2069                 :       10128 :               l->malloc_state = new_state;
    2070                 :             :             }
    2071                 :       49155 :         }
    2072                 :             :     }
    2073                 :             : 
    2074                 :     2316480 :   FOR_EACH_DEFINED_FUNCTION (node)
    2075                 :     2171538 :     if (funct_state_summaries->exists (node))
    2076                 :             :       {
    2077                 :     2159277 :         funct_state l = funct_state_summaries->get (node);
    2078                 :     2159277 :         if (!node->alias
    2079                 :     2134186 :             && l->malloc_state == STATE_MALLOC
    2080                 :       16054 :             && !node->inlined_to
    2081                 :     2159667 :             && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (node->decl))))
    2082                 :             :           {
    2083                 :         390 :             if (dump_file && (dump_flags & TDF_DETAILS))
    2084                 :           6 :               fprintf (dump_file, "Function %s found to be malloc\n",
    2085                 :             :                        node->dump_name ());
    2086                 :             : 
    2087                 :         390 :             bool malloc_decl_p = DECL_IS_MALLOC (node->decl);
    2088                 :         390 :             node->set_malloc_flag (true);
    2089                 :         390 :             if (!malloc_decl_p && warn_suggest_attribute_malloc)
    2090                 :           0 :                 warn_function_malloc (node->decl);
    2091                 :             :           }
    2092                 :             :       }
    2093                 :             : 
    2094                 :      144942 :   dump_malloc_lattice (dump_file, "after propagation");
    2095                 :      144942 :   ipa_free_postorder_info ();
    2096                 :      144942 :   free (order);
    2097                 :      144942 : }
    2098                 :             : 
    2099                 :             : /* Produce the global information by preforming a transitive closure
    2100                 :             :    on the local information that was produced by generate_summary.  */
    2101                 :             : 
    2102                 :             : unsigned int
    2103                 :      144942 : pass_ipa_pure_const::
    2104                 :             : execute (function *)
    2105                 :             : {
    2106                 :      144942 :   bool remove_p;
    2107                 :             : 
    2108                 :             :   /* Nothrow makes more function to not lead to return and improve
    2109                 :             :      later analysis.  */
    2110                 :      144942 :   propagate_nothrow ();
    2111                 :      144942 :   propagate_malloc ();
    2112                 :      144942 :   remove_p = propagate_pure_const ();
    2113                 :             : 
    2114                 :      144942 :   delete funct_state_summaries;
    2115                 :      144942 :   return remove_p ? TODO_remove_functions : 0;
    2116                 :             : }
    2117                 :             : 
    2118                 :             : static bool
    2119                 :     3800370 : gate_pure_const (void)
    2120                 :             : {
    2121                 :      565525 :   return flag_ipa_pure_const || in_lto_p;
    2122                 :             : }
    2123                 :             : 
    2124                 :      273196 : pass_ipa_pure_const::pass_ipa_pure_const(gcc::context *ctxt)
    2125                 :             :     : ipa_opt_pass_d(pass_data_ipa_pure_const, ctxt,
    2126                 :             :                      pure_const_generate_summary, /* generate_summary */
    2127                 :             :                      pure_const_write_summary, /* write_summary */
    2128                 :             :                      pure_const_read_summary, /* read_summary */
    2129                 :             :                      NULL, /* write_optimization_summary */
    2130                 :             :                      NULL, /* read_optimization_summary */
    2131                 :             :                      NULL, /* stmt_fixup */
    2132                 :             :                      0, /* function_transform_todo_flags_start */
    2133                 :             :                      NULL, /* function_transform */
    2134                 :             :                      NULL), /* variable_transform */
    2135                 :      273196 :   init_p (false) {}
    2136                 :             : 
    2137                 :             : ipa_opt_pass_d *
    2138                 :      273196 : make_pass_ipa_pure_const (gcc::context *ctxt)
    2139                 :             : {
    2140                 :      273196 :   return new pass_ipa_pure_const (ctxt);
    2141                 :             : }
    2142                 :             : 
    2143                 :             : /* Simple local pass for pure const discovery reusing the analysis from
    2144                 :             :    ipa_pure_const.   This pass is effective when executed together with
    2145                 :             :    other optimization passes in early optimization pass queue.  */
    2146                 :             : 
    2147                 :             : namespace {
    2148                 :             : 
    2149                 :             : const pass_data pass_data_local_pure_const =
    2150                 :             : {
    2151                 :             :   GIMPLE_PASS, /* type */
    2152                 :             :   "local-pure-const", /* name */
    2153                 :             :   OPTGROUP_NONE, /* optinfo_flags */
    2154                 :             :   TV_IPA_PURE_CONST, /* tv_id */
    2155                 :             :   0, /* properties_required */
    2156                 :             :   0, /* properties_provided */
    2157                 :             :   0, /* properties_destroyed */
    2158                 :             :   0, /* todo_flags_start */
    2159                 :             :   0, /* todo_flags_finish */
    2160                 :             : };
    2161                 :             : 
    2162                 :             : class pass_local_pure_const : public gimple_opt_pass
    2163                 :             : {
    2164                 :             : public:
    2165                 :      546392 :   pass_local_pure_const (gcc::context *ctxt)
    2166                 :     1092784 :     : gimple_opt_pass (pass_data_local_pure_const, ctxt)
    2167                 :             :   {}
    2168                 :             : 
    2169                 :             :   /* opt_pass methods: */
    2170                 :      273196 :   opt_pass * clone () final override
    2171                 :             :   {
    2172                 :      273196 :     return new pass_local_pure_const (m_ctxt);
    2173                 :             :   }
    2174                 :     3235093 :   bool gate (function *) final override { return gate_pure_const (); }
    2175                 :             :   unsigned int execute (function *) final override;
    2176                 :             : 
    2177                 :             : }; // class pass_local_pure_const
    2178                 :             : 
    2179                 :             : unsigned int
    2180                 :     3234795 : pass_local_pure_const::execute (function *fun)
    2181                 :             : {
    2182                 :     3234795 :   bool changed = false;
    2183                 :     3234795 :   funct_state l;
    2184                 :     3234795 :   bool skip;
    2185                 :     3234795 :   struct cgraph_node *node;
    2186                 :             : 
    2187                 :     3234795 :   node = cgraph_node::get (current_function_decl);
    2188                 :     3234795 :   skip = skip_function_for_local_pure_const (node);
    2189                 :             : 
    2190                 :     3234795 :   if (!warn_suggest_attribute_const
    2191                 :     3234772 :       && !warn_suggest_attribute_pure
    2192                 :     3234751 :       && skip)
    2193                 :             :     return 0;
    2194                 :             : 
    2195                 :     3073171 :   l = analyze_function (node, false);
    2196                 :             : 
    2197                 :             :   /* Do NORETURN discovery.  */
    2198                 :     3073171 :   if (!skip && !TREE_THIS_VOLATILE (current_function_decl)
    2199                 :     6120997 :       && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
    2200                 :             :     {
    2201                 :       29798 :       warn_function_noreturn (fun->decl);
    2202                 :       29798 :       if (dump_file)
    2203                 :           1 :         fprintf (dump_file, "Function found to be noreturn: %s\n",
    2204                 :             :                  current_function_name ());
    2205                 :             : 
    2206                 :             :       /* Update declaration and reduce profile to executed once.  */
    2207                 :       29798 :       if (cgraph_node::get (current_function_decl)->set_noreturn_flag (true))
    2208                 :             :         changed = true;
    2209                 :       29798 :       if (node->frequency > NODE_FREQUENCY_EXECUTED_ONCE)
    2210                 :       11212 :         node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
    2211                 :             :     }
    2212                 :             : 
    2213                 :     3073171 :   switch (l->pure_const_state)
    2214                 :             :     {
    2215                 :      625111 :     case IPA_CONST:
    2216                 :     1250222 :       changed |= ipa_make_function_const
    2217                 :      625111 :                    (cgraph_node::get (current_function_decl), l->looping, true);
    2218                 :      625111 :       break;
    2219                 :             : 
    2220                 :      374774 :     case IPA_PURE:
    2221                 :      749548 :       changed |= ipa_make_function_pure
    2222                 :      374774 :                    (cgraph_node::get (current_function_decl), l->looping, true);
    2223                 :      374774 :       break;
    2224                 :             : 
    2225                 :             :     default:
    2226                 :             :       break;
    2227                 :             :     }
    2228                 :     3073171 :   if (!l->can_throw && !TREE_NOTHROW (current_function_decl))
    2229                 :             :     {
    2230                 :       21004 :       node->set_nothrow_flag (true);
    2231                 :       21004 :       changed = true;
    2232                 :       21004 :       if (dump_file)
    2233                 :           2 :         fprintf (dump_file, "Function found to be nothrow: %s\n",
    2234                 :             :                  current_function_name ());
    2235                 :             :     }
    2236                 :             : 
    2237                 :     3073171 :   if (l->malloc_state == STATE_MALLOC
    2238                 :     3073171 :       && !DECL_IS_MALLOC (current_function_decl))
    2239                 :             :     {
    2240                 :       20278 :       node->set_malloc_flag (true);
    2241                 :       20278 :       if (warn_suggest_attribute_malloc)
    2242                 :           3 :         warn_function_malloc (node->decl);
    2243                 :       20278 :       changed = true;
    2244                 :       20278 :       if (dump_file)
    2245                 :           2 :         fprintf (dump_file, "Function found to be malloc: %s\n",
    2246                 :             :                  node->dump_name ());
    2247                 :             :     }
    2248                 :             : 
    2249                 :     3073171 :   free (l);
    2250                 :     3073171 :   if (changed)
    2251                 :      824437 :     return execute_fixup_cfg ();
    2252                 :             :   else
    2253                 :             :     return 0;
    2254                 :             : }
    2255                 :             : 
    2256                 :             : } // anon namespace
    2257                 :             : 
    2258                 :             : gimple_opt_pass *
    2259                 :      273196 : make_pass_local_pure_const (gcc::context *ctxt)
    2260                 :             : {
    2261                 :      273196 :   return new pass_local_pure_const (ctxt);
    2262                 :             : }
    2263                 :             : 
    2264                 :             : /* Emit noreturn warnings.  */
    2265                 :             : 
    2266                 :             : namespace {
    2267                 :             : 
    2268                 :             : const pass_data pass_data_warn_function_noreturn =
    2269                 :             : {
    2270                 :             :   GIMPLE_PASS, /* type */
    2271                 :             :   "*warn_function_noreturn", /* name */
    2272                 :             :   OPTGROUP_NONE, /* optinfo_flags */
    2273                 :             :   TV_NONE, /* tv_id */
    2274                 :             :   PROP_cfg, /* properties_required */
    2275                 :             :   0, /* properties_provided */
    2276                 :             :   0, /* properties_destroyed */
    2277                 :             :   0, /* todo_flags_start */
    2278                 :             :   0, /* todo_flags_finish */
    2279                 :             : };
    2280                 :             : 
    2281                 :             : class pass_warn_function_noreturn : public gimple_opt_pass
    2282                 :             : {
    2283                 :             : public:
    2284                 :      273196 :   pass_warn_function_noreturn (gcc::context *ctxt)
    2285                 :      546392 :     : gimple_opt_pass (pass_data_warn_function_noreturn, ctxt)
    2286                 :             :   {}
    2287                 :             : 
    2288                 :             :   /* opt_pass methods: */
    2289                 :     1422113 :   bool gate (function *) final override
    2290                 :             :   {
    2291                 :     1422113 :     return warn_suggest_attribute_noreturn;
    2292                 :             :   }
    2293                 :          27 :   unsigned int execute (function *fun) final override
    2294                 :             :     {
    2295                 :          27 :       if (!TREE_THIS_VOLATILE (current_function_decl)
    2296                 :          27 :           && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) == 0)
    2297                 :           4 :         warn_function_noreturn (current_function_decl);
    2298                 :          27 :       return 0;
    2299                 :             :     }
    2300                 :             : 
    2301                 :             : }; // class pass_warn_function_noreturn
    2302                 :             : 
    2303                 :             : } // anon namespace
    2304                 :             : 
    2305                 :             : gimple_opt_pass *
    2306                 :      273196 : make_pass_warn_function_noreturn (gcc::context *ctxt)
    2307                 :             : {
    2308                 :      273196 :   return new pass_warn_function_noreturn (ctxt);
    2309                 :             : }
    2310                 :             : 
    2311                 :             : /* Simple local pass for pure const discovery reusing the analysis from
    2312                 :             :    ipa_pure_const.   This pass is effective when executed together with
    2313                 :             :    other optimization passes in early optimization pass queue.  */
    2314                 :             : 
    2315                 :             : namespace {
    2316                 :             : 
    2317                 :             : const pass_data pass_data_nothrow =
    2318                 :             : {
    2319                 :             :   GIMPLE_PASS, /* type */
    2320                 :             :   "nothrow", /* name */
    2321                 :             :   OPTGROUP_NONE, /* optinfo_flags */
    2322                 :             :   TV_IPA_PURE_CONST, /* tv_id */
    2323                 :             :   0, /* properties_required */
    2324                 :             :   0, /* properties_provided */
    2325                 :             :   0, /* properties_destroyed */
    2326                 :             :   0, /* todo_flags_start */
    2327                 :             :   0, /* todo_flags_finish */
    2328                 :             : };
    2329                 :             : 
    2330                 :             : class pass_nothrow : public gimple_opt_pass
    2331                 :             : {
    2332                 :             : public:
    2333                 :      273196 :   pass_nothrow (gcc::context *ctxt)
    2334                 :      546392 :     : gimple_opt_pass (pass_data_nothrow, ctxt)
    2335                 :             :   {}
    2336                 :             : 
    2337                 :             :   /* opt_pass methods: */
    2338                 :           0 :   opt_pass * clone () final override { return new pass_nothrow (m_ctxt); }
    2339                 :     2671760 :   bool gate (function *) final override { return optimize; }
    2340                 :             :   unsigned int execute (function *) final override;
    2341                 :             : 
    2342                 :             : }; // class pass_nothrow
    2343                 :             : 
    2344                 :             : unsigned int
    2345                 :     2240915 : pass_nothrow::execute (function *)
    2346                 :             : {
    2347                 :     2240915 :   struct cgraph_node *node;
    2348                 :     2240915 :   basic_block this_block;
    2349                 :             : 
    2350                 :     2240915 :   if (TREE_NOTHROW (current_function_decl))
    2351                 :             :     return 0;
    2352                 :             : 
    2353                 :     1393768 :   node = cgraph_node::get (current_function_decl);
    2354                 :             : 
    2355                 :             :   /* We run during lowering, we cannot really use availability yet.  */
    2356                 :     1393768 :   if (cgraph_node::get (current_function_decl)->get_availability ()
    2357                 :             :       <= AVAIL_INTERPOSABLE)
    2358                 :             :     {
    2359                 :       78534 :       if (dump_file)
    2360                 :           0 :         fprintf (dump_file, "Function is interposable;"
    2361                 :             :                  " not analyzing.\n");
    2362                 :       78534 :       return true;
    2363                 :             :     }
    2364                 :             : 
    2365                 :    10141872 :   FOR_EACH_BB_FN (this_block, cfun)
    2366                 :             :     {
    2367                 :    18742400 :       for (gimple_stmt_iterator gsi = gsi_start_bb (this_block);
    2368                 :    45901109 :            !gsi_end_p (gsi);
    2369                 :    36529909 :            gsi_next (&gsi))
    2370                 :    37074471 :         if (stmt_can_throw_external (cfun, gsi_stmt (gsi)))
    2371                 :             :           {
    2372                 :      545860 :             if (is_gimple_call (gsi_stmt (gsi)))
    2373                 :             :               {
    2374                 :      341383 :                 tree callee_t = gimple_call_fndecl (gsi_stmt (gsi));
    2375                 :      341383 :                 if (callee_t && recursive_call_p (current_function_decl,
    2376                 :             :                                                   callee_t))
    2377                 :        1298 :                   continue;
    2378                 :             :               }
    2379                 :             :         
    2380                 :      544562 :             if (dump_file)
    2381                 :             :               {
    2382                 :           0 :                 fprintf (dump_file, "Statement can throw: ");
    2383                 :           0 :                 print_gimple_stmt (dump_file, gsi_stmt (gsi), 0);
    2384                 :             :               }
    2385                 :      544562 :             return 0;
    2386                 :             :           }
    2387                 :             :     }
    2388                 :             : 
    2389                 :      770672 :   node->set_nothrow_flag (true);
    2390                 :             : 
    2391                 :      770672 :   bool cfg_changed = false;
    2392                 :      770672 :   if (self_recursive_p (node))
    2393                 :       29247 :     FOR_EACH_BB_FN (this_block, cfun)
    2394                 :       79198 :       if (gcall *g = safe_dyn_cast <gcall *> (*gsi_last_bb (this_block)))
    2395                 :             :         {
    2396                 :        1957 :           tree callee_t = gimple_call_fndecl (g);
    2397                 :        1957 :           if (callee_t
    2398                 :        1857 :               && recursive_call_p (current_function_decl, callee_t)
    2399                 :         553 :               && maybe_clean_eh_stmt (g)
    2400                 :        1960 :               && gimple_purge_dead_eh_edges (this_block))
    2401                 :             :             cfg_changed = true;
    2402                 :             :         }
    2403                 :             : 
    2404                 :      770672 :   if (dump_file)
    2405                 :          33 :     fprintf (dump_file, "Function found to be nothrow: %s\n",
    2406                 :             :              current_function_name ());
    2407                 :      770672 :   return cfg_changed ? TODO_cleanup_cfg : 0;
    2408                 :             : }
    2409                 :             : 
    2410                 :             : } // anon namespace
    2411                 :             : 
    2412                 :             : gimple_opt_pass *
    2413                 :      273196 : make_pass_nothrow (gcc::context *ctxt)
    2414                 :             : {
    2415                 :      273196 :   return new pass_nothrow (ctxt);
    2416                 :             : }
        

Generated by: LCOV version 2.1-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.