LCOV - code coverage report
Current view: top level - gcc - tree-stdarg.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 478 548 87.2 %
Date: 2020-04-04 11:58:09 Functions: 18 18 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Pass computing data for optimizing stdarg functions.
       2                 :            :    Copyright (C) 2004-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Jakub Jelinek <jakub@redhat.com>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : any later version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful,
      13                 :            : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :            : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15                 :            : GNU General Public License 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                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "backend.h"
      25                 :            : #include "target.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "tree-pass.h"
      29                 :            : #include "ssa.h"
      30                 :            : #include "gimple-pretty-print.h"
      31                 :            : #include "fold-const.h"
      32                 :            : #include "langhooks.h"
      33                 :            : #include "gimple-iterator.h"
      34                 :            : #include "gimple-walk.h"
      35                 :            : #include "gimplify.h"
      36                 :            : #include "tree-into-ssa.h"
      37                 :            : #include "tree-cfg.h"
      38                 :            : #include "tree-stdarg.h"
      39                 :            : 
      40                 :            : /* A simple pass that attempts to optimize stdarg functions on architectures
      41                 :            :    that need to save register arguments to stack on entry to stdarg functions.
      42                 :            :    If the function doesn't use any va_start macros, no registers need to
      43                 :            :    be saved.  If va_start macros are used, the va_list variables don't escape
      44                 :            :    the function, it is only necessary to save registers that will be used
      45                 :            :    in va_arg macros.  E.g. if va_arg is only used with integral types
      46                 :            :    in the function, floating point registers don't need to be saved, etc.  */
      47                 :            : 
      48                 :            : 
      49                 :            : /* Return true if basic block VA_ARG_BB is dominated by VA_START_BB and
      50                 :            :    is executed at most as many times as VA_START_BB.  */
      51                 :            : 
      52                 :            : static bool
      53                 :       4575 : reachable_at_most_once (basic_block va_arg_bb, basic_block va_start_bb)
      54                 :            : {
      55                 :       4575 :   auto_vec<edge, 10> stack;
      56                 :       4575 :   edge e;
      57                 :       4575 :   edge_iterator ei;
      58                 :       4575 :   bool ret;
      59                 :            : 
      60                 :       4575 :   if (va_arg_bb == va_start_bb)
      61                 :            :     return true;
      62                 :            : 
      63                 :       4516 :   if (! dominated_by_p (CDI_DOMINATORS, va_arg_bb, va_start_bb))
      64                 :            :     return false;
      65                 :            : 
      66                 :       9091 :   auto_sbitmap visited (last_basic_block_for_fn (cfun));
      67                 :       4516 :   bitmap_clear (visited);
      68                 :       4516 :   ret = true;
      69                 :            : 
      70                 :       9070 :   FOR_EACH_EDGE (e, ei, va_arg_bb->preds)
      71                 :       4554 :     stack.safe_push (e);
      72                 :            : 
      73                 :      82768 :   while (! stack.is_empty ())
      74                 :            :     {
      75                 :      79262 :       basic_block src;
      76                 :            : 
      77                 :      79262 :       e = stack.pop ();
      78                 :      79262 :       src = e->src;
      79                 :            : 
      80                 :      79262 :       if (e->flags & EDGE_COMPLEX)
      81                 :            :         {
      82                 :            :           ret = false;
      83                 :            :           break;
      84                 :            :         }
      85                 :            : 
      86                 :      79262 :       if (src == va_start_bb)
      87                 :       3679 :         continue;
      88                 :            : 
      89                 :            :       /* va_arg_bb can be executed more times than va_start_bb.  */
      90                 :      75583 :       if (src == va_arg_bb)
      91                 :            :         {
      92                 :            :           ret = false;
      93                 :            :           break;
      94                 :            :         }
      95                 :            : 
      96                 :      74573 :       gcc_assert (src != ENTRY_BLOCK_PTR_FOR_FN (cfun));
      97                 :            : 
      98                 :      74573 :       if (! bitmap_bit_p (visited, src->index))
      99                 :            :         {
     100                 :      62863 :           bitmap_set_bit (visited, src->index);
     101                 :     139263 :           FOR_EACH_EDGE (e, ei, src->preds)
     102                 :      76400 :             stack.safe_push (e);
     103                 :            :         }
     104                 :            :     }
     105                 :            : 
     106                 :       4516 :   return ret;
     107                 :            : }
     108                 :            : 
     109                 :            : 
     110                 :            : /* For statement COUNTER = RHS, if RHS is COUNTER + constant,
     111                 :            :    return constant, otherwise return HOST_WIDE_INT_M1U.
     112                 :            :    GPR_P is true if this is GPR counter.  */
     113                 :            : 
     114                 :            : static unsigned HOST_WIDE_INT
     115                 :       1942 : va_list_counter_bump (struct stdarg_info *si, tree counter, tree rhs,
     116                 :            :                       bool gpr_p)
     117                 :            : {
     118                 :       1942 :   tree lhs, orig_lhs;
     119                 :       1942 :   gimple *stmt;
     120                 :       1942 :   unsigned HOST_WIDE_INT ret = 0, val, counter_val;
     121                 :       1942 :   unsigned int max_size;
     122                 :            : 
     123                 :       1942 :   if (si->offsets == NULL)
     124                 :            :     {
     125                 :        698 :       unsigned int i;
     126                 :            : 
     127                 :       1396 :       si->offsets = XNEWVEC (int, num_ssa_names);
     128                 :      90792 :       for (i = 0; i < num_ssa_names; ++i)
     129                 :      44698 :         si->offsets[i] = -1;
     130                 :            :     }
     131                 :            : 
     132                 :       1942 :   counter_val = gpr_p ? cfun->va_list_gpr_size : cfun->va_list_fpr_size;
     133                 :       1942 :   max_size = gpr_p ? VA_LIST_MAX_GPR_SIZE : VA_LIST_MAX_FPR_SIZE;
     134                 :       1942 :   orig_lhs = lhs = rhs;
     135                 :       3686 :   while (lhs)
     136                 :            :     {
     137                 :       3686 :       enum tree_code rhs_code;
     138                 :       3686 :       tree rhs1;
     139                 :            : 
     140                 :       3686 :       if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
     141                 :            :         {
     142                 :         56 :           if (counter_val >= max_size)
     143                 :            :             {
     144                 :            :               ret = max_size;
     145                 :            :               break;
     146                 :            :             }
     147                 :            : 
     148                 :         56 :           ret -= counter_val - si->offsets[SSA_NAME_VERSION (lhs)];
     149                 :         56 :           break;
     150                 :            :         }
     151                 :            : 
     152                 :       3630 :       stmt = SSA_NAME_DEF_STMT (lhs);
     153                 :            : 
     154                 :       3630 :       if (!is_gimple_assign (stmt) || gimple_assign_lhs (stmt) != lhs)
     155                 :            :         return HOST_WIDE_INT_M1U;
     156                 :            : 
     157                 :       3630 :       rhs_code = gimple_assign_rhs_code (stmt);
     158                 :       3630 :       rhs1 = gimple_assign_rhs1 (stmt);
     159                 :       3630 :       if ((get_gimple_rhs_class (rhs_code) == GIMPLE_SINGLE_RHS
     160                 :       1746 :            || gimple_assign_cast_p (stmt))
     161                 :       3630 :           && TREE_CODE (rhs1) == SSA_NAME)
     162                 :            :         {
     163                 :          0 :           lhs = rhs1;
     164                 :          0 :           continue;
     165                 :            :         }
     166                 :            : 
     167                 :       5374 :       if ((rhs_code == POINTER_PLUS_EXPR
     168                 :       3630 :            || rhs_code == PLUS_EXPR)
     169                 :       1744 :           && TREE_CODE (rhs1) == SSA_NAME
     170                 :       5374 :           && tree_fits_uhwi_p (gimple_assign_rhs2 (stmt)))
     171                 :            :         {
     172                 :       1744 :           ret += tree_to_uhwi (gimple_assign_rhs2 (stmt));
     173                 :       1744 :           lhs = rhs1;
     174                 :       1744 :           continue;
     175                 :            :         }
     176                 :            : 
     177                 :       1886 :       if (rhs_code == ADDR_EXPR 
     178                 :          0 :           && TREE_CODE (TREE_OPERAND (rhs1, 0)) == MEM_REF
     179                 :          0 :           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0)) == SSA_NAME
     180                 :       1886 :           && tree_fits_uhwi_p (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1)))
     181                 :            :         {
     182                 :          0 :           ret += tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1));
     183                 :          0 :           lhs = TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0);
     184                 :          0 :           continue;
     185                 :            :         }
     186                 :            : 
     187                 :       1886 :       if (get_gimple_rhs_class (rhs_code) != GIMPLE_SINGLE_RHS)
     188                 :            :         return HOST_WIDE_INT_M1U;
     189                 :            : 
     190                 :       1884 :       rhs = gimple_assign_rhs1 (stmt);
     191                 :       1884 :       if (TREE_CODE (counter) != TREE_CODE (rhs))
     192                 :            :         return HOST_WIDE_INT_M1U;
     193                 :            : 
     194                 :       1884 :       if (TREE_CODE (counter) == COMPONENT_REF)
     195                 :            :         {
     196                 :       1713 :           if (get_base_address (counter) != get_base_address (rhs)
     197                 :       1713 :               || TREE_CODE (TREE_OPERAND (rhs, 1)) != FIELD_DECL
     198                 :       3426 :               || TREE_OPERAND (counter, 1) != TREE_OPERAND (rhs, 1))
     199                 :            :             return HOST_WIDE_INT_M1U;
     200                 :            :         }
     201                 :        171 :       else if (counter != rhs)
     202                 :            :         return HOST_WIDE_INT_M1U;
     203                 :            : 
     204                 :            :       lhs = NULL;
     205                 :            :     }
     206                 :            : 
     207                 :       1940 :   lhs = orig_lhs;
     208                 :       1940 :   val = ret + counter_val;
     209                 :       5566 :   while (lhs)
     210                 :            :     {
     211                 :       3682 :       enum tree_code rhs_code;
     212                 :       3682 :       tree rhs1;
     213                 :            : 
     214                 :       3682 :       if (si->offsets[SSA_NAME_VERSION (lhs)] != -1)
     215                 :            :         break;
     216                 :            : 
     217                 :       3626 :       if (val >= max_size)
     218                 :        302 :         si->offsets[SSA_NAME_VERSION (lhs)] = max_size;
     219                 :            :       else
     220                 :       3324 :         si->offsets[SSA_NAME_VERSION (lhs)] = val;
     221                 :            : 
     222                 :       3626 :       stmt = SSA_NAME_DEF_STMT (lhs);
     223                 :            : 
     224                 :       3626 :       rhs_code = gimple_assign_rhs_code (stmt);
     225                 :       3626 :       rhs1 = gimple_assign_rhs1 (stmt);
     226                 :       3626 :       if ((get_gimple_rhs_class (rhs_code) == GIMPLE_SINGLE_RHS
     227                 :       1742 :            || gimple_assign_cast_p (stmt))
     228                 :       3626 :           && TREE_CODE (rhs1) == SSA_NAME)
     229                 :            :         {
     230                 :          0 :           lhs = rhs1;
     231                 :          0 :           continue;
     232                 :            :         }
     233                 :            : 
     234                 :       5368 :       if ((rhs_code == POINTER_PLUS_EXPR
     235                 :       3626 :            || rhs_code == PLUS_EXPR)
     236                 :       1742 :           && TREE_CODE (rhs1) == SSA_NAME
     237                 :       5368 :           && tree_fits_uhwi_p (gimple_assign_rhs2 (stmt)))
     238                 :            :         {
     239                 :       1742 :           val -= tree_to_uhwi (gimple_assign_rhs2 (stmt));
     240                 :       1742 :           lhs = rhs1;
     241                 :       1742 :           continue;
     242                 :            :         }
     243                 :            : 
     244                 :       1884 :       if (rhs_code == ADDR_EXPR 
     245                 :          0 :           && TREE_CODE (TREE_OPERAND (rhs1, 0)) == MEM_REF
     246                 :          0 :           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0)) == SSA_NAME
     247                 :       1884 :           && tree_fits_uhwi_p (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1)))
     248                 :            :         {
     249                 :          0 :           val -= tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (rhs1, 0), 1));
     250                 :          0 :           lhs = TREE_OPERAND (TREE_OPERAND (rhs1, 0), 0);
     251                 :          0 :           continue;
     252                 :            :         }
     253                 :            : 
     254                 :            :       lhs = NULL;
     255                 :            :     }
     256                 :            : 
     257                 :            :   return ret;
     258                 :            : }
     259                 :            : 
     260                 :            : 
     261                 :            : /* Called by walk_tree to look for references to va_list variables.  */
     262                 :            : 
     263                 :            : static tree
     264                 :     121708 : find_va_list_reference (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
     265                 :            :                         void *data)
     266                 :            : {
     267                 :     121708 :   bitmap va_list_vars = (bitmap) ((struct walk_stmt_info *) data)->info;
     268                 :     121708 :   tree var = *tp;
     269                 :            : 
     270                 :     121708 :   if (TREE_CODE (var) == SSA_NAME)
     271                 :            :     {
     272                 :      63325 :       if (bitmap_bit_p (va_list_vars, SSA_NAME_VERSION (var)))
     273                 :          0 :         return var;
     274                 :            :     }
     275                 :      58383 :   else if (VAR_P (var))
     276                 :            :     {
     277                 :      13704 :       if (bitmap_bit_p (va_list_vars, DECL_UID (var) + num_ssa_names))
     278                 :        806 :         return var;
     279                 :            :     }
     280                 :            : 
     281                 :            :   return NULL_TREE;
     282                 :            : }
     283                 :            : 
     284                 :            : 
     285                 :            : /* Helper function of va_list_counter_struct_op.  Compute
     286                 :            :    cfun->va_list_{g,f}pr_size.  AP is a va_list GPR/FPR counter,
     287                 :            :    if WRITE_P is true, seen in AP = VAR, otherwise seen in VAR = AP
     288                 :            :    statement.  GPR_P is true if AP is a GPR counter, false if it is
     289                 :            :    a FPR counter.  */
     290                 :            : 
     291                 :            : static void
     292                 :       8940 : va_list_counter_op (struct stdarg_info *si, tree ap, tree var, bool gpr_p,
     293                 :            :                     bool write_p)
     294                 :            : {
     295                 :       8940 :   unsigned HOST_WIDE_INT increment;
     296                 :            : 
     297                 :       8940 :   if (si->compute_sizes < 0)
     298                 :            :     {
     299                 :       4430 :       si->compute_sizes = 0;
     300                 :       4430 :       if (si->va_start_count == 1
     301                 :       4430 :           && reachable_at_most_once (si->bb, si->va_start_bb))
     302                 :       3394 :         si->compute_sizes = 1;
     303                 :            : 
     304                 :       4430 :       if (dump_file && (dump_flags & TDF_DETAILS))
     305                 :          0 :         fprintf (dump_file,
     306                 :            :                  "bb%d will %sbe executed at most once for each va_start "
     307                 :          0 :                  "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
     308                 :          0 :                  si->va_start_bb->index);
     309                 :            :     }
     310                 :            : 
     311                 :       8940 :   if (write_p
     312                 :       2235 :       && si->compute_sizes
     313                 :      10653 :       && (increment = va_list_counter_bump (si, ap, var, gpr_p)) + 1 > 1)
     314                 :            :     {
     315                 :       1713 :       if (gpr_p && cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
     316                 :            :         {
     317                 :       1197 :           cfun->va_list_gpr_size += increment;
     318                 :       1197 :           return;
     319                 :            :         }
     320                 :            : 
     321                 :        516 :       if (!gpr_p && cfun->va_list_fpr_size + increment < VA_LIST_MAX_FPR_SIZE)
     322                 :            :         {
     323                 :        365 :           cfun->va_list_fpr_size += increment;
     324                 :        365 :           return;
     325                 :            :         }
     326                 :            :     }
     327                 :            : 
     328                 :       7378 :   if (write_p || !si->compute_sizes)
     329                 :            :     {
     330                 :       2239 :       if (gpr_p)
     331                 :       1827 :         cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
     332                 :            :       else
     333                 :        412 :         cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
     334                 :            :     }
     335                 :            : }
     336                 :            : 
     337                 :            : 
     338                 :            : /* If AP is a va_list GPR/FPR counter, compute cfun->va_list_{g,f}pr_size.
     339                 :            :    If WRITE_P is true, AP has been seen in AP = VAR assignment, if WRITE_P
     340                 :            :    is false, AP has been seen in VAR = AP assignment.
     341                 :            :    Return true if the AP = VAR (resp. VAR = AP) statement is a recognized
     342                 :            :    va_arg operation that doesn't cause the va_list variable to escape
     343                 :            :    current function.  */
     344                 :            : 
     345                 :            : static bool
     346                 :      47446 : va_list_counter_struct_op (struct stdarg_info *si, tree ap, tree var,
     347                 :            :                            bool write_p)
     348                 :            : {
     349                 :      47446 :   tree base;
     350                 :            : 
     351                 :      47446 :   if (TREE_CODE (ap) != COMPONENT_REF
     352                 :      47446 :       || TREE_CODE (TREE_OPERAND (ap, 1)) != FIELD_DECL)
     353                 :            :     return false;
     354                 :            : 
     355                 :      17250 :   if (TREE_CODE (var) != SSA_NAME
     356                 :      17250 :       || bitmap_bit_p (si->va_list_vars, SSA_NAME_VERSION (var)))
     357                 :        246 :     return false;
     358                 :            : 
     359                 :      17004 :   base = get_base_address (ap);
     360                 :      17004 :   if (!VAR_P (base)
     361                 :      50194 :       || !bitmap_bit_p (si->va_list_vars, DECL_UID (base) + num_ssa_names))
     362                 :       1147 :     return false;
     363                 :            : 
     364                 :      15857 :   if (TREE_OPERAND (ap, 1) == va_list_gpr_counter_field)
     365                 :       6996 :     va_list_counter_op (si, ap, var, true, write_p);
     366                 :       8861 :   else if (TREE_OPERAND (ap, 1) == va_list_fpr_counter_field)
     367                 :       1944 :     va_list_counter_op (si, ap, var, false, write_p);
     368                 :            : 
     369                 :            :   return true;
     370                 :            : }
     371                 :            : 
     372                 :            : 
     373                 :            : /* Check for TEM = AP.  Return true if found and the caller shouldn't
     374                 :            :    search for va_list references in the statement.  */
     375                 :            : 
     376                 :            : static bool
     377                 :        992 : va_list_ptr_read (struct stdarg_info *si, tree ap, tree tem)
     378                 :            : {
     379                 :        992 :   if (!VAR_P (ap)
     380                 :       1718 :       || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap) + num_ssa_names))
     381                 :        811 :     return false;
     382                 :            : 
     383                 :        181 :   if (TREE_CODE (tem) != SSA_NAME
     384                 :        181 :       || bitmap_bit_p (si->va_list_vars, SSA_NAME_VERSION (tem)))
     385                 :          0 :     return false;
     386                 :            : 
     387                 :        181 :   if (si->compute_sizes < 0)
     388                 :            :     {
     389                 :        181 :       si->compute_sizes = 0;
     390                 :        181 :       if (si->va_start_count == 1
     391                 :        181 :           && reachable_at_most_once (si->bb, si->va_start_bb))
     392                 :        171 :         si->compute_sizes = 1;
     393                 :            : 
     394                 :        181 :       if (dump_file && (dump_flags & TDF_DETAILS))
     395                 :          0 :         fprintf (dump_file,
     396                 :            :                  "bb%d will %sbe executed at most once for each va_start "
     397                 :          0 :                  "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
     398                 :          0 :                  si->va_start_bb->index);
     399                 :            :     }
     400                 :            : 
     401                 :            :   /* For void * or char * va_list types, there is just one counter.
     402                 :            :      If va_arg is used in a loop, we don't know how many registers need
     403                 :            :      saving.  */
     404                 :        181 :   if (! si->compute_sizes)
     405                 :            :     return false;
     406                 :            : 
     407                 :        171 :   if (va_list_counter_bump (si, ap, tem, true) == HOST_WIDE_INT_M1U)
     408                 :            :     return false;
     409                 :            : 
     410                 :            :   /* Note the temporary, as we need to track whether it doesn't escape
     411                 :            :      the current function.  */
     412                 :        171 :   bitmap_set_bit (si->va_list_escape_vars, SSA_NAME_VERSION (tem));
     413                 :            : 
     414                 :        171 :   return true;
     415                 :            : }
     416                 :            : 
     417                 :            : 
     418                 :            : /* Check for:
     419                 :            :      tem1 = AP;
     420                 :            :      TEM2 = tem1 + CST;
     421                 :            :      AP = TEM2;
     422                 :            :    sequence and update cfun->va_list_gpr_size.  Return true if found.  */
     423                 :            : 
     424                 :            : static bool
     425                 :        821 : va_list_ptr_write (struct stdarg_info *si, tree ap, tree tem2)
     426                 :            : {
     427                 :        821 :   unsigned HOST_WIDE_INT increment;
     428                 :            : 
     429                 :        821 :   if (!VAR_P (ap)
     430                 :        905 :       || !bitmap_bit_p (si->va_list_vars, DECL_UID (ap) + num_ssa_names))
     431                 :        792 :     return false;
     432                 :            : 
     433                 :         29 :   if (TREE_CODE (tem2) != SSA_NAME
     434                 :         29 :       || bitmap_bit_p (si->va_list_vars, SSA_NAME_VERSION (tem2)))
     435                 :          0 :     return false;
     436                 :            : 
     437                 :         29 :   if (si->compute_sizes <= 0)
     438                 :            :     return false;
     439                 :            : 
     440                 :         29 :   increment = va_list_counter_bump (si, ap, tem2, true);
     441                 :         29 :   if (increment + 1 <= 1)
     442                 :            :     return false;
     443                 :            : 
     444                 :         27 :   if (cfun->va_list_gpr_size + increment < VA_LIST_MAX_GPR_SIZE)
     445                 :         27 :     cfun->va_list_gpr_size += increment;
     446                 :            :   else
     447                 :          0 :     cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
     448                 :            : 
     449                 :            :   return true;
     450                 :            : }
     451                 :            : 
     452                 :            : 
     453                 :            : /* If RHS is X, (some type *) X or X + CST for X a temporary variable
     454                 :            :    containing value of some va_list variable plus optionally some constant,
     455                 :            :    either set si->va_list_escapes or add LHS to si->va_list_escape_vars,
     456                 :            :    depending whether LHS is a function local temporary.  */
     457                 :            : 
     458                 :            : static void
     459                 :        910 : check_va_list_escapes (struct stdarg_info *si, tree lhs, tree rhs)
     460                 :            : {
     461                 :        910 :   if (! POINTER_TYPE_P (TREE_TYPE (rhs)))
     462                 :            :     return;
     463                 :            : 
     464                 :        303 :   if (TREE_CODE (rhs) == SSA_NAME)
     465                 :            :     {
     466                 :         81 :       if (! bitmap_bit_p (si->va_list_escape_vars, SSA_NAME_VERSION (rhs)))
     467                 :            :         return;
     468                 :            :     }
     469                 :        222 :   else if (TREE_CODE (rhs) == ADDR_EXPR
     470                 :         50 :            && TREE_CODE (TREE_OPERAND (rhs, 0)) == MEM_REF
     471                 :        226 :            && TREE_CODE (TREE_OPERAND (TREE_OPERAND (rhs, 0), 0)) == SSA_NAME)
     472                 :            :     {
     473                 :          4 :       tree ptr = TREE_OPERAND (TREE_OPERAND (rhs, 0), 0);
     474                 :          4 :       if (! bitmap_bit_p (si->va_list_escape_vars, SSA_NAME_VERSION (ptr)))
     475                 :            :         return;
     476                 :            :     }
     477                 :            :   else
     478                 :            :     return;
     479                 :            : 
     480                 :         31 :   if (TREE_CODE (lhs) != SSA_NAME)
     481                 :            :     {
     482                 :          2 :       si->va_list_escapes = true;
     483                 :          2 :       return;
     484                 :            :     }
     485                 :            : 
     486                 :         29 :   if (si->compute_sizes < 0)
     487                 :            :     {
     488                 :          0 :       si->compute_sizes = 0;
     489                 :          0 :       if (si->va_start_count == 1
     490                 :          0 :           && reachable_at_most_once (si->bb, si->va_start_bb))
     491                 :          0 :         si->compute_sizes = 1;
     492                 :            : 
     493                 :          0 :       if (dump_file && (dump_flags & TDF_DETAILS))
     494                 :          0 :         fprintf (dump_file,
     495                 :            :                  "bb%d will %sbe executed at most once for each va_start "
     496                 :          0 :                  "in bb%d\n", si->bb->index, si->compute_sizes ? "" : "not ",
     497                 :          0 :                  si->va_start_bb->index);
     498                 :            :     }
     499                 :            : 
     500                 :            :   /* For void * or char * va_list types, there is just one counter.
     501                 :            :      If va_arg is used in a loop, we don't know how many registers need
     502                 :            :      saving.  */
     503                 :         29 :   if (! si->compute_sizes)
     504                 :            :     {
     505                 :          0 :       si->va_list_escapes = true;
     506                 :          0 :       return;
     507                 :            :     }
     508                 :            : 
     509                 :         29 :   if (va_list_counter_bump (si, si->va_start_ap, lhs, true)
     510                 :            :       == HOST_WIDE_INT_M1U)
     511                 :            :     {
     512                 :          0 :       si->va_list_escapes = true;
     513                 :          0 :       return;
     514                 :            :     }
     515                 :            : 
     516                 :         29 :   bitmap_set_bit (si->va_list_escape_vars, SSA_NAME_VERSION (lhs));
     517                 :            : }
     518                 :            : 
     519                 :            : 
     520                 :            : /* Check all uses of temporaries from si->va_list_escape_vars bitmap.
     521                 :            :    Return true if va_list might be escaping.  */
     522                 :            : 
     523                 :            : static bool
     524                 :        112 : check_all_va_list_escapes (struct stdarg_info *si)
     525                 :            : {
     526                 :        112 :   basic_block bb;
     527                 :            : 
     528                 :        276 :   FOR_EACH_BB_FN (bb, cfun)
     529                 :            :     {
     530                 :        281 :       for (gphi_iterator i = gsi_start_phis (bb); !gsi_end_p (i);
     531                 :         20 :            gsi_next (&i))
     532                 :            :         {
     533                 :         20 :           tree lhs;
     534                 :         20 :           use_operand_p uop;
     535                 :         20 :           ssa_op_iter soi;
     536                 :         20 :           gphi *phi = i.phi ();
     537                 :            : 
     538                 :         20 :           lhs = PHI_RESULT (phi);
     539                 :         28 :           if (virtual_operand_p (lhs)
     540                 :         28 :               || bitmap_bit_p (si->va_list_escape_vars,
     541                 :          8 :                                SSA_NAME_VERSION (lhs)))
     542                 :         12 :             continue;
     543                 :            : 
     544                 :         36 :           FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE)
     545                 :            :             {
     546                 :         28 :               tree rhs = USE_FROM_PTR (uop);
     547                 :         28 :               if (TREE_CODE (rhs) == SSA_NAME
     548                 :         54 :                   && bitmap_bit_p (si->va_list_escape_vars,
     549                 :         26 :                                 SSA_NAME_VERSION (rhs)))
     550                 :            :                 {
     551                 :          0 :                   if (dump_file && (dump_flags & TDF_DETAILS))
     552                 :            :                     {
     553                 :          0 :                       fputs ("va_list escapes in ", dump_file);
     554                 :          0 :                       print_gimple_stmt (dump_file, phi, 0, dump_flags);
     555                 :          0 :                       fputc ('\n', dump_file);
     556                 :            :                     }
     557                 :          0 :                   return true;
     558                 :            :                 }
     559                 :            :             }
     560                 :            :         }
     561                 :            : 
     562                 :       2598 :       for (gimple_stmt_iterator i = gsi_start_bb (bb); !gsi_end_p (i);
     563                 :       2076 :            gsi_next (&i))
     564                 :            :         {
     565                 :       2173 :           gimple *stmt = gsi_stmt (i);
     566                 :       2173 :           tree use;
     567                 :       2173 :           ssa_op_iter iter;
     568                 :            : 
     569                 :       2173 :           if (is_gimple_debug (stmt))
     570                 :       1279 :             continue;
     571                 :            : 
     572                 :       2214 :           FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_ALL_USES)
     573                 :            :             {
     574                 :       2834 :               if (! bitmap_bit_p (si->va_list_escape_vars,
     575                 :       1417 :                                   SSA_NAME_VERSION (use)))
     576                 :       1275 :                 continue;
     577                 :            : 
     578                 :        142 :               if (is_gimple_assign (stmt))
     579                 :            :                 {
     580                 :         45 :                   tree rhs = gimple_assign_rhs1 (stmt);
     581                 :         45 :                   enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
     582                 :            : 
     583                 :            :                   /* x = *ap_temp;  */
     584                 :         45 :                   if (rhs_code == MEM_REF
     585                 :         15 :                       && TREE_OPERAND (rhs, 0) == use
     586                 :         15 :                       && TYPE_SIZE_UNIT (TREE_TYPE (rhs))
     587                 :         15 :                       && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (rhs)))
     588                 :         60 :                       && si->offsets[SSA_NAME_VERSION (use)] != -1)
     589                 :            :                     {
     590                 :         15 :                       unsigned HOST_WIDE_INT gpr_size;
     591                 :         15 :                       tree access_size = TYPE_SIZE_UNIT (TREE_TYPE (rhs));
     592                 :            : 
     593                 :         15 :                       gpr_size = si->offsets[SSA_NAME_VERSION (use)]
     594                 :         15 :                                  + tree_to_shwi (TREE_OPERAND (rhs, 1))
     595                 :         15 :                                  + tree_to_uhwi (access_size);
     596                 :         15 :                       if (gpr_size >= VA_LIST_MAX_GPR_SIZE)
     597                 :          0 :                         cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
     598                 :         15 :                       else if (gpr_size > cfun->va_list_gpr_size)
     599                 :          0 :                         cfun->va_list_gpr_size = gpr_size;
     600                 :         15 :                       continue;
     601                 :            :                     }
     602                 :            : 
     603                 :            :                   /* va_arg sequences may contain
     604                 :            :                      other_ap_temp = ap_temp;
     605                 :            :                      other_ap_temp = ap_temp + constant;
     606                 :            :                      other_ap_temp = (some_type *) ap_temp;
     607                 :            :                      ap = ap_temp;
     608                 :            :                      statements.  */
     609                 :         30 :                   if (rhs == use
     610                 :         30 :                       && ((rhs_code == POINTER_PLUS_EXPR
     611                 :         15 :                            && (TREE_CODE (gimple_assign_rhs2 (stmt))
     612                 :            :                                == INTEGER_CST))
     613                 :         15 :                           || gimple_assign_cast_p (stmt)
     614                 :         15 :                           || (get_gimple_rhs_class (rhs_code)
     615                 :            :                               == GIMPLE_SINGLE_RHS)))
     616                 :            :                     {
     617                 :         30 :                       tree lhs = gimple_assign_lhs (stmt);
     618                 :            : 
     619                 :         45 :                       if (TREE_CODE (lhs) == SSA_NAME
     620                 :         45 :                           && bitmap_bit_p (si->va_list_escape_vars,
     621                 :         15 :                                            SSA_NAME_VERSION (lhs)))
     622                 :         15 :                         continue;
     623                 :            : 
     624                 :         30 :                       if (VAR_P (lhs)
     625                 :         30 :                           && bitmap_bit_p (si->va_list_vars,
     626                 :         30 :                                            DECL_UID (lhs) + num_ssa_names))
     627                 :         15 :                         continue;
     628                 :            :                     }
     629                 :          0 :                   else if (rhs_code == ADDR_EXPR
     630                 :          0 :                            && TREE_CODE (TREE_OPERAND (rhs, 0)) == MEM_REF
     631                 :          0 :                            && TREE_OPERAND (TREE_OPERAND (rhs, 0), 0) == use)
     632                 :            :                     {
     633                 :          0 :                       tree lhs = gimple_assign_lhs (stmt);
     634                 :            : 
     635                 :          0 :                       if (bitmap_bit_p (si->va_list_escape_vars,
     636                 :          0 :                                         SSA_NAME_VERSION (lhs)))
     637                 :          0 :                         continue;
     638                 :            :                     }
     639                 :            :                 }
     640                 :            : 
     641                 :         97 :               if (dump_file && (dump_flags & TDF_DETAILS))
     642                 :            :                 {
     643                 :          0 :                   fputs ("va_list escapes in ", dump_file);
     644                 :          0 :                   print_gimple_stmt (dump_file, stmt, 0, dump_flags);
     645                 :          0 :                   fputc ('\n', dump_file);
     646                 :            :                 }
     647                 :         97 :               return true;
     648                 :            :             }
     649                 :            :         }
     650                 :            :     }
     651                 :            : 
     652                 :            :   return false;
     653                 :            : }
     654                 :            : 
     655                 :            : /* Optimize FUN->va_list_gpr_size and FUN->va_list_fpr_size.  */
     656                 :            : 
     657                 :            : static void
     658                 :       6215 : optimize_va_list_gpr_fpr_size (function *fun)
     659                 :            : {
     660                 :       6215 :   basic_block bb;
     661                 :       6215 :   bool va_list_escapes = false;
     662                 :       6215 :   bool va_list_simple_ptr;
     663                 :       6215 :   struct stdarg_info si;
     664                 :       6215 :   struct walk_stmt_info wi;
     665                 :       6215 :   const char *funcname = NULL;
     666                 :       6215 :   tree cfun_va_list;
     667                 :            : 
     668                 :       6215 :   fun->va_list_gpr_size = 0;
     669                 :       6215 :   fun->va_list_fpr_size = 0;
     670                 :       6215 :   memset (&si, 0, sizeof (si));
     671                 :       6215 :   si.va_list_vars = BITMAP_ALLOC (NULL);
     672                 :       6215 :   si.va_list_escape_vars = BITMAP_ALLOC (NULL);
     673                 :            : 
     674                 :       6215 :   if (dump_file)
     675                 :         40 :     funcname = lang_hooks.decl_printable_name (current_function_decl, 2);
     676                 :            : 
     677                 :       6215 :   cfun_va_list = targetm.fn_abi_va_list (fun->decl);
     678                 :      12430 :   va_list_simple_ptr = POINTER_TYPE_P (cfun_va_list)
     679                 :       9940 :                        && (TREE_TYPE (cfun_va_list) == void_type_node
     680                 :       3725 :                            || TREE_TYPE (cfun_va_list) == char_type_node);
     681                 :       6215 :   gcc_assert (is_gimple_reg_type (cfun_va_list) == va_list_simple_ptr);
     682                 :            : 
     683                 :      36791 :   FOR_EACH_BB_FN (bb, fun)
     684                 :            :     {
     685                 :      34765 :       gimple_stmt_iterator i;
     686                 :            : 
     687                 :     186705 :       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
     688                 :            :         {
     689                 :     121363 :           gimple *stmt = gsi_stmt (i);
     690                 :     121363 :           tree callee, ap;
     691                 :            : 
     692                 :     121363 :           if (!is_gimple_call (stmt))
     693                 :     103752 :             continue;
     694                 :            : 
     695                 :      17611 :           callee = gimple_call_fndecl (stmt);
     696                 :      19561 :           if (!callee
     697                 :      17611 :               || !fndecl_built_in_p (callee, BUILT_IN_NORMAL))
     698                 :       1950 :             continue;
     699                 :            : 
     700                 :      15661 :           switch (DECL_FUNCTION_CODE (callee))
     701                 :            :             {
     702                 :       6090 :             case BUILT_IN_VA_START:
     703                 :       6090 :               break;
     704                 :            :               /* If old style builtins are used, don't optimize anything.  */
     705                 :          1 :             case BUILT_IN_SAVEREGS:
     706                 :          1 :             case BUILT_IN_NEXT_ARG:
     707                 :          1 :               va_list_escapes = true;
     708                 :          1 :               continue;
     709                 :       9570 :             default:
     710                 :       9570 :               continue;
     711                 :            :             }
     712                 :            : 
     713                 :       6090 :           si.va_start_count++;
     714                 :       6090 :           ap = gimple_call_arg (stmt, 0);
     715                 :            : 
     716                 :       6090 :           if (TREE_CODE (ap) != ADDR_EXPR)
     717                 :            :             {
     718                 :            :               va_list_escapes = true;
     719                 :            :               break;
     720                 :            :             }
     721                 :       6072 :           ap = TREE_OPERAND (ap, 0);
     722                 :       6072 :           if (TREE_CODE (ap) == ARRAY_REF)
     723                 :            :             {
     724                 :         48 :               if (! integer_zerop (TREE_OPERAND (ap, 1)))
     725                 :            :                 {
     726                 :            :                   va_list_escapes = true;
     727                 :            :                   break;
     728                 :            :                 }
     729                 :          0 :               ap = TREE_OPERAND (ap, 0);
     730                 :            :             }
     731                 :       6024 :           if (TYPE_MAIN_VARIANT (TREE_TYPE (ap))
     732                 :       6024 :               != TYPE_MAIN_VARIANT (targetm.fn_abi_va_list (fun->decl))
     733                 :       6024 :               || !VAR_P (ap))
     734                 :            :             {
     735                 :            :               va_list_escapes = true;
     736                 :            :               break;
     737                 :            :             }
     738                 :            : 
     739                 :       1919 :           if (is_global_var (ap))
     740                 :            :             {
     741                 :            :               va_list_escapes = true;
     742                 :            :               break;
     743                 :            :             }
     744                 :            : 
     745                 :       3804 :           bitmap_set_bit (si.va_list_vars, DECL_UID (ap) + num_ssa_names);
     746                 :            : 
     747                 :            :           /* VA_START_BB and VA_START_AP will be only used if there is just
     748                 :            :              one va_start in the function.  */
     749                 :       1902 :           si.va_start_bb = bb;
     750                 :       1902 :           si.va_start_ap = ap;
     751                 :            :         }
     752                 :            : 
     753                 :      34765 :       if (va_list_escapes)
     754                 :            :         break;
     755                 :            :     }
     756                 :            : 
     757                 :            :   /* If there were no va_start uses in the function, there is no need to
     758                 :            :      save anything.  */
     759                 :       6215 :   if (si.va_start_count == 0)
     760                 :        166 :     goto finish;
     761                 :            : 
     762                 :            :   /* If some va_list arguments weren't local, we can't optimize.  */
     763                 :       6049 :   if (va_list_escapes)
     764                 :       4188 :     goto finish;
     765                 :            : 
     766                 :            :   /* For void * or char * va_list, something useful can be done only
     767                 :            :      if there is just one va_start.  */
     768                 :       1861 :   if (va_list_simple_ptr && si.va_start_count > 1)
     769                 :            :     {
     770                 :          4 :       va_list_escapes = true;
     771                 :          4 :       goto finish;
     772                 :            :     }
     773                 :            : 
     774                 :            :   /* For struct * va_list, if the backend didn't tell us what the counter fields
     775                 :            :      are, there is nothing more we can do.  */
     776                 :       1857 :   if (!va_list_simple_ptr
     777                 :       1725 :       && va_list_gpr_counter_field == NULL_TREE
     778                 :          0 :       && va_list_fpr_counter_field == NULL_TREE)
     779                 :            :     {
     780                 :          0 :       va_list_escapes = true;
     781                 :          0 :       goto finish;
     782                 :            :     }
     783                 :            : 
     784                 :            :   /* For void * or char * va_list there is just one counter
     785                 :            :      (va_list itself).  Use VA_LIST_GPR_SIZE for it.  */
     786                 :       1857 :   if (va_list_simple_ptr)
     787                 :        132 :     fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
     788                 :            : 
     789                 :       1857 :   calculate_dominance_info (CDI_DOMINATORS);
     790                 :       1857 :   memset (&wi, 0, sizeof (wi));
     791                 :       1857 :   wi.info = si.va_list_vars;
     792                 :            : 
     793                 :      23407 :   FOR_EACH_BB_FN (bb, fun)
     794                 :            :     {
     795                 :      22358 :       si.compute_sizes = -1;
     796                 :      22358 :       si.bb = bb;
     797                 :            : 
     798                 :            :       /* For va_list_simple_ptr, we have to check PHI nodes too.  We treat
     799                 :            :          them as assignments for the purpose of escape analysis.  This is
     800                 :            :          not needed for non-simple va_list because virtual phis don't perform
     801                 :            :          any real data movement.  Also, check PHI nodes for taking address of
     802                 :            :          the va_list vars.  */
     803                 :      22358 :       tree lhs, rhs;
     804                 :      22358 :       use_operand_p uop;
     805                 :      22358 :       ssa_op_iter soi;
     806                 :            : 
     807                 :      28963 :       for (gphi_iterator i = gsi_start_phis (bb); !gsi_end_p (i);
     808                 :       6605 :            gsi_next (&i))
     809                 :            :         {
     810                 :       6605 :           gphi *phi = i.phi ();
     811                 :       6605 :           lhs = PHI_RESULT (phi);
     812                 :            : 
     813                 :      13210 :           if (virtual_operand_p (lhs))
     814                 :       3489 :             continue;
     815                 :            : 
     816                 :       3116 :           if (va_list_simple_ptr)
     817                 :            :             {
     818                 :        270 :               FOR_EACH_PHI_ARG (uop, phi, soi, SSA_OP_USE)
     819                 :            :                 {
     820                 :        188 :                   rhs = USE_FROM_PTR (uop);
     821                 :        188 :                   if (va_list_ptr_read (&si, rhs, lhs))
     822                 :          0 :                     continue;
     823                 :        188 :                   else if (va_list_ptr_write (&si, lhs, rhs))
     824                 :          0 :                     continue;
     825                 :            :                   else
     826                 :        188 :                     check_va_list_escapes (&si, lhs, rhs);
     827                 :            : 
     828                 :        188 :                   if (si.va_list_escapes)
     829                 :            :                     {
     830                 :          0 :                       if (dump_file && (dump_flags & TDF_DETAILS))
     831                 :            :                         {
     832                 :          0 :                           fputs ("va_list escapes in ", dump_file);
     833                 :          0 :                           print_gimple_stmt (dump_file, phi, 0, dump_flags);
     834                 :          0 :                           fputc ('\n', dump_file);
     835                 :            :                         }
     836                 :            :                       va_list_escapes = true;
     837                 :            :                     }
     838                 :            :                 }
     839                 :            :             }
     840                 :            : 
     841                 :       6302 :           for (unsigned j = 0; !va_list_escapes
     842                 :      18829 :                                && j < gimple_phi_num_args (phi); ++j)
     843                 :       6302 :             if ((!va_list_simple_ptr
     844                 :        188 :                  || TREE_CODE (gimple_phi_arg_def (phi, j)) != SSA_NAME)
     845                 :       6346 :                 && walk_tree (gimple_phi_arg_def_ptr (phi, j),
     846                 :            :                               find_va_list_reference, &wi, NULL))
     847                 :            :               {
     848                 :          7 :                 if (dump_file && (dump_flags & TDF_DETAILS))
     849                 :            :                   {
     850                 :          0 :                     fputs ("va_list escapes in ", dump_file);
     851                 :          0 :                     print_gimple_stmt (dump_file, phi, 0, dump_flags);
     852                 :          0 :                     fputc ('\n', dump_file);
     853                 :            :                   }
     854                 :            :                 va_list_escapes = true;
     855                 :            :               }
     856                 :            :         }
     857                 :            : 
     858                 :      22358 :       for (gimple_stmt_iterator i = gsi_start_bb (bb);
     859                 :      98780 :            !gsi_end_p (i) && !va_list_escapes;
     860                 :      76422 :            gsi_next (&i))
     861                 :            :         {
     862                 :      76422 :           gimple *stmt = gsi_stmt (i);
     863                 :            : 
     864                 :            :           /* Don't look at __builtin_va_{start,end}, they are ok.  */
     865                 :      76422 :           if (is_gimple_call (stmt))
     866                 :            :             {
     867                 :       7667 :               tree callee = gimple_call_fndecl (stmt);
     868                 :            : 
     869                 :      10595 :               if (callee
     870                 :       7667 :                   && (fndecl_built_in_p (callee, BUILT_IN_VA_START)
     871                 :       5623 :                       || fndecl_built_in_p (callee, BUILT_IN_VA_END)))
     872                 :       2928 :                 continue;
     873                 :            :             }
     874                 :            : 
     875                 :      73494 :           if (is_gimple_assign (stmt))
     876                 :            :             {
     877                 :      42015 :               lhs = gimple_assign_lhs (stmt);
     878                 :      42015 :               rhs = gimple_assign_rhs1 (stmt);
     879                 :            : 
     880                 :      42015 :               if (va_list_simple_ptr)
     881                 :            :                 {
     882                 :       1261 :                   if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
     883                 :            :                       == GIMPLE_SINGLE_RHS)
     884                 :            :                     {
     885                 :            :                       /* Check for ap ={v} {}.  */
     886                 :        911 :                       if (TREE_CLOBBER_P (rhs))
     887                 :        107 :                         continue;
     888                 :            : 
     889                 :            :                       /* Check for tem = ap.  */
     890                 :        804 :                       else if (va_list_ptr_read (&si, rhs, lhs))
     891                 :        171 :                         continue;
     892                 :            : 
     893                 :            :                       /* Check for the last insn in:
     894                 :            :                          tem1 = ap;
     895                 :            :                          tem2 = tem1 + CST;
     896                 :            :                          ap = tem2;
     897                 :            :                          sequence.  */
     898                 :        633 :                       else if (va_list_ptr_write (&si, lhs, rhs))
     899                 :         27 :                         continue;
     900                 :            :                     }
     901                 :            : 
     902                 :        956 :                   if ((gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
     903                 :         86 :                        && TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST)
     904                 :        915 :                       || CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))
     905                 :       1796 :                       || (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
     906                 :            :                           == GIMPLE_SINGLE_RHS))
     907                 :        722 :                     check_va_list_escapes (&si, lhs, rhs);
     908                 :            :                 }
     909                 :            :               else
     910                 :            :                 {
     911                 :      40754 :                   if (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
     912                 :            :                       == GIMPLE_SINGLE_RHS)
     913                 :            :                     {
     914                 :            :                       /* Check for ap ={v} {}.  */
     915                 :      27406 :                       if (TREE_CLOBBER_P (rhs))
     916                 :       1395 :                         continue;
     917                 :            : 
     918                 :            :                       /* Check for ap[0].field = temp.  */
     919                 :      26011 :                       else if (va_list_counter_struct_op (&si, lhs, rhs, true))
     920                 :       4576 :                         continue;
     921                 :            : 
     922                 :            :                       /* Check for temp = ap[0].field.  */
     923                 :      21435 :                       else if (va_list_counter_struct_op (&si, rhs, lhs,
     924                 :            :                                                           false))
     925                 :      11281 :                         continue;
     926                 :            :                     }
     927                 :            : 
     928                 :            :                   /* Do any architecture specific checking.  */
     929                 :      23502 :                   if (targetm.stdarg_optimize_hook
     930                 :      23502 :                       && targetm.stdarg_optimize_hook (&si, stmt))
     931                 :          0 :                     continue;
     932                 :            :                 }
     933                 :            :             }
     934                 :      31479 :           else if (is_gimple_debug (stmt))
     935                 :      11562 :             continue;
     936                 :            : 
     937                 :            :           /* All other uses of va_list are either va_copy (that is not handled
     938                 :            :              in this optimization), taking address of va_list variable or
     939                 :            :              passing va_list to other functions (in that case va_list might
     940                 :            :              escape the function and therefore va_start needs to set it up
     941                 :            :              fully), or some unexpected use of va_list.  None of these should
     942                 :            :              happen in a gimplified VA_ARG_EXPR.  */
     943                 :      44375 :           if (si.va_list_escapes
     944                 :      44375 :               || walk_gimple_op (stmt, find_va_list_reference, &wi))
     945                 :            :             {
     946                 :        801 :               if (dump_file && (dump_flags & TDF_DETAILS))
     947                 :            :                 {
     948                 :          0 :                   fputs ("va_list escapes in ", dump_file);
     949                 :          0 :                   print_gimple_stmt (dump_file, stmt, 0, dump_flags);
     950                 :          0 :                   fputc ('\n', dump_file);
     951                 :            :                 }
     952                 :            :               va_list_escapes = true;
     953                 :            :             }
     954                 :            :         }
     955                 :            : 
     956                 :      22358 :       if (va_list_escapes)
     957                 :            :         break;
     958                 :            :     }
     959                 :            : 
     960                 :       1857 :   if (! va_list_escapes
     961                 :       1857 :       && va_list_simple_ptr
     962                 :        112 :       && ! bitmap_empty_p (si.va_list_escape_vars)
     963                 :       1969 :       && check_all_va_list_escapes (&si))
     964                 :            :     va_list_escapes = true;
     965                 :            : 
     966                 :       6118 : finish:
     967                 :       6118 :   if (va_list_escapes)
     968                 :            :     {
     969                 :       5098 :       fun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
     970                 :       5098 :       fun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
     971                 :            :     }
     972                 :       6215 :   BITMAP_FREE (si.va_list_vars);
     973                 :       6215 :   BITMAP_FREE (si.va_list_escape_vars);
     974                 :       6215 :   free (si.offsets);
     975                 :       6215 :   if (dump_file)
     976                 :            :     {
     977                 :         40 :       fprintf (dump_file, "%s: va_list escapes %d, needs to save ",
     978                 :            :                funcname, (int) va_list_escapes);
     979                 :         40 :       if (fun->va_list_gpr_size >= VA_LIST_MAX_GPR_SIZE)
     980                 :         21 :         fputs ("all", dump_file);
     981                 :            :       else
     982                 :         19 :         fprintf (dump_file, "%d", cfun->va_list_gpr_size);
     983                 :         40 :       fputs (" GPR units and ", dump_file);
     984                 :         40 :       if (fun->va_list_fpr_size >= VA_LIST_MAX_FPR_SIZE)
     985                 :         21 :         fputs ("all", dump_file);
     986                 :            :       else
     987                 :         19 :         fprintf (dump_file, "%d", cfun->va_list_fpr_size);
     988                 :         40 :       fputs (" FPR units.\n", dump_file);
     989                 :            :     }
     990                 :       6215 : }
     991                 :            : 
     992                 :            : /* Expand IFN_VA_ARGs in FUN.  */
     993                 :            : 
     994                 :            : static void
     995                 :      28522 : expand_ifn_va_arg_1 (function *fun)
     996                 :            : {
     997                 :      28522 :   bool modified = false;
     998                 :      28522 :   basic_block bb;
     999                 :      28522 :   gimple_stmt_iterator i;
    1000                 :      28522 :   location_t saved_location;
    1001                 :            : 
    1002                 :     379636 :   FOR_EACH_BB_FN (bb, fun)
    1003                 :    1759280 :     for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
    1004                 :            :       {
    1005                 :    1092870 :         gimple *stmt = gsi_stmt (i);
    1006                 :    1092870 :         tree ap, aptype, expr, lhs, type;
    1007                 :    1092870 :         gimple_seq pre = NULL, post = NULL;
    1008                 :            : 
    1009                 :    1092870 :         if (!gimple_call_internal_p (stmt, IFN_VA_ARG))
    1010                 :    1057050 :           continue;
    1011                 :            : 
    1012                 :      35824 :         modified = true;
    1013                 :            : 
    1014                 :      35824 :         type = TREE_TYPE (TREE_TYPE (gimple_call_arg (stmt, 1)));
    1015                 :      35824 :         ap = gimple_call_arg (stmt, 0);
    1016                 :      35824 :         aptype = TREE_TYPE (gimple_call_arg (stmt, 2));
    1017                 :      35824 :         gcc_assert (POINTER_TYPE_P (aptype));
    1018                 :            : 
    1019                 :            :         /* Balanced out the &ap, usually added by build_va_arg.  */
    1020                 :      35824 :         ap = build2 (MEM_REF, TREE_TYPE (aptype), ap,
    1021                 :      35824 :                      build_int_cst (aptype, 0));
    1022                 :            : 
    1023                 :      35824 :         push_gimplify_context (false);
    1024                 :      35824 :         saved_location = input_location;
    1025                 :      35824 :         input_location = gimple_location (stmt);
    1026                 :            : 
    1027                 :            :         /* Make it easier for the backends by protecting the valist argument
    1028                 :            :            from multiple evaluations.  */
    1029                 :      35824 :         gimplify_expr (&ap, &pre, &post, is_gimple_min_lval, fb_lvalue);
    1030                 :            : 
    1031                 :      35824 :         expr = targetm.gimplify_va_arg_expr (ap, type, &pre, &post);
    1032                 :            : 
    1033                 :      35824 :         lhs = gimple_call_lhs (stmt);
    1034                 :      35824 :         if (lhs != NULL_TREE)
    1035                 :            :           {
    1036                 :      35250 :             unsigned int nargs = gimple_call_num_args (stmt);
    1037                 :      35250 :             gcc_assert (useless_type_conversion_p (TREE_TYPE (lhs), type));
    1038                 :            : 
    1039                 :      35250 :             if (nargs == 4)
    1040                 :            :               {
    1041                 :            :                 /* We've transported the size of with WITH_SIZE_EXPR here as
    1042                 :            :                    the last argument of the internal fn call.  Now reinstate
    1043                 :            :                    it.  */
    1044                 :         99 :                 tree size = gimple_call_arg (stmt, nargs - 1);
    1045                 :         99 :                 expr = build2 (WITH_SIZE_EXPR, TREE_TYPE (expr), expr, size);
    1046                 :            :               }
    1047                 :            : 
    1048                 :            :             /* We use gimplify_assign here, rather than gimple_build_assign,
    1049                 :            :                because gimple_assign knows how to deal with variable-sized
    1050                 :            :                types.  */
    1051                 :      35250 :             gimplify_assign (lhs, expr, &pre);
    1052                 :            :           }
    1053                 :            :         else
    1054                 :        574 :           gimplify_and_add (expr, &pre);
    1055                 :            : 
    1056                 :      35824 :         input_location = saved_location;
    1057                 :      35824 :         pop_gimplify_context (NULL);
    1058                 :            : 
    1059                 :      35824 :         gimple_seq_add_seq (&pre, post);
    1060                 :      35824 :         update_modified_stmts (pre);
    1061                 :            : 
    1062                 :            :         /* Add the sequence after IFN_VA_ARG.  This splits the bb right
    1063                 :            :            after IFN_VA_ARG, and adds the sequence in one or more new bbs
    1064                 :            :            inbetween.  */
    1065                 :      35824 :         gimple_find_sub_bbs (pre, &i);
    1066                 :            : 
    1067                 :            :         /* Remove the IFN_VA_ARG gimple_call.  It's the last stmt in the
    1068                 :            :            bb.  */
    1069                 :      35824 :         unlink_stmt_vdef (stmt);
    1070                 :      71648 :         release_ssa_name_fn (fun, gimple_vdef (stmt));
    1071                 :      35824 :         gsi_remove (&i, true);
    1072                 :      35824 :         gcc_assert (gsi_end_p (i));
    1073                 :            : 
    1074                 :            :         /* We're walking here into the bbs which contain the expansion of
    1075                 :            :            IFN_VA_ARG, and will not contain another IFN_VA_ARG that needs
    1076                 :            :            expanding.  We could try to skip walking these bbs, perhaps by
    1077                 :            :            walking backwards over gimples and bbs.  */
    1078                 :      35824 :         break;
    1079                 :            :       }
    1080                 :            : 
    1081                 :      28522 :   if (!modified)
    1082                 :      19873 :     return;
    1083                 :            : 
    1084                 :       8649 :   free_dominance_info (CDI_DOMINATORS);
    1085                 :       8649 :   update_ssa (TODO_update_ssa);
    1086                 :            : }
    1087                 :            : 
    1088                 :            : /* Expand IFN_VA_ARGs in FUN, if necessary.  */
    1089                 :            : 
    1090                 :            : static void
    1091                 :     694112 : expand_ifn_va_arg (function *fun)
    1092                 :            : {
    1093                 :     694112 :   if ((fun->curr_properties & PROP_gimple_lva) == 0)
    1094                 :      28522 :     expand_ifn_va_arg_1 (fun);
    1095                 :            : 
    1096                 :     694112 :   if (flag_checking)
    1097                 :            :     {
    1098                 :     694102 :       basic_block bb;
    1099                 :     694102 :       gimple_stmt_iterator i;
    1100                 :    7316520 :       FOR_EACH_BB_FN (bb, fun)
    1101                 :   65662700 :         for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
    1102                 :   52417900 :           gcc_assert (!gimple_call_internal_p (gsi_stmt (i), IFN_VA_ARG));
    1103                 :            :     }
    1104                 :     694112 : }
    1105                 :            : 
    1106                 :            : namespace {
    1107                 :            : 
    1108                 :            : const pass_data pass_data_stdarg =
    1109                 :            : {
    1110                 :            :   GIMPLE_PASS, /* type */
    1111                 :            :   "stdarg", /* name */
    1112                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    1113                 :            :   TV_NONE, /* tv_id */
    1114                 :            :   ( PROP_cfg | PROP_ssa ), /* properties_required */
    1115                 :            :   PROP_gimple_lva, /* properties_provided */
    1116                 :            :   0, /* properties_destroyed */
    1117                 :            :   0, /* todo_flags_start */
    1118                 :            :   0, /* todo_flags_finish */
    1119                 :            : };
    1120                 :            : 
    1121                 :            : class pass_stdarg : public gimple_opt_pass
    1122                 :            : {
    1123                 :            : public:
    1124                 :     200773 :   pass_stdarg (gcc::context *ctxt)
    1125                 :     401546 :     : gimple_opt_pass (pass_data_stdarg, ctxt)
    1126                 :            :   {}
    1127                 :            : 
    1128                 :            :   /* opt_pass methods: */
    1129                 :     686787 :   virtual bool gate (function *)
    1130                 :            :     {
    1131                 :            :       /* Always run this pass, in order to expand va_arg internal_fns.  We
    1132                 :            :          also need to do that if fun->stdarg == 0, because a va_arg may also
    1133                 :            :          occur in a function without varargs, f.i. if when passing a va_list to
    1134                 :            :          another function.  */
    1135                 :     686787 :       return true;
    1136                 :            :     }
    1137                 :            : 
    1138                 :            :   virtual unsigned int execute (function *);
    1139                 :            : 
    1140                 :            : }; // class pass_stdarg
    1141                 :            : 
    1142                 :            : unsigned int
    1143                 :     686785 : pass_stdarg::execute (function *fun)
    1144                 :            : {
    1145                 :            :   /* TODO: Postpone expand_ifn_va_arg till after
    1146                 :            :      optimize_va_list_gpr_fpr_size.  */
    1147                 :     686785 :   expand_ifn_va_arg (fun);
    1148                 :            : 
    1149                 :     686785 :   if (flag_stdarg_opt
    1150                 :            :       /* This optimization is only for stdarg functions.  */
    1151                 :     686785 :       && fun->stdarg != 0)
    1152                 :       6215 :     optimize_va_list_gpr_fpr_size (fun);
    1153                 :            : 
    1154                 :     686785 :   return 0;
    1155                 :            : }
    1156                 :            : 
    1157                 :            : } // anon namespace
    1158                 :            : 
    1159                 :            : gimple_opt_pass *
    1160                 :     200773 : make_pass_stdarg (gcc::context *ctxt)
    1161                 :            : {
    1162                 :     200773 :   return new pass_stdarg (ctxt);
    1163                 :            : }
    1164                 :            : 
    1165                 :            : namespace {
    1166                 :            : 
    1167                 :            : const pass_data pass_data_lower_vaarg =
    1168                 :            : {
    1169                 :            :   GIMPLE_PASS, /* type */
    1170                 :            :   "lower_vaarg", /* name */
    1171                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    1172                 :            :   TV_NONE, /* tv_id */
    1173                 :            :   ( PROP_cfg | PROP_ssa ), /* properties_required */
    1174                 :            :   PROP_gimple_lva, /* properties_provided */
    1175                 :            :   0, /* properties_destroyed */
    1176                 :            :   0, /* todo_flags_start */
    1177                 :            :   0, /* todo_flags_finish */
    1178                 :            : };
    1179                 :            : 
    1180                 :            : class pass_lower_vaarg : public gimple_opt_pass
    1181                 :            : {
    1182                 :            : public:
    1183                 :     200773 :   pass_lower_vaarg (gcc::context *ctxt)
    1184                 :     401546 :     : gimple_opt_pass (pass_data_lower_vaarg, ctxt)
    1185                 :            :   {}
    1186                 :            : 
    1187                 :            :   /* opt_pass methods: */
    1188                 :     944512 :   virtual bool gate (function *)
    1189                 :            :     {
    1190                 :     944512 :       return (cfun->curr_properties & PROP_gimple_lva) == 0;
    1191                 :            :     }
    1192                 :            : 
    1193                 :            :   virtual unsigned int execute (function *);
    1194                 :            : 
    1195                 :            : }; // class pass_lower_vaarg
    1196                 :            : 
    1197                 :            : unsigned int
    1198                 :       7327 : pass_lower_vaarg::execute (function *fun)
    1199                 :            : {
    1200                 :       7327 :   expand_ifn_va_arg (fun);
    1201                 :       7327 :   return 0;
    1202                 :            : }
    1203                 :            : 
    1204                 :            : } // anon namespace
    1205                 :            : 
    1206                 :            : gimple_opt_pass *
    1207                 :     200773 : make_pass_lower_vaarg (gcc::context *ctxt)
    1208                 :            : {
    1209                 :     200773 :   return new pass_lower_vaarg (ctxt);
    1210                 :            : }

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.