LCOV - code coverage report
Current view: top level - gcc - tree-nrv.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 110 116 94.8 %
Date: 2020-05-30 12:51:24 Functions: 7 7 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Language independent return value optimizations
       2                 :            :    Copyright (C) 2004-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify
       7                 :            : it under the terms of the GNU General Public License as published by
       8                 :            : the Free Software Foundation; either version 3, or (at your option)
       9                 :            : any later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful,
      12                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            : GNU General Public License for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "tree.h"
      25                 :            : #include "gimple.h"
      26                 :            : #include "tree-pass.h"
      27                 :            : #include "ssa.h"
      28                 :            : #include "tree-pretty-print.h"
      29                 :            : #include "gimple-iterator.h"
      30                 :            : #include "gimple-walk.h"
      31                 :            : #include "internal-fn.h"
      32                 :            : 
      33                 :            : /* This file implements return value optimizations for functions which
      34                 :            :    return aggregate types.
      35                 :            : 
      36                 :            :    Basically this pass searches the function for return statements which
      37                 :            :    return a local aggregate.  When converted to RTL such statements will
      38                 :            :    generate a copy from the local aggregate to final return value destination
      39                 :            :    mandated by the target's ABI.
      40                 :            : 
      41                 :            :    That copy can often be avoided by directly constructing the return value
      42                 :            :    into the final destination mandated by the target's ABI.
      43                 :            : 
      44                 :            :    This is basically a generic equivalent to the C++ front-end's
      45                 :            :    Named Return Value optimization.  */
      46                 :            : 
      47                 :            : struct nrv_data_t
      48                 :            : {
      49                 :            :   /* This is the temporary (a VAR_DECL) which appears in all of
      50                 :            :      this function's RETURN_EXPR statements.  */
      51                 :            :   tree var;
      52                 :            : 
      53                 :            :   /* This is the function's RESULT_DECL.  We will replace all occurrences
      54                 :            :      of VAR with RESULT_DECL when we apply this optimization.  */
      55                 :            :   tree result;
      56                 :            :   int modified;
      57                 :            : };
      58                 :            : 
      59                 :            : static tree finalize_nrv_r (tree *, int *, void *);
      60                 :            : 
      61                 :            : /* Callback for the tree walker.
      62                 :            : 
      63                 :            :    If TP refers to a RETURN_EXPR, then set the expression being returned
      64                 :            :    to nrv_data->result.
      65                 :            : 
      66                 :            :    If TP refers to nrv_data->var, then replace nrv_data->var with
      67                 :            :    nrv_data->result.
      68                 :            : 
      69                 :            :    If we reach a node where we know all the subtrees are uninteresting,
      70                 :            :    then set *WALK_SUBTREES to zero.  */
      71                 :            : 
      72                 :            : static tree
      73                 :     123100 : finalize_nrv_r (tree *tp, int *walk_subtrees, void *data)
      74                 :            : {
      75                 :     123100 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
      76                 :     123100 :   struct nrv_data_t *dp = (struct nrv_data_t *) wi->info;
      77                 :            : 
      78                 :            :   /* No need to walk into types.  */
      79                 :     123100 :   if (TYPE_P (*tp))
      80                 :          0 :     *walk_subtrees = 0;
      81                 :            : 
      82                 :            :   /* Otherwise replace all occurrences of VAR with RESULT.  */
      83                 :     123100 :   else if (*tp == dp->var)
      84                 :            :     {
      85                 :       1737 :       *tp = dp->result;
      86                 :       1737 :       dp->modified = 1;
      87                 :            :     }
      88                 :            : 
      89                 :            :   /* Keep iterating.  */
      90                 :     123100 :   return NULL_TREE;
      91                 :            : }
      92                 :            : 
      93                 :            : /* Main entry point for return value optimizations.
      94                 :            : 
      95                 :            :    If this function always returns the same local variable, and that
      96                 :            :    local variable is an aggregate type, then replace the variable with
      97                 :            :    the function's DECL_RESULT.
      98                 :            : 
      99                 :            :    This is the equivalent of the C++ named return value optimization
     100                 :            :    applied to optimized trees in a language independent form.  If we
     101                 :            :    ever encounter languages which prevent this kind of optimization,
     102                 :            :    then we could either have the languages register the optimization or
     103                 :            :    we could change the gating function to check the current language.  */
     104                 :            : 
     105                 :            : namespace {
     106                 :            : 
     107                 :            : const pass_data pass_data_nrv =
     108                 :            : {
     109                 :            :   GIMPLE_PASS, /* type */
     110                 :            :   "nrv", /* name */
     111                 :            :   OPTGROUP_NONE, /* optinfo_flags */
     112                 :            :   TV_TREE_NRV, /* tv_id */
     113                 :            :   ( PROP_ssa | PROP_cfg ), /* properties_required */
     114                 :            :   0, /* properties_provided */
     115                 :            :   0, /* properties_destroyed */
     116                 :            :   0, /* todo_flags_start */
     117                 :            :   0, /* todo_flags_finish */
     118                 :            : };
     119                 :            : 
     120                 :            : class pass_nrv : public gimple_opt_pass
     121                 :            : {
     122                 :            : public:
     123                 :     201440 :   pass_nrv (gcc::context *ctxt)
     124                 :     402880 :     : gimple_opt_pass (pass_data_nrv, ctxt)
     125                 :            :   {}
     126                 :            : 
     127                 :            :   /* opt_pass methods: */
     128                 :     960651 :   virtual bool gate (function *) { return optimize > 0; }
     129                 :            : 
     130                 :            :   virtual unsigned int execute (function *);
     131                 :            : 
     132                 :            : }; // class pass_nrv
     133                 :            : 
     134                 :            : unsigned int
     135                 :     688162 : pass_nrv::execute (function *fun)
     136                 :            : {
     137                 :     688162 :   tree result = DECL_RESULT (current_function_decl);
     138                 :     688162 :   tree result_type = TREE_TYPE (result);
     139                 :     688162 :   tree found = NULL;
     140                 :     688162 :   basic_block bb;
     141                 :     688162 :   gimple_stmt_iterator gsi;
     142                 :     688162 :   struct nrv_data_t data;
     143                 :            : 
     144                 :            :   /* If this function does not return an aggregate type in memory, then
     145                 :            :      there is nothing to do.  */
     146                 :     688162 :   if (!aggregate_value_p (result, current_function_decl))
     147                 :            :     return 0;
     148                 :            : 
     149                 :            :   /* If a GIMPLE type is returned in memory, finalize_nrv_r might create
     150                 :            :      non-GIMPLE.  */
     151                 :      41506 :   if (is_gimple_reg_type (result_type))
     152                 :            :     return 0;
     153                 :            : 
     154                 :            :   /* If the front end already did something like this, don't do it here.  */
     155                 :      35707 :   if (DECL_NAME (result))
     156                 :            :     return 0;
     157                 :            : 
     158                 :            :   /* If the result has its address taken then it might be modified
     159                 :            :      by means not detected in the following loop.  Bail out in this
     160                 :            :      case.  */
     161                 :      35317 :   if (TREE_ADDRESSABLE (result))
     162                 :            :     return 0;
     163                 :            : 
     164                 :            :   /* Look through each block for assignments to the RESULT_DECL.  */
     165                 :     529130 :   FOR_EACH_BB_FN (bb, fun)
     166                 :            :     {
     167                 :    3353670 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     168                 :            :         {
     169                 :    2330870 :           gimple *stmt = gsi_stmt (gsi);
     170                 :    2330870 :           tree ret_val;
     171                 :            : 
     172                 :    2330870 :           if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
     173                 :            :             {
     174                 :            :               /* In a function with an aggregate return value, the
     175                 :            :                  gimplifier has changed all non-empty RETURN_EXPRs to
     176                 :            :                  return the RESULT_DECL.  */
     177                 :        855 :               ret_val = gimple_return_retval (return_stmt);
     178                 :        855 :               if (ret_val)
     179                 :        855 :                 gcc_assert (ret_val == result);
     180                 :            :             }
     181                 :    2330010 :           else if (gimple_has_lhs (stmt)
     182                 :    1141580 :                    && gimple_get_lhs (stmt) == result)
     183                 :            :             {
     184                 :       1746 :               tree rhs;
     185                 :            : 
     186                 :       1746 :               if (!gimple_assign_copy_p (stmt))
     187                 :            :                 return 0;
     188                 :            : 
     189                 :       1543 :               rhs = gimple_assign_rhs1 (stmt);
     190                 :            : 
     191                 :            :               /* Now verify that this return statement uses the same value
     192                 :            :                  as any previously encountered return statement.  */
     193                 :       1543 :               if (found != NULL)
     194                 :            :                 {
     195                 :            :                   /* If we found a return statement using a different variable
     196                 :            :                      than previous return statements, then we cannot perform
     197                 :            :                      NRV optimizations.  */
     198                 :        107 :                   if (found != rhs)
     199                 :            :                     return 0;
     200                 :            :                 }
     201                 :            :               else
     202                 :            :                 found = rhs;
     203                 :            : 
     204                 :            :               /* The returned value must be a local automatic variable of the
     205                 :            :                  same type and alignment as the function's result.  */
     206                 :       1465 :               if (!VAR_P (found)
     207                 :       1465 :                   || TREE_THIS_VOLATILE (found)
     208                 :       1156 :                   || !auto_var_in_fn_p (found, current_function_decl)
     209                 :       1127 :                   || TREE_ADDRESSABLE (found)
     210                 :       2022 :                   || DECL_ALIGN (found) > DECL_ALIGN (result)
     211                 :       2237 :                   || !useless_type_conversion_p (result_type,
     212                 :        772 :                                                  TREE_TYPE (found)))
     213                 :        693 :                 return 0;
     214                 :            :             }
     215                 :    4744770 :           else if (gimple_has_lhs (stmt))
     216                 :            :             {
     217                 :    1054960 :               tree addr = get_base_address (gimple_get_lhs (stmt));
     218                 :            :                /* If there's any MODIFY of component of RESULT,
     219                 :            :                   then bail out.  */
     220                 :    1054960 :               if (addr && addr == result)
     221                 :            :                 return 0;
     222                 :            :             }
     223                 :            :         }
     224                 :            :     }
     225                 :            : 
     226                 :        773 :   if (!found)
     227                 :            :     return 0;
     228                 :            : 
     229                 :            :   /* If dumping details, then note once and only the NRV replacement.  */
     230                 :        665 :   if (dump_file && (dump_flags & TDF_DETAILS))
     231                 :            :     {
     232                 :          0 :       fprintf (dump_file, "NRV Replaced: ");
     233                 :          0 :       print_generic_expr (dump_file, found, dump_flags);
     234                 :          0 :       fprintf (dump_file, "  with: ");
     235                 :          0 :       print_generic_expr (dump_file, result, dump_flags);
     236                 :          0 :       fprintf (dump_file, "\n");
     237                 :            :     }
     238                 :            : 
     239                 :            :   /* At this point we know that all the return statements return the
     240                 :            :      same local which has suitable attributes for NRV.   Copy debugging
     241                 :            :      information from FOUND to RESULT if it will be useful.  But don't set
     242                 :            :      DECL_ABSTRACT_ORIGIN to point at another function.  */
     243                 :        665 :   if (!DECL_IGNORED_P (found)
     244                 :        665 :       && !(DECL_ABSTRACT_ORIGIN (found)
     245                 :         16 :            && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (found)) != current_function_decl))
     246                 :            :     {
     247                 :        630 :       DECL_NAME (result) = DECL_NAME (found);
     248                 :        630 :       DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (found);
     249                 :        630 :       DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (found);
     250                 :            :     }
     251                 :            : 
     252                 :        665 :   TREE_ADDRESSABLE (result) |= TREE_ADDRESSABLE (found);
     253                 :            : 
     254                 :            :   /* Now walk through the function changing all references to VAR to be
     255                 :            :      RESULT.  */
     256                 :        665 :   data.var = found;
     257                 :        665 :   data.result = result;
     258                 :       7974 :   FOR_EACH_BB_FN (bb, fun)
     259                 :            :     {
     260                 :      48850 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
     261                 :            :         {
     262                 :      34232 :           gimple *stmt = gsi_stmt (gsi);
     263                 :            :           /* If this is a copy from VAR to RESULT, remove it.  */
     264                 :      34232 :           if (gimple_assign_copy_p (stmt)
     265                 :       8816 :               && gimple_assign_lhs (stmt) == result
     266                 :      34926 :               && gimple_assign_rhs1 (stmt) == found)
     267                 :            :             {
     268                 :        694 :               unlink_stmt_vdef (stmt);
     269                 :        694 :               gsi_remove (&gsi, true);
     270                 :        694 :               release_defs (stmt);
     271                 :            :             }
     272                 :            :           else
     273                 :            :             {
     274                 :      33538 :               struct walk_stmt_info wi;
     275                 :      33538 :               memset (&wi, 0, sizeof (wi));
     276                 :      33538 :               wi.info = &data;
     277                 :      33538 :               data.modified = 0;
     278                 :      33538 :               walk_gimple_op (stmt, finalize_nrv_r, &wi);
     279                 :      33538 :               if (data.modified)
     280                 :       1737 :                 update_stmt (stmt);
     281                 :      33538 :               gsi_next (&gsi);
     282                 :            :             }
     283                 :            :         }
     284                 :            :     }
     285                 :            : 
     286                 :        665 :   SET_DECL_VALUE_EXPR (found, result);
     287                 :        665 :   DECL_HAS_VALUE_EXPR_P (found) = 1;
     288                 :            : 
     289                 :        665 :   return 0;
     290                 :            : }
     291                 :            : 
     292                 :            : } // anon namespace
     293                 :            : 
     294                 :            : gimple_opt_pass *
     295                 :     201440 : make_pass_nrv (gcc::context *ctxt)
     296                 :            : {
     297                 :     201440 :   return new pass_nrv (ctxt);
     298                 :            : }
     299                 :            : 
     300                 :            : /* Determine (pessimistically) whether DEST is available for NRV
     301                 :            :    optimization, where DEST is expected to be the LHS of a modify
     302                 :            :    expression where the RHS is a function returning an aggregate.
     303                 :            : 
     304                 :            :    DEST is available if it is not clobbered or used by the call.  */
     305                 :            : 
     306                 :            : static bool
     307                 :       3223 : dest_safe_for_nrv_p (gcall *call)
     308                 :            : {
     309                 :       3223 :   tree dest = gimple_call_lhs (call);
     310                 :            : 
     311                 :       3223 :   dest = get_base_address (dest);
     312                 :       3223 :   if (! dest)
     313                 :            :     return false;
     314                 :            : 
     315                 :       3223 :   if (TREE_CODE (dest) == SSA_NAME)
     316                 :            :     return true;
     317                 :            : 
     318                 :       1563 :   if (call_may_clobber_ref_p (call, dest)
     319                 :       1563 :       || ref_maybe_used_by_stmt_p (call, dest))
     320                 :        620 :     return false;
     321                 :            : 
     322                 :            :   return true;
     323                 :            : }
     324                 :            : 
     325                 :            : /* Walk through the function looking for GIMPLE_ASSIGNs with calls that
     326                 :            :    return in memory on the RHS.  For each of these, determine whether it is
     327                 :            :    safe to pass the address of the LHS as the return slot, and mark the
     328                 :            :    call appropriately if so.
     329                 :            : 
     330                 :            :    The NRV shares the return slot with a local variable in the callee; this
     331                 :            :    optimization shares the return slot with the target of the call within
     332                 :            :    the caller.  If the NRV is performed (which we can't know in general),
     333                 :            :    this optimization is safe if the address of the target has not
     334                 :            :    escaped prior to the call.  If it has, modifications to the local
     335                 :            :    variable will produce visible changes elsewhere, as in PR c++/19317.  */
     336                 :            : 
     337                 :            : namespace {
     338                 :            : 
     339                 :            : const pass_data pass_data_return_slot =
     340                 :            : {
     341                 :            :   GIMPLE_PASS, /* type */
     342                 :            :   "retslot", /* name */
     343                 :            :   OPTGROUP_NONE, /* optinfo_flags */
     344                 :            :   TV_NONE, /* tv_id */
     345                 :            :   PROP_ssa, /* properties_required */
     346                 :            :   0, /* properties_provided */
     347                 :            :   0, /* properties_destroyed */
     348                 :            :   0, /* todo_flags_start */
     349                 :            :   0, /* todo_flags_finish */
     350                 :            : };
     351                 :            : 
     352                 :            : class pass_return_slot : public gimple_opt_pass
     353                 :            : {
     354                 :            : public:
     355                 :     201440 :   pass_return_slot (gcc::context *ctxt)
     356                 :     402880 :     : gimple_opt_pass (pass_data_return_slot, ctxt)
     357                 :            :   {}
     358                 :            : 
     359                 :            :   /* opt_pass methods: */
     360                 :            :   virtual unsigned int execute (function *);
     361                 :            : 
     362                 :            : }; // class pass_return_slot
     363                 :            : 
     364                 :            : unsigned int
     365                 :     686162 : pass_return_slot::execute (function *fun)
     366                 :            : {
     367                 :     686162 :   basic_block bb;
     368                 :            : 
     369                 :    7582280 :   FOR_EACH_BB_FN (bb, fun)
     370                 :            :     {
     371                 :    6896110 :       gimple_stmt_iterator gsi;
     372                 :   65479200 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     373                 :            :         {
     374                 :   51687000 :           gcall *stmt;
     375                 :   51687000 :           bool slot_opt_p;
     376                 :            : 
     377                 :   51687000 :           stmt = dyn_cast <gcall *> (gsi_stmt (gsi));
     378                 :    3663290 :           if (stmt
     379                 :    3663290 :               && gimple_call_lhs (stmt)
     380                 :    1394380 :               && !gimple_call_return_slot_opt_p (stmt)
     381                 :            :               /* Ignore internal functions, those are expanded specially
     382                 :            :                  and aggregate_value_p on their result might result in
     383                 :            :                  undesirable warnings with some backends.  */
     384                 :    1233560 :               && !gimple_call_internal_p (stmt)
     385                 :    1173210 :               && aggregate_value_p (TREE_TYPE (gimple_call_lhs (stmt)),
     386                 :    1173210 :                                     gimple_call_fndecl (stmt)))
     387                 :            :             {
     388                 :            :               /* Check if the location being assigned to is
     389                 :            :                  clobbered by the call.  */
     390                 :       3223 :               slot_opt_p = dest_safe_for_nrv_p (stmt);
     391                 :   51690200 :               gimple_call_set_return_slot_opt (stmt, slot_opt_p);
     392                 :            :             }
     393                 :            :         }
     394                 :            :     }
     395                 :     686162 :   return 0;
     396                 :            : }
     397                 :            : 
     398                 :            : } // anon namespace
     399                 :            : 
     400                 :            : gimple_opt_pass *
     401                 :     201440 : make_pass_return_slot (gcc::context *ctxt)
     402                 :            : {
     403                 :     201440 :   return new pass_return_slot (ctxt);
     404                 :            : }

Generated by: LCOV version 1.0

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