LCOV - code coverage report
Current view: top level - gcc - calls.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1953 2441 80.0 %
Date: 2020-04-04 11:58:09 Functions: 48 57 84.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Convert function calls to rtl insns, for GNU C compiler.
       2                 :            :    Copyright (C) 1989-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 it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : 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 "target.h"
      25                 :            : #include "rtl.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "predict.h"
      29                 :            : #include "memmodel.h"
      30                 :            : #include "tm_p.h"
      31                 :            : #include "stringpool.h"
      32                 :            : #include "expmed.h"
      33                 :            : #include "optabs.h"
      34                 :            : #include "emit-rtl.h"
      35                 :            : #include "cgraph.h"
      36                 :            : #include "diagnostic-core.h"
      37                 :            : #include "fold-const.h"
      38                 :            : #include "stor-layout.h"
      39                 :            : #include "varasm.h"
      40                 :            : #include "internal-fn.h"
      41                 :            : #include "dojump.h"
      42                 :            : #include "explow.h"
      43                 :            : #include "calls.h"
      44                 :            : #include "expr.h"
      45                 :            : #include "output.h"
      46                 :            : #include "langhooks.h"
      47                 :            : #include "except.h"
      48                 :            : #include "dbgcnt.h"
      49                 :            : #include "rtl-iter.h"
      50                 :            : #include "tree-vrp.h"
      51                 :            : #include "tree-ssanames.h"
      52                 :            : #include "tree-ssa-strlen.h"
      53                 :            : #include "intl.h"
      54                 :            : #include "stringpool.h"
      55                 :            : #include "hash-map.h"
      56                 :            : #include "hash-traits.h"
      57                 :            : #include "attribs.h"
      58                 :            : #include "builtins.h"
      59                 :            : #include "gimple-fold.h"
      60                 :            : 
      61                 :            : /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits.  */
      62                 :            : #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
      63                 :            : 
      64                 :            : /* Data structure and subroutines used within expand_call.  */
      65                 :            : 
      66                 :            : struct arg_data
      67                 :            : {
      68                 :            :   /* Tree node for this argument.  */
      69                 :            :   tree tree_value;
      70                 :            :   /* Mode for value; TYPE_MODE unless promoted.  */
      71                 :            :   machine_mode mode;
      72                 :            :   /* Current RTL value for argument, or 0 if it isn't precomputed.  */
      73                 :            :   rtx value;
      74                 :            :   /* Initially-compute RTL value for argument; only for const functions.  */
      75                 :            :   rtx initial_value;
      76                 :            :   /* Register to pass this argument in, 0 if passed on stack, or an
      77                 :            :      PARALLEL if the arg is to be copied into multiple non-contiguous
      78                 :            :      registers.  */
      79                 :            :   rtx reg;
      80                 :            :   /* Register to pass this argument in when generating tail call sequence.
      81                 :            :      This is not the same register as for normal calls on machines with
      82                 :            :      register windows.  */
      83                 :            :   rtx tail_call_reg;
      84                 :            :   /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
      85                 :            :      form for emit_group_move.  */
      86                 :            :   rtx parallel_value;
      87                 :            :   /* If REG was promoted from the actual mode of the argument expression,
      88                 :            :      indicates whether the promotion is sign- or zero-extended.  */
      89                 :            :   int unsignedp;
      90                 :            :   /* Number of bytes to put in registers.  0 means put the whole arg
      91                 :            :      in registers.  Also 0 if not passed in registers.  */
      92                 :            :   int partial;
      93                 :            :   /* Nonzero if argument must be passed on stack.
      94                 :            :      Note that some arguments may be passed on the stack
      95                 :            :      even though pass_on_stack is zero, just because FUNCTION_ARG says so.
      96                 :            :      pass_on_stack identifies arguments that *cannot* go in registers.  */
      97                 :            :   int pass_on_stack;
      98                 :            :   /* Some fields packaged up for locate_and_pad_parm.  */
      99                 :            :   struct locate_and_pad_arg_data locate;
     100                 :            :   /* Location on the stack at which parameter should be stored.  The store
     101                 :            :      has already been done if STACK == VALUE.  */
     102                 :            :   rtx stack;
     103                 :            :   /* Location on the stack of the start of this argument slot.  This can
     104                 :            :      differ from STACK if this arg pads downward.  This location is known
     105                 :            :      to be aligned to TARGET_FUNCTION_ARG_BOUNDARY.  */
     106                 :            :   rtx stack_slot;
     107                 :            :   /* Place that this stack area has been saved, if needed.  */
     108                 :            :   rtx save_area;
     109                 :            :   /* If an argument's alignment does not permit direct copying into registers,
     110                 :            :      copy in smaller-sized pieces into pseudos.  These are stored in a
     111                 :            :      block pointed to by this field.  The next field says how many
     112                 :            :      word-sized pseudos we made.  */
     113                 :            :   rtx *aligned_regs;
     114                 :            :   int n_aligned_regs;
     115                 :            : };
     116                 :            : 
     117                 :            : /* A vector of one char per byte of stack space.  A byte if nonzero if
     118                 :            :    the corresponding stack location has been used.
     119                 :            :    This vector is used to prevent a function call within an argument from
     120                 :            :    clobbering any stack already set up.  */
     121                 :            : static char *stack_usage_map;
     122                 :            : 
     123                 :            : /* Size of STACK_USAGE_MAP.  */
     124                 :            : static unsigned int highest_outgoing_arg_in_use;
     125                 :            : 
     126                 :            : /* Assume that any stack location at this byte index is used,
     127                 :            :    without checking the contents of stack_usage_map.  */
     128                 :            : static unsigned HOST_WIDE_INT stack_usage_watermark = HOST_WIDE_INT_M1U;
     129                 :            : 
     130                 :            : /* A bitmap of virtual-incoming stack space.  Bit is set if the corresponding
     131                 :            :    stack location's tail call argument has been already stored into the stack.
     132                 :            :    This bitmap is used to prevent sibling call optimization if function tries
     133                 :            :    to use parent's incoming argument slots when they have been already
     134                 :            :    overwritten with tail call arguments.  */
     135                 :            : static sbitmap stored_args_map;
     136                 :            : 
     137                 :            : /* Assume that any virtual-incoming location at this byte index has been
     138                 :            :    stored, without checking the contents of stored_args_map.  */
     139                 :            : static unsigned HOST_WIDE_INT stored_args_watermark;
     140                 :            : 
     141                 :            : /* stack_arg_under_construction is nonzero when an argument may be
     142                 :            :    initialized with a constructor call (including a C function that
     143                 :            :    returns a BLKmode struct) and expand_call must take special action
     144                 :            :    to make sure the object being constructed does not overlap the
     145                 :            :    argument list for the constructor call.  */
     146                 :            : static int stack_arg_under_construction;
     147                 :            : 
     148                 :            : static void precompute_register_parameters (int, struct arg_data *, int *);
     149                 :            : static int store_one_arg (struct arg_data *, rtx, int, int, int);
     150                 :            : static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
     151                 :            : static int finalize_must_preallocate (int, int, struct arg_data *,
     152                 :            :                                       struct args_size *);
     153                 :            : static void precompute_arguments (int, struct arg_data *);
     154                 :            : static void compute_argument_addresses (struct arg_data *, rtx, int);
     155                 :            : static rtx rtx_for_function_call (tree, tree);
     156                 :            : static void load_register_parameters (struct arg_data *, int, rtx *, int,
     157                 :            :                                       int, int *);
     158                 :            : static int special_function_p (const_tree, int);
     159                 :            : static int check_sibcall_argument_overlap_1 (rtx);
     160                 :            : static int check_sibcall_argument_overlap (rtx_insn *, struct arg_data *, int);
     161                 :            : 
     162                 :            : static tree split_complex_types (tree);
     163                 :            : 
     164                 :            : #ifdef REG_PARM_STACK_SPACE
     165                 :            : static rtx save_fixed_argument_area (int, rtx, int *, int *);
     166                 :            : static void restore_fixed_argument_area (rtx, rtx, int, int);
     167                 :            : #endif
     168                 :            : 
     169                 :            : /* Return true if bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
     170                 :            :    stack region might already be in use.  */
     171                 :            : 
     172                 :            : static bool
     173                 :       1430 : stack_region_maybe_used_p (poly_uint64 lower_bound, poly_uint64 upper_bound,
     174                 :            :                            unsigned int reg_parm_stack_space)
     175                 :            : {
     176                 :       1430 :   unsigned HOST_WIDE_INT const_lower, const_upper;
     177                 :       1430 :   const_lower = constant_lower_bound (lower_bound);
     178                 :       1430 :   if (!upper_bound.is_constant (&const_upper))
     179                 :            :     const_upper = HOST_WIDE_INT_M1U;
     180                 :            : 
     181                 :       1430 :   if (const_upper > stack_usage_watermark)
     182                 :            :     return true;
     183                 :            : 
     184                 :            :   /* Don't worry about things in the fixed argument area;
     185                 :            :      it has already been saved.  */
     186                 :       1430 :   const_lower = MAX (const_lower, reg_parm_stack_space);
     187                 :       1430 :   const_upper = MIN (const_upper, highest_outgoing_arg_in_use);
     188                 :      13094 :   for (unsigned HOST_WIDE_INT i = const_lower; i < const_upper; ++i)
     189                 :      11664 :     if (stack_usage_map[i])
     190                 :            :       return true;
     191                 :            :   return false;
     192                 :            : }
     193                 :            : 
     194                 :            : /* Record that bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
     195                 :            :    stack region are now in use.  */
     196                 :            : 
     197                 :            : static void
     198                 :       1430 : mark_stack_region_used (poly_uint64 lower_bound, poly_uint64 upper_bound)
     199                 :            : {
     200                 :       1430 :   unsigned HOST_WIDE_INT const_lower, const_upper;
     201                 :       1430 :   const_lower = constant_lower_bound (lower_bound);
     202                 :       1430 :   if (upper_bound.is_constant (&const_upper))
     203                 :      13094 :     for (unsigned HOST_WIDE_INT i = const_lower; i < const_upper; ++i)
     204                 :      11664 :       stack_usage_map[i] = 1;
     205                 :            :   else
     206                 :            :     stack_usage_watermark = MIN (stack_usage_watermark, const_lower);
     207                 :          0 : }
     208                 :            : 
     209                 :            : /* Force FUNEXP into a form suitable for the address of a CALL,
     210                 :            :    and return that as an rtx.  Also load the static chain register
     211                 :            :    if FNDECL is a nested function.
     212                 :            : 
     213                 :            :    CALL_FUSAGE points to a variable holding the prospective
     214                 :            :    CALL_INSN_FUNCTION_USAGE information.  */
     215                 :            : 
     216                 :            : rtx
     217                 :    3962870 : prepare_call_address (tree fndecl_or_type, rtx funexp, rtx static_chain_value,
     218                 :            :                       rtx *call_fusage, int reg_parm_seen, int flags)
     219                 :            : {
     220                 :            :   /* Make a valid memory address and copy constants through pseudo-regs,
     221                 :            :      but not for a constant address if -fno-function-cse.  */
     222                 :    3962870 :   if (GET_CODE (funexp) != SYMBOL_REF)
     223                 :            :     {
     224                 :            :       /* If it's an indirect call by descriptor, generate code to perform
     225                 :            :          runtime identification of the pointer and load the descriptor.  */
     226                 :     145257 :       if ((flags & ECF_BY_DESCRIPTOR) && !flag_trampolines)
     227                 :            :         {
     228                 :          0 :           const int bit_val = targetm.calls.custom_function_descriptors;
     229                 :          0 :           rtx call_lab = gen_label_rtx ();
     230                 :            : 
     231                 :          0 :           gcc_assert (fndecl_or_type && TYPE_P (fndecl_or_type));
     232                 :          0 :           fndecl_or_type
     233                 :          0 :             = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, NULL_TREE,
     234                 :            :                           fndecl_or_type);
     235                 :          0 :           DECL_STATIC_CHAIN (fndecl_or_type) = 1;
     236                 :          0 :           rtx chain = targetm.calls.static_chain (fndecl_or_type, false);
     237                 :            : 
     238                 :          0 :           if (GET_MODE (funexp) != Pmode)
     239                 :          0 :             funexp = convert_memory_address (Pmode, funexp);
     240                 :            : 
     241                 :            :           /* Avoid long live ranges around function calls.  */
     242                 :          0 :           funexp = copy_to_mode_reg (Pmode, funexp);
     243                 :            : 
     244                 :          0 :           if (REG_P (chain))
     245                 :          0 :             emit_insn (gen_rtx_CLOBBER (VOIDmode, chain));
     246                 :            : 
     247                 :            :           /* Emit the runtime identification pattern.  */
     248                 :          0 :           rtx mask = gen_rtx_AND (Pmode, funexp, GEN_INT (bit_val));
     249                 :          0 :           emit_cmp_and_jump_insns (mask, const0_rtx, EQ, NULL_RTX, Pmode, 1,
     250                 :            :                                    call_lab);
     251                 :            : 
     252                 :            :           /* Statically predict the branch to very likely taken.  */
     253                 :          0 :           rtx_insn *insn = get_last_insn ();
     254                 :          0 :           if (JUMP_P (insn))
     255                 :          0 :             predict_insn_def (insn, PRED_BUILTIN_EXPECT, TAKEN);
     256                 :            : 
     257                 :            :           /* Load the descriptor.  */
     258                 :          0 :           rtx mem = gen_rtx_MEM (ptr_mode,
     259                 :          0 :                                  plus_constant (Pmode, funexp, - bit_val));
     260                 :          0 :           MEM_NOTRAP_P (mem) = 1;
     261                 :          0 :           mem = convert_memory_address (Pmode, mem);
     262                 :          0 :           emit_move_insn (chain, mem);
     263                 :            : 
     264                 :          0 :           mem = gen_rtx_MEM (ptr_mode,
     265                 :          0 :                              plus_constant (Pmode, funexp,
     266                 :          0 :                                             POINTER_SIZE / BITS_PER_UNIT
     267                 :          0 :                                               - bit_val));
     268                 :          0 :           MEM_NOTRAP_P (mem) = 1;
     269                 :          0 :           mem = convert_memory_address (Pmode, mem);
     270                 :          0 :           emit_move_insn (funexp, mem);
     271                 :            : 
     272                 :          0 :           emit_label (call_lab);
     273                 :            : 
     274                 :          0 :           if (REG_P (chain))
     275                 :            :             {
     276                 :          0 :               use_reg (call_fusage, chain);
     277                 :          0 :               STATIC_CHAIN_REG_P (chain) = 1;
     278                 :            :             }
     279                 :            : 
     280                 :            :           /* Make sure we're not going to be overwritten below.  */
     281                 :          0 :           gcc_assert (!static_chain_value);
     282                 :            :         }
     283                 :            : 
     284                 :            :       /* If we are using registers for parameters, force the
     285                 :            :          function address into a register now.  */
     286                 :     145257 :       funexp = ((reg_parm_seen
     287                 :     108670 :                  && targetm.small_register_classes_for_mode_p (FUNCTION_MODE))
     288                 :     253927 :                  ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
     289                 :      36587 :                  : memory_address (FUNCTION_MODE, funexp));
     290                 :            :     }
     291                 :            :   else
     292                 :            :     {
     293                 :            :       /* funexp could be a SYMBOL_REF represents a function pointer which is
     294                 :            :          of ptr_mode.  In this case, it should be converted into address mode
     295                 :            :          to be a valid address for memory rtx pattern.  See PR 64971.  */
     296                 :    4404500 :       if (GET_MODE (funexp) != Pmode)
     297                 :          0 :         funexp = convert_memory_address (Pmode, funexp);
     298                 :            : 
     299                 :    3817610 :       if (!(flags & ECF_SIBCALL))
     300                 :            :         {
     301                 :            :           if (!NO_FUNCTION_CSE && optimize && ! flag_no_function_cse)
     302                 :            :             funexp = force_reg (Pmode, funexp);
     303                 :            :         }
     304                 :            :     }
     305                 :            : 
     306                 :    3962870 :   if (static_chain_value != 0
     307                 :    3962870 :       && (TREE_CODE (fndecl_or_type) != FUNCTION_DECL
     308                 :       9173 :           || DECL_STATIC_CHAIN (fndecl_or_type)))
     309                 :            :     {
     310                 :      25571 :       rtx chain;
     311                 :            : 
     312                 :      25571 :       chain = targetm.calls.static_chain (fndecl_or_type, false);
     313                 :      51142 :       static_chain_value = convert_memory_address (Pmode, static_chain_value);
     314                 :            : 
     315                 :      25571 :       emit_move_insn (chain, static_chain_value);
     316                 :      25571 :       if (REG_P (chain))
     317                 :            :         {
     318                 :      25571 :           use_reg (call_fusage, chain);
     319                 :      25571 :           STATIC_CHAIN_REG_P (chain) = 1;
     320                 :            :         }
     321                 :            :     }
     322                 :            : 
     323                 :    3962870 :   return funexp;
     324                 :            : }
     325                 :            : 
     326                 :            : /* Generate instructions to call function FUNEXP,
     327                 :            :    and optionally pop the results.
     328                 :            :    The CALL_INSN is the first insn generated.
     329                 :            : 
     330                 :            :    FNDECL is the declaration node of the function.  This is given to the
     331                 :            :    hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
     332                 :            :    its own args.
     333                 :            : 
     334                 :            :    FUNTYPE is the data type of the function.  This is given to the hook
     335                 :            :    TARGET_RETURN_POPS_ARGS to determine whether this function pops its
     336                 :            :    own args.  We used to allow an identifier for library functions, but
     337                 :            :    that doesn't work when the return type is an aggregate type and the
     338                 :            :    calling convention says that the pointer to this aggregate is to be
     339                 :            :    popped by the callee.
     340                 :            : 
     341                 :            :    STACK_SIZE is the number of bytes of arguments on the stack,
     342                 :            :    ROUNDED_STACK_SIZE is that number rounded up to
     343                 :            :    PREFERRED_STACK_BOUNDARY; zero if the size is variable.  This is
     344                 :            :    both to put into the call insn and to generate explicit popping
     345                 :            :    code if necessary.
     346                 :            : 
     347                 :            :    STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
     348                 :            :    It is zero if this call doesn't want a structure value.
     349                 :            : 
     350                 :            :    NEXT_ARG_REG is the rtx that results from executing
     351                 :            :      targetm.calls.function_arg (&args_so_far,
     352                 :            :                                  function_arg_info::end_marker ());
     353                 :            :    just after all the args have had their registers assigned.
     354                 :            :    This could be whatever you like, but normally it is the first
     355                 :            :    arg-register beyond those used for args in this call,
     356                 :            :    or 0 if all the arg-registers are used in this call.
     357                 :            :    It is passed on to `gen_call' so you can put this info in the call insn.
     358                 :            : 
     359                 :            :    VALREG is a hard register in which a value is returned,
     360                 :            :    or 0 if the call does not return a value.
     361                 :            : 
     362                 :            :    OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
     363                 :            :    the args to this call were processed.
     364                 :            :    We restore `inhibit_defer_pop' to that value.
     365                 :            : 
     366                 :            :    CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
     367                 :            :    denote registers used by the called function.  */
     368                 :            : 
     369                 :            : static void
     370                 :    3962660 : emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED,
     371                 :            :              tree funtype ATTRIBUTE_UNUSED,
     372                 :            :              poly_int64 stack_size ATTRIBUTE_UNUSED,
     373                 :            :              poly_int64 rounded_stack_size,
     374                 :            :              poly_int64 struct_value_size ATTRIBUTE_UNUSED,
     375                 :            :              rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
     376                 :            :              int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
     377                 :            :              cumulative_args_t args_so_far ATTRIBUTE_UNUSED)
     378                 :            : {
     379                 :    4577740 :   rtx rounded_stack_size_rtx = gen_int_mode (rounded_stack_size, Pmode);
     380                 :    3962660 :   rtx call, funmem, pat;
     381                 :    3962660 :   int already_popped = 0;
     382                 :    3962660 :   poly_int64 n_popped = 0;
     383                 :            : 
     384                 :            :   /* Sibling call patterns never pop arguments (no sibcall(_value)_pop
     385                 :            :      patterns exist).  Any popping that the callee does on return will
     386                 :            :      be from our caller's frame rather than ours.  */
     387                 :    3962660 :   if (!(ecf_flags & ECF_SIBCALL))
     388                 :            :     {
     389                 :    3871500 :       n_popped += targetm.calls.return_pops_args (fndecl, funtype, stack_size);
     390                 :            : 
     391                 :            : #ifdef CALL_POPS_ARGS
     392                 :            :       n_popped += CALL_POPS_ARGS (*get_cumulative_args (args_so_far));
     393                 :            : #endif
     394                 :            :     }
     395                 :            : 
     396                 :            :   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
     397                 :            :      and we don't want to load it into a register as an optimization,
     398                 :            :      because prepare_call_address already did it if it should be done.  */
     399                 :    3962660 :   if (GET_CODE (funexp) != SYMBOL_REF)
     400                 :     145232 :     funexp = memory_address (FUNCTION_MODE, funexp);
     401                 :            : 
     402                 :    3962660 :   funmem = gen_rtx_MEM (FUNCTION_MODE, funexp);
     403                 :    3962660 :   if (fndecl && TREE_CODE (fndecl) == FUNCTION_DECL)
     404                 :            :     {
     405                 :    3730970 :       tree t = fndecl;
     406                 :            : 
     407                 :            :       /* Although a built-in FUNCTION_DECL and its non-__builtin
     408                 :            :          counterpart compare equal and get a shared mem_attrs, they
     409                 :            :          produce different dump output in compare-debug compilations,
     410                 :            :          if an entry gets garbage collected in one compilation, then
     411                 :            :          adds a different (but equivalent) entry, while the other
     412                 :            :          doesn't run the garbage collector at the same spot and then
     413                 :            :          shares the mem_attr with the equivalent entry. */
     414                 :    3730970 :       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
     415                 :            :         {
     416                 :     708160 :           tree t2 = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
     417                 :     708160 :           if (t2)
     418                 :     708160 :             t = t2;
     419                 :            :         }
     420                 :            : 
     421                 :    3730970 :         set_mem_expr (funmem, t);
     422                 :            :     }
     423                 :     231690 :   else if (fntree)
     424                 :     145248 :     set_mem_expr (funmem, build_simple_mem_ref (CALL_EXPR_FN (fntree)));
     425                 :            : 
     426                 :    3962660 :   if (ecf_flags & ECF_SIBCALL)
     427                 :            :     {
     428                 :      91160 :       if (valreg)
     429                 :      29027 :         pat = targetm.gen_sibcall_value (valreg, funmem,
     430                 :            :                                          rounded_stack_size_rtx,
     431                 :            :                                          next_arg_reg, NULL_RTX);
     432                 :            :       else
     433                 :      62133 :         pat = targetm.gen_sibcall (funmem, rounded_stack_size_rtx,
     434                 :            :                                    next_arg_reg,
     435                 :      65522 :                                    gen_int_mode (struct_value_size, Pmode));
     436                 :            :     }
     437                 :            :   /* If the target has "call" or "call_value" insns, then prefer them
     438                 :            :      if no arguments are actually popped.  If the target does not have
     439                 :            :      "call" or "call_value" insns, then we must use the popping versions
     440                 :            :      even if the call has no arguments to pop.  */
     441                 :    3871500 :   else if (maybe_ne (n_popped, 0)
     442                 :    7635310 :            || !(valreg
     443                 :    1452710 :                 ? targetm.have_call_value ()
     444                 :    2311100 :                 : targetm.have_call ()))
     445                 :            :     {
     446                 :     215390 :       rtx n_pop = gen_int_mode (n_popped, Pmode);
     447                 :            : 
     448                 :            :       /* If this subroutine pops its own args, record that in the call insn
     449                 :            :          if possible, for the sake of frame pointer elimination.  */
     450                 :            : 
     451                 :     107695 :       if (valreg)
     452                 :          0 :         pat = targetm.gen_call_value_pop (valreg, funmem,
     453                 :            :                                           rounded_stack_size_rtx,
     454                 :            :                                           next_arg_reg, n_pop);
     455                 :            :       else
     456                 :     107695 :         pat = targetm.gen_call_pop (funmem, rounded_stack_size_rtx,
     457                 :            :                                     next_arg_reg, n_pop);
     458                 :            : 
     459                 :            :       already_popped = 1;
     460                 :            :     }
     461                 :            :   else
     462                 :            :     {
     463                 :    3763810 :       if (valreg)
     464                 :    1452710 :         pat = targetm.gen_call_value (valreg, funmem, rounded_stack_size_rtx,
     465                 :            :                                       next_arg_reg, NULL_RTX);
     466                 :            :       else
     467                 :    2311100 :         pat = targetm.gen_call (funmem, rounded_stack_size_rtx, next_arg_reg,
     468                 :    2595760 :                                 gen_int_mode (struct_value_size, Pmode));
     469                 :            :     }
     470                 :    3962660 :   emit_insn (pat);
     471                 :            : 
     472                 :            :   /* Find the call we just emitted.  */
     473                 :    3962660 :   rtx_call_insn *call_insn = last_call_insn ();
     474                 :            : 
     475                 :            :   /* Some target create a fresh MEM instead of reusing the one provided
     476                 :            :      above.  Set its MEM_EXPR.  */
     477                 :    3962660 :   call = get_call_rtx_from (call_insn);
     478                 :    3962660 :   if (call
     479                 :    4049190 :       && MEM_EXPR (XEXP (call, 0)) == NULL_TREE
     480                 :    4049190 :       && MEM_EXPR (funmem) != NULL_TREE)
     481                 :         86 :     set_mem_expr (XEXP (call, 0), MEM_EXPR (funmem));
     482                 :            : 
     483                 :            :   /* Put the register usage information there.  */
     484                 :    3962660 :   add_function_usage_to (call_insn, call_fusage);
     485                 :            : 
     486                 :            :   /* If this is a const call, then set the insn's unchanging bit.  */
     487                 :    3962660 :   if (ecf_flags & ECF_CONST)
     488                 :     139338 :     RTL_CONST_CALL_P (call_insn) = 1;
     489                 :            : 
     490                 :            :   /* If this is a pure call, then set the insn's unchanging bit.  */
     491                 :    3962660 :   if (ecf_flags & ECF_PURE)
     492                 :     120712 :     RTL_PURE_CALL_P (call_insn) = 1;
     493                 :            : 
     494                 :            :   /* If this is a const call, then set the insn's unchanging bit.  */
     495                 :    3962660 :   if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
     496                 :      29446 :     RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn) = 1;
     497                 :            : 
     498                 :            :   /* Create a nothrow REG_EH_REGION note, if needed.  */
     499                 :    3962660 :   make_reg_eh_region_note (call_insn, ecf_flags, 0);
     500                 :            : 
     501                 :    3962660 :   if (ecf_flags & ECF_NORETURN)
     502                 :     520990 :     add_reg_note (call_insn, REG_NORETURN, const0_rtx);
     503                 :            : 
     504                 :    3962660 :   if (ecf_flags & ECF_RETURNS_TWICE)
     505                 :            :     {
     506                 :       1214 :       add_reg_note (call_insn, REG_SETJMP, const0_rtx);
     507                 :       1214 :       cfun->calls_setjmp = 1;
     508                 :            :     }
     509                 :            : 
     510                 :    3962660 :   SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
     511                 :            : 
     512                 :            :   /* Restore this now, so that we do defer pops for this call's args
     513                 :            :      if the context of the call as a whole permits.  */
     514                 :    3962660 :   inhibit_defer_pop = old_inhibit_defer_pop;
     515                 :            : 
     516                 :    3962660 :   if (maybe_ne (n_popped, 0))
     517                 :            :     {
     518                 :     107695 :       if (!already_popped)
     519                 :          0 :         CALL_INSN_FUNCTION_USAGE (call_insn)
     520                 :          0 :           = gen_rtx_EXPR_LIST (VOIDmode,
     521                 :            :                                gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
     522                 :            :                                CALL_INSN_FUNCTION_USAGE (call_insn));
     523                 :     107695 :       rounded_stack_size -= n_popped;
     524                 :     215390 :       rounded_stack_size_rtx = gen_int_mode (rounded_stack_size, Pmode);
     525                 :     107695 :       stack_pointer_delta -= n_popped;
     526                 :            : 
     527                 :     107695 :       add_args_size_note (call_insn, stack_pointer_delta);
     528                 :            : 
     529                 :            :       /* If popup is needed, stack realign must use DRAP  */
     530                 :     107695 :       if (SUPPORTS_STACK_ALIGNMENT)
     531                 :     107695 :         crtl->need_drap = true;
     532                 :            :     }
     533                 :            :   /* For noreturn calls when not accumulating outgoing args force
     534                 :            :      REG_ARGS_SIZE note to prevent crossjumping of calls with different
     535                 :            :      args sizes.  */
     536                 :    3854970 :   else if (!ACCUMULATE_OUTGOING_ARGS && (ecf_flags & ECF_NORETURN) != 0)
     537                 :     520856 :     add_args_size_note (call_insn, stack_pointer_delta);
     538                 :            : 
     539                 :    3962660 :   if (!ACCUMULATE_OUTGOING_ARGS)
     540                 :            :     {
     541                 :            :       /* If returning from the subroutine does not automatically pop the args,
     542                 :            :          we need an instruction to pop them sooner or later.
     543                 :            :          Perhaps do it now; perhaps just record how much space to pop later.
     544                 :            : 
     545                 :            :          If returning from the subroutine does pop the args, indicate that the
     546                 :            :          stack pointer will be changed.  */
     547                 :            : 
     548                 :    3940940 :       if (maybe_ne (rounded_stack_size, 0))
     549                 :            :         {
     550                 :     752798 :           if (ecf_flags & ECF_NORETURN)
     551                 :            :             /* Just pretend we did the pop.  */
     552                 :      48459 :             stack_pointer_delta -= rounded_stack_size;
     553                 :     704339 :           else if (flag_defer_pop && inhibit_defer_pop == 0
     554                 :     631794 :               && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
     555                 :     622912 :             pending_stack_adjust += rounded_stack_size;
     556                 :            :           else
     557                 :      81427 :             adjust_stack (rounded_stack_size_rtx);
     558                 :            :         }
     559                 :            :     }
     560                 :            :   /* When we accumulate outgoing args, we must avoid any stack manipulations.
     561                 :            :      Restore the stack pointer to its original value now.  Usually
     562                 :            :      ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
     563                 :            :      On  i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
     564                 :            :      popping variants of functions exist as well.
     565                 :            : 
     566                 :            :      ??? We may optimize similar to defer_pop above, but it is
     567                 :            :      probably not worthwhile.
     568                 :            : 
     569                 :            :      ??? It will be worthwhile to enable combine_stack_adjustments even for
     570                 :            :      such machines.  */
     571                 :      21720 :   else if (maybe_ne (n_popped, 0))
     572                 :          0 :     anti_adjust_stack (gen_int_mode (n_popped, Pmode));
     573                 :    3962660 : }
     574                 :            : 
     575                 :            : /* Determine if the function identified by FNDECL is one with
     576                 :            :    special properties we wish to know about.  Modify FLAGS accordingly.
     577                 :            : 
     578                 :            :    For example, if the function might return more than one time (setjmp), then
     579                 :            :    set ECF_RETURNS_TWICE.
     580                 :            : 
     581                 :            :    Set ECF_MAY_BE_ALLOCA for any memory allocation function that might allocate
     582                 :            :    space from the stack such as alloca.  */
     583                 :            : 
     584                 :            : static int
     585                 : 1867280000 : special_function_p (const_tree fndecl, int flags)
     586                 :            : {
     587                 : 1867280000 :   tree name_decl = DECL_NAME (fndecl);
     588                 :            : 
     589                 : 1867280000 :   if (maybe_special_function_p (fndecl)
     590                 : 3199240000 :       && IDENTIFIER_LENGTH (name_decl) <= 11)
     591                 :            :     {
     592                 :  208296000 :       const char *name = IDENTIFIER_POINTER (name_decl);
     593                 :  208296000 :       const char *tname = name;
     594                 :            : 
     595                 :            :       /* We assume that alloca will always be called by name.  It
     596                 :            :          makes no sense to pass it as a pointer-to-function to
     597                 :            :          anything that does not understand its behavior.  */
     598                 :  208296000 :       if (IDENTIFIER_LENGTH (name_decl) == 6
     599                 :   27075600 :           && name[0] == 'a'
     600                 :  208541000 :           && ! strcmp (name, "alloca"))
     601                 :      30355 :         flags |= ECF_MAY_BE_ALLOCA;
     602                 :            : 
     603                 :            :       /* Disregard prefix _ or __.  */
     604                 :  208296000 :       if (name[0] == '_')
     605                 :            :         {
     606                 :    9025600 :           if (name[1] == '_')
     607                 :    8263920 :             tname += 2;
     608                 :            :           else
     609                 :     761688 :             tname += 1;
     610                 :            :         }
     611                 :            : 
     612                 :            :       /* ECF_RETURNS_TWICE is safe even for -ffreestanding.  */
     613                 :  208296000 :       if (! strcmp (tname, "setjmp")
     614                 :  208121000 :           || ! strcmp (tname, "sigsetjmp")
     615                 :  208105000 :           || ! strcmp (name, "savectx")
     616                 :  208105000 :           || ! strcmp (name, "vfork")
     617                 :  208094000 :           || ! strcmp (name, "getcontext"))
     618                 :     218713 :         flags |= ECF_RETURNS_TWICE;
     619                 :            :     }
     620                 :            : 
     621                 : 1867280000 :   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
     622                 : 1867280000 :       && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
     623                 :    2379840 :     flags |= ECF_MAY_BE_ALLOCA;
     624                 :            : 
     625                 : 1867280000 :   return flags;
     626                 :            : }
     627                 :            : 
     628                 :            : /* Similar to special_function_p; return a set of ERF_ flags for the
     629                 :            :    function FNDECL.  */
     630                 :            : static int
     631                 :    3730970 : decl_return_flags (tree fndecl)
     632                 :            : {
     633                 :    3730970 :   tree attr;
     634                 :    3730970 :   tree type = TREE_TYPE (fndecl);
     635                 :    3730970 :   if (!type)
     636                 :            :     return 0;
     637                 :            : 
     638                 :    3730970 :   attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
     639                 :    3730970 :   if (!attr)
     640                 :            :     return 0;
     641                 :            : 
     642                 :     306460 :   attr = TREE_VALUE (TREE_VALUE (attr));
     643                 :     612920 :   if (!attr || TREE_STRING_LENGTH (attr) < 1)
     644                 :            :     return 0;
     645                 :            : 
     646                 :     306460 :   switch (TREE_STRING_POINTER (attr)[0])
     647                 :            :     {
     648                 :      65219 :     case '1':
     649                 :      65219 :     case '2':
     650                 :      65219 :     case '3':
     651                 :      65219 :     case '4':
     652                 :      65219 :       return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
     653                 :            : 
     654                 :            :     case 'm':
     655                 :            :       return ERF_NOALIAS;
     656                 :            : 
     657                 :     241241 :     case '.':
     658                 :     241241 :     default:
     659                 :     241241 :       return 0;
     660                 :            :     }
     661                 :            : }
     662                 :            : 
     663                 :            : /* Return nonzero when FNDECL represents a call to setjmp.  */
     664                 :            : 
     665                 :            : int
     666                 :   20374800 : setjmp_call_p (const_tree fndecl)
     667                 :            : {
     668                 :   20374800 :   if (DECL_IS_RETURNS_TWICE (fndecl))
     669                 :            :     return ECF_RETURNS_TWICE;
     670                 :   20374600 :   return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
     671                 :            : }
     672                 :            : 
     673                 :            : 
     674                 :            : /* Return true if STMT may be an alloca call.  */
     675                 :            : 
     676                 :            : bool
     677                 :   11690700 : gimple_maybe_alloca_call_p (const gimple *stmt)
     678                 :            : {
     679                 :   11690700 :   tree fndecl;
     680                 :            : 
     681                 :   11690700 :   if (!is_gimple_call (stmt))
     682                 :            :     return false;
     683                 :            : 
     684                 :   11690700 :   fndecl = gimple_call_fndecl (stmt);
     685                 :   11690700 :   if (fndecl && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
     686                 :       4427 :     return true;
     687                 :            : 
     688                 :            :   return false;
     689                 :            : }
     690                 :            : 
     691                 :            : /* Return true if STMT is a builtin alloca call.  */
     692                 :            : 
     693                 :            : bool
     694                 :   59516100 : gimple_alloca_call_p (const gimple *stmt)
     695                 :            : {
     696                 :   59516100 :   tree fndecl;
     697                 :            : 
     698                 :   59516100 :   if (!is_gimple_call (stmt))
     699                 :            :     return false;
     700                 :            : 
     701                 :    9978980 :   fndecl = gimple_call_fndecl (stmt);
     702                 :    9978980 :   if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
     703                 :    2410490 :     switch (DECL_FUNCTION_CODE (fndecl))
     704                 :            :       {
     705                 :      30449 :       CASE_BUILT_IN_ALLOCA:
     706                 :      30449 :         return gimple_call_num_args (stmt) > 0;
     707                 :            :       default:
     708                 :            :         break;
     709                 :            :       }
     710                 :            : 
     711                 :            :   return false;
     712                 :            : }
     713                 :            : 
     714                 :            : /* Return true when exp contains a builtin alloca call.  */
     715                 :            : 
     716                 :            : bool
     717                 :     404138 : alloca_call_p (const_tree exp)
     718                 :            : {
     719                 :     404138 :   tree fndecl;
     720                 :     404138 :   if (TREE_CODE (exp) == CALL_EXPR
     721                 :     404138 :       && (fndecl = get_callee_fndecl (exp))
     722                 :     808276 :       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
     723                 :     271328 :     switch (DECL_FUNCTION_CODE (fndecl))
     724                 :            :       {
     725                 :          0 :       CASE_BUILT_IN_ALLOCA:
     726                 :          0 :         return true;
     727                 :            :       default:
     728                 :            :         break;
     729                 :            :       }
     730                 :            : 
     731                 :            :   return false;
     732                 :            : }
     733                 :            : 
     734                 :            : /* Return TRUE if FNDECL is either a TM builtin or a TM cloned
     735                 :            :    function.  Return FALSE otherwise.  */
     736                 :            : 
     737                 :            : static bool
     738                 :     668801 : is_tm_builtin (const_tree fndecl)
     739                 :            : {
     740                 :     668801 :   if (fndecl == NULL)
     741                 :            :     return false;
     742                 :            : 
     743                 :    1263900 :   if (decl_is_tm_clone (fndecl))
     744                 :            :     return true;
     745                 :            : 
     746                 :     651556 :   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
     747                 :            :     {
     748                 :     360572 :       switch (DECL_FUNCTION_CODE (fndecl))
     749                 :            :         {
     750                 :     256692 :         case BUILT_IN_TM_COMMIT:
     751                 :     256692 :         case BUILT_IN_TM_COMMIT_EH:
     752                 :     256692 :         case BUILT_IN_TM_ABORT:
     753                 :     256692 :         case BUILT_IN_TM_IRREVOCABLE:
     754                 :     256692 :         case BUILT_IN_TM_GETTMCLONE_IRR:
     755                 :     256692 :         case BUILT_IN_TM_MEMCPY:
     756                 :     256692 :         case BUILT_IN_TM_MEMMOVE:
     757                 :     256692 :         case BUILT_IN_TM_MEMSET:
     758                 :     256692 :         CASE_BUILT_IN_TM_STORE (1):
     759                 :     256692 :         CASE_BUILT_IN_TM_STORE (2):
     760                 :     256692 :         CASE_BUILT_IN_TM_STORE (4):
     761                 :     256692 :         CASE_BUILT_IN_TM_STORE (8):
     762                 :     256692 :         CASE_BUILT_IN_TM_STORE (FLOAT):
     763                 :     256692 :         CASE_BUILT_IN_TM_STORE (DOUBLE):
     764                 :     256692 :         CASE_BUILT_IN_TM_STORE (LDOUBLE):
     765                 :     256692 :         CASE_BUILT_IN_TM_STORE (M64):
     766                 :     256692 :         CASE_BUILT_IN_TM_STORE (M128):
     767                 :     256692 :         CASE_BUILT_IN_TM_STORE (M256):
     768                 :     256692 :         CASE_BUILT_IN_TM_LOAD (1):
     769                 :     256692 :         CASE_BUILT_IN_TM_LOAD (2):
     770                 :     256692 :         CASE_BUILT_IN_TM_LOAD (4):
     771                 :     256692 :         CASE_BUILT_IN_TM_LOAD (8):
     772                 :     256692 :         CASE_BUILT_IN_TM_LOAD (FLOAT):
     773                 :     256692 :         CASE_BUILT_IN_TM_LOAD (DOUBLE):
     774                 :     256692 :         CASE_BUILT_IN_TM_LOAD (LDOUBLE):
     775                 :     256692 :         CASE_BUILT_IN_TM_LOAD (M64):
     776                 :     256692 :         CASE_BUILT_IN_TM_LOAD (M128):
     777                 :     256692 :         CASE_BUILT_IN_TM_LOAD (M256):
     778                 :     256692 :         case BUILT_IN_TM_LOG:
     779                 :     256692 :         case BUILT_IN_TM_LOG_1:
     780                 :     256692 :         case BUILT_IN_TM_LOG_2:
     781                 :     256692 :         case BUILT_IN_TM_LOG_4:
     782                 :     256692 :         case BUILT_IN_TM_LOG_8:
     783                 :     256692 :         case BUILT_IN_TM_LOG_FLOAT:
     784                 :     256692 :         case BUILT_IN_TM_LOG_DOUBLE:
     785                 :     256692 :         case BUILT_IN_TM_LOG_LDOUBLE:
     786                 :     256692 :         case BUILT_IN_TM_LOG_M64:
     787                 :     256692 :         case BUILT_IN_TM_LOG_M128:
     788                 :     256692 :         case BUILT_IN_TM_LOG_M256:
     789                 :     256692 :           return true;
     790                 :            :         default:
     791                 :            :           break;
     792                 :            :         }
     793                 :            :     }
     794                 :            :   return false;
     795                 :            : }
     796                 :            : 
     797                 :            : /* Detect flags (function attributes) from the function decl or type node.  */
     798                 :            : 
     799                 :            : int
     800                 : 3582380000 : flags_from_decl_or_type (const_tree exp)
     801                 :            : {
     802                 : 3582380000 :   int flags = 0;
     803                 :            : 
     804                 : 3582380000 :   if (DECL_P (exp))
     805                 :            :     {
     806                 :            :       /* The function exp may have the `malloc' attribute.  */
     807                 : 1835610000 :       if (DECL_IS_MALLOC (exp))
     808                 :   30366800 :         flags |= ECF_MALLOC;
     809                 :            : 
     810                 :            :       /* The function exp may have the `returns_twice' attribute.  */
     811                 : 1835610000 :       if (DECL_IS_RETURNS_TWICE (exp))
     812                 :      44300 :         flags |= ECF_RETURNS_TWICE;
     813                 :            : 
     814                 :            :       /* Process the pure and const attributes.  */
     815                 : 1835610000 :       if (TREE_READONLY (exp))
     816                 :   74249600 :         flags |= ECF_CONST;
     817                 : 1835610000 :       if (DECL_PURE_P (exp))
     818                 :   59607300 :         flags |= ECF_PURE;
     819                 : 1835610000 :       if (DECL_LOOPING_CONST_OR_PURE_P (exp))
     820                 :    8303270 :         flags |= ECF_LOOPING_CONST_OR_PURE;
     821                 :            : 
     822                 : 1835610000 :       if (DECL_IS_NOVOPS (exp))
     823                 :     312867 :         flags |= ECF_NOVOPS;
     824                 : 1835610000 :       if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp)))
     825                 :  221745000 :         flags |= ECF_LEAF;
     826                 : 1835610000 :       if (lookup_attribute ("cold", DECL_ATTRIBUTES (exp)))
     827                 :   88522300 :         flags |= ECF_COLD;
     828                 :            : 
     829                 : 1835610000 :       if (TREE_NOTHROW (exp))
     830                 :  581458000 :         flags |= ECF_NOTHROW;
     831                 :            : 
     832                 : 1835610000 :       if (flag_tm)
     833                 :            :         {
     834                 :     668801 :           if (is_tm_builtin (exp))
     835                 :     273937 :             flags |= ECF_TM_BUILTIN;
     836                 :     394864 :           else if ((flags & (ECF_CONST|ECF_NOVOPS)) != 0
     837                 :     781260 :                    || lookup_attribute ("transaction_pure",
     838                 :     386396 :                                         TYPE_ATTRIBUTES (TREE_TYPE (exp))))
     839                 :      90008 :             flags |= ECF_TM_PURE;
     840                 :            :         }
     841                 :            : 
     842                 : 1835610000 :       flags = special_function_p (exp, flags);
     843                 :            :     }
     844                 : 1746770000 :   else if (TYPE_P (exp))
     845                 :            :     {
     846                 : 1746770000 :       if (TYPE_READONLY (exp))
     847                 :   15298500 :         flags |= ECF_CONST;
     848                 :            : 
     849                 : 1746770000 :       if (flag_tm
     850                 : 1746770000 :           && ((flags & ECF_CONST) != 0
     851                 :     635847 :               || lookup_attribute ("transaction_pure", TYPE_ATTRIBUTES (exp))))
     852                 :      79764 :         flags |= ECF_TM_PURE;
     853                 :            :     }
     854                 :            :   else
     855                 :          0 :     gcc_unreachable ();
     856                 :            : 
     857                 : 3582380000 :   if (TREE_THIS_VOLATILE (exp))
     858                 :            :     {
     859                 :  269435000 :       flags |= ECF_NORETURN;
     860                 :  269435000 :       if (flags & (ECF_CONST|ECF_PURE))
     861                 :    8524150 :         flags |= ECF_LOOPING_CONST_OR_PURE;
     862                 :            :     }
     863                 :            : 
     864                 : 3582380000 :   return flags;
     865                 :            : }
     866                 :            : 
     867                 :            : /* Detect flags from a CALL_EXPR.  */
     868                 :            : 
     869                 :            : int
     870                 :   84209900 : call_expr_flags (const_tree t)
     871                 :            : {
     872                 :   84209900 :   int flags;
     873                 :   84209900 :   tree decl = get_callee_fndecl (t);
     874                 :            : 
     875                 :   84209900 :   if (decl)
     876                 :   81028500 :     flags = flags_from_decl_or_type (decl);
     877                 :    3181370 :   else if (CALL_EXPR_FN (t) == NULL_TREE)
     878                 :     114370 :     flags = internal_fn_flags (CALL_EXPR_IFN (t));
     879                 :            :   else
     880                 :            :     {
     881                 :    3067000 :       tree type = TREE_TYPE (CALL_EXPR_FN (t));
     882                 :    3067000 :       if (type && TREE_CODE (type) == POINTER_TYPE)
     883                 :    1986430 :         flags = flags_from_decl_or_type (TREE_TYPE (type));
     884                 :            :       else
     885                 :            :         flags = 0;
     886                 :    3067000 :       if (CALL_EXPR_BY_DESCRIPTOR (t))
     887                 :          0 :         flags |= ECF_BY_DESCRIPTOR;
     888                 :            :     }
     889                 :            : 
     890                 :   84209900 :   return flags;
     891                 :            : }
     892                 :            : 
     893                 :            : /* Return true if ARG should be passed by invisible reference.  */
     894                 :            : 
     895                 :            : bool
     896                 :   13455500 : pass_by_reference (CUMULATIVE_ARGS *ca, function_arg_info arg)
     897                 :            : {
     898                 :   13455500 :   if (tree type = arg.type)
     899                 :            :     {
     900                 :            :       /* If this type contains non-trivial constructors, then it is
     901                 :            :          forbidden for the middle-end to create any new copies.  */
     902                 :   13302700 :       if (TREE_ADDRESSABLE (type))
     903                 :            :         return true;
     904                 :            : 
     905                 :            :       /* GCC post 3.4 passes *all* variable sized types by reference.  */
     906                 :   13302600 :       if (!TYPE_SIZE (type) || !poly_int_tree_p (TYPE_SIZE (type)))
     907                 :            :         return true;
     908                 :            : 
     909                 :            :       /* If a record type should be passed the same as its first (and only)
     910                 :            :          member, use the type and mode of that member.  */
     911                 :   13302200 :       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
     912                 :            :         {
     913                 :         18 :           arg.type = TREE_TYPE (first_field (type));
     914                 :         18 :           arg.mode = TYPE_MODE (arg.type);
     915                 :            :         }
     916                 :            :     }
     917                 :            : 
     918                 :   13454900 :   return targetm.calls.pass_by_reference (pack_cumulative_args (ca), arg);
     919                 :            : }
     920                 :            : 
     921                 :            : /* Return true if TYPE should be passed by reference when passed to
     922                 :            :    the "..." arguments of a function.  */
     923                 :            : 
     924                 :            : bool
     925                 :      35824 : pass_va_arg_by_reference (tree type)
     926                 :            : {
     927                 :      35824 :   return pass_by_reference (NULL, function_arg_info (type, /*named=*/false));
     928                 :            : }
     929                 :            : 
     930                 :            : /* Decide whether ARG, which occurs in the state described by CA,
     931                 :            :    should be passed by reference.  Return true if so and update
     932                 :            :    ARG accordingly.  */
     933                 :            : 
     934                 :            : bool
     935                 :    5851530 : apply_pass_by_reference_rules (CUMULATIVE_ARGS *ca, function_arg_info &arg)
     936                 :            : {
     937                 :    5851530 :   if (pass_by_reference (ca, arg))
     938                 :            :     {
     939                 :        195 :       arg.type = build_pointer_type (arg.type);
     940                 :        195 :       arg.mode = TYPE_MODE (arg.type);
     941                 :        195 :       arg.pass_by_reference = true;
     942                 :        195 :       return true;
     943                 :            :     }
     944                 :            :   return false;
     945                 :            : }
     946                 :            : 
     947                 :            : /* Return true if ARG, which is passed by reference, should be callee
     948                 :            :    copied instead of caller copied.  */
     949                 :            : 
     950                 :            : bool
     951                 :        379 : reference_callee_copied (CUMULATIVE_ARGS *ca, const function_arg_info &arg)
     952                 :            : {
     953                 :        379 :   if (arg.type && TREE_ADDRESSABLE (arg.type))
     954                 :            :     return false;
     955                 :        379 :   return targetm.calls.callee_copies (pack_cumulative_args (ca), arg);
     956                 :            : }
     957                 :            : 
     958                 :            : 
     959                 :            : /* Precompute all register parameters as described by ARGS, storing values
     960                 :            :    into fields within the ARGS array.
     961                 :            : 
     962                 :            :    NUM_ACTUALS indicates the total number elements in the ARGS array.
     963                 :            : 
     964                 :            :    Set REG_PARM_SEEN if we encounter a register parameter.  */
     965                 :            : 
     966                 :            : static void
     967                 :    3876220 : precompute_register_parameters (int num_actuals, struct arg_data *args,
     968                 :            :                                 int *reg_parm_seen)
     969                 :            : {
     970                 :    3876220 :   int i;
     971                 :            : 
     972                 :    3876220 :   *reg_parm_seen = 0;
     973                 :            : 
     974                 :   11291600 :   for (i = 0; i < num_actuals; i++)
     975                 :    7415420 :     if (args[i].reg != 0 && ! args[i].pass_on_stack)
     976                 :            :       {
     977                 :    5829110 :         *reg_parm_seen = 1;
     978                 :            : 
     979                 :    5829110 :         if (args[i].value == 0)
     980                 :            :           {
     981                 :    5829110 :             push_temp_slots ();
     982                 :    5829110 :             args[i].value = expand_normal (args[i].tree_value);
     983                 :    5829110 :             preserve_temp_slots (args[i].value);
     984                 :    5829110 :             pop_temp_slots ();
     985                 :            :           }
     986                 :            : 
     987                 :            :         /* If we are to promote the function arg to a wider mode,
     988                 :            :            do it now.  */
     989                 :            : 
     990                 :    5829110 :         if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
     991                 :         28 :           args[i].value
     992                 :         28 :             = convert_modes (args[i].mode,
     993                 :         28 :                              TYPE_MODE (TREE_TYPE (args[i].tree_value)),
     994                 :            :                              args[i].value, args[i].unsignedp);
     995                 :            : 
     996                 :            :         /* If the value is a non-legitimate constant, force it into a
     997                 :            :            pseudo now.  TLS symbols sometimes need a call to resolve.  */
     998                 :    5829110 :         if (CONSTANT_P (args[i].value)
     999                 :    5829110 :             && !targetm.legitimate_constant_p (args[i].mode, args[i].value))
    1000                 :       2331 :           args[i].value = force_reg (args[i].mode, args[i].value);
    1001                 :            : 
    1002                 :            :         /* If we're going to have to load the value by parts, pull the
    1003                 :            :            parts into pseudos.  The part extraction process can involve
    1004                 :            :            non-trivial computation.  */
    1005                 :    5829110 :         if (GET_CODE (args[i].reg) == PARALLEL)
    1006                 :            :           {
    1007                 :     175715 :             tree type = TREE_TYPE (args[i].tree_value);
    1008                 :     175715 :             args[i].parallel_value
    1009                 :     175715 :               = emit_group_load_into_temps (args[i].reg, args[i].value,
    1010                 :     175715 :                                             type, int_size_in_bytes (type));
    1011                 :            :           }
    1012                 :            : 
    1013                 :            :         /* If the value is expensive, and we are inside an appropriately
    1014                 :            :            short loop, put the value into a pseudo and then put the pseudo
    1015                 :            :            into the hard reg.
    1016                 :            : 
    1017                 :            :            For small register classes, also do this if this call uses
    1018                 :            :            register parameters.  This is to avoid reload conflicts while
    1019                 :            :            loading the parameters registers.  */
    1020                 :            : 
    1021                 :    2941730 :         else if ((! (REG_P (args[i].value)
    1022                 :            :                      || (GET_CODE (args[i].value) == SUBREG
    1023                 :      18536 :                          && REG_P (SUBREG_REG (args[i].value)))))
    1024                 :    2923190 :                  && args[i].mode != BLKmode
    1025                 :    2921990 :                  && (set_src_cost (args[i].value, args[i].mode,
    1026                 :    2921990 :                                    optimize_insn_for_speed_p ())
    1027                 :            :                      > COSTS_N_INSNS (1))
    1028                 :    5942900 :                  && ((*reg_parm_seen
    1029                 :     289506 :                       && targetm.small_register_classes_for_mode_p (args[i].mode))
    1030                 :          0 :                      || optimize))
    1031                 :     289506 :           args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
    1032                 :            :       }
    1033                 :    3876220 : }
    1034                 :            : 
    1035                 :            : #ifdef REG_PARM_STACK_SPACE
    1036                 :            : 
    1037                 :            :   /* The argument list is the property of the called routine and it
    1038                 :            :      may clobber it.  If the fixed area has been used for previous
    1039                 :            :      parameters, we must save and restore it.  */
    1040                 :            : 
    1041                 :            : static rtx
    1042                 :      20538 : save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
    1043                 :            : {
    1044                 :      20538 :   unsigned int low;
    1045                 :      20538 :   unsigned int high;
    1046                 :            : 
    1047                 :            :   /* Compute the boundary of the area that needs to be saved, if any.  */
    1048                 :      20538 :   high = reg_parm_stack_space;
    1049                 :      20538 :   if (ARGS_GROW_DOWNWARD)
    1050                 :            :     high += 1;
    1051                 :            : 
    1052                 :      20538 :   if (high > highest_outgoing_arg_in_use)
    1053                 :            :     high = highest_outgoing_arg_in_use;
    1054                 :            : 
    1055                 :     211258 :   for (low = 0; low < high; low++)
    1056                 :     190720 :     if (stack_usage_map[low] != 0 || low >= stack_usage_watermark)
    1057                 :            :       {
    1058                 :          0 :         int num_to_save;
    1059                 :          0 :         machine_mode save_mode;
    1060                 :          0 :         int delta;
    1061                 :          0 :         rtx addr;
    1062                 :          0 :         rtx stack_area;
    1063                 :          0 :         rtx save_area;
    1064                 :            : 
    1065                 :          0 :         while (stack_usage_map[--high] == 0)
    1066                 :            :           ;
    1067                 :            : 
    1068                 :          0 :         *low_to_save = low;
    1069                 :          0 :         *high_to_save = high;
    1070                 :            : 
    1071                 :          0 :         num_to_save = high - low + 1;
    1072                 :            : 
    1073                 :            :         /* If we don't have the required alignment, must do this
    1074                 :            :            in BLKmode.  */
    1075                 :          0 :         scalar_int_mode imode;
    1076                 :          0 :         if (int_mode_for_size (num_to_save * BITS_PER_UNIT, 1).exists (&imode)
    1077                 :          0 :             && (low & (MIN (GET_MODE_SIZE (imode),
    1078                 :          0 :                             BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)) == 0)
    1079                 :          0 :           save_mode = imode;
    1080                 :            :         else
    1081                 :            :           save_mode = BLKmode;
    1082                 :            : 
    1083                 :          0 :         if (ARGS_GROW_DOWNWARD)
    1084                 :            :           delta = -high;
    1085                 :            :         else
    1086                 :          0 :           delta = low;
    1087                 :            : 
    1088                 :          0 :         addr = plus_constant (Pmode, argblock, delta);
    1089                 :          0 :         stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
    1090                 :            : 
    1091                 :          0 :         set_mem_align (stack_area, PARM_BOUNDARY);
    1092                 :          0 :         if (save_mode == BLKmode)
    1093                 :            :           {
    1094                 :          0 :             save_area = assign_stack_temp (BLKmode, num_to_save);
    1095                 :          0 :             emit_block_move (validize_mem (save_area), stack_area,
    1096                 :            :                              GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
    1097                 :            :           }
    1098                 :            :         else
    1099                 :            :           {
    1100                 :          0 :             save_area = gen_reg_rtx (save_mode);
    1101                 :          0 :             emit_move_insn (save_area, stack_area);
    1102                 :            :           }
    1103                 :            : 
    1104                 :          0 :         return save_area;
    1105                 :            :       }
    1106                 :            : 
    1107                 :            :   return NULL_RTX;
    1108                 :            : }
    1109                 :            : 
    1110                 :            : static void
    1111                 :          0 : restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
    1112                 :            : {
    1113                 :          0 :   machine_mode save_mode = GET_MODE (save_area);
    1114                 :          0 :   int delta;
    1115                 :          0 :   rtx addr, stack_area;
    1116                 :            : 
    1117                 :          0 :   if (ARGS_GROW_DOWNWARD)
    1118                 :            :     delta = -high_to_save;
    1119                 :            :   else
    1120                 :          0 :     delta = low_to_save;
    1121                 :            : 
    1122                 :          0 :   addr = plus_constant (Pmode, argblock, delta);
    1123                 :          0 :   stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
    1124                 :          0 :   set_mem_align (stack_area, PARM_BOUNDARY);
    1125                 :            : 
    1126                 :          0 :   if (save_mode != BLKmode)
    1127                 :          0 :     emit_move_insn (stack_area, save_area);
    1128                 :            :   else
    1129                 :          0 :     emit_block_move (stack_area, validize_mem (save_area),
    1130                 :          0 :                      GEN_INT (high_to_save - low_to_save + 1),
    1131                 :            :                      BLOCK_OP_CALL_PARM);
    1132                 :          0 : }
    1133                 :            : #endif /* REG_PARM_STACK_SPACE */
    1134                 :            : 
    1135                 :            : /* If any elements in ARGS refer to parameters that are to be passed in
    1136                 :            :    registers, but not in memory, and whose alignment does not permit a
    1137                 :            :    direct copy into registers.  Copy the values into a group of pseudos
    1138                 :            :    which we will later copy into the appropriate hard registers.
    1139                 :            : 
    1140                 :            :    Pseudos for each unaligned argument will be stored into the array
    1141                 :            :    args[argnum].aligned_regs.  The caller is responsible for deallocating
    1142                 :            :    the aligned_regs array if it is nonzero.  */
    1143                 :            : 
    1144                 :            : static void
    1145                 :          0 : store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
    1146                 :            : {
    1147                 :          0 :   int i, j;
    1148                 :            : 
    1149                 :          0 :   for (i = 0; i < num_actuals; i++)
    1150                 :          0 :     if (args[i].reg != 0 && ! args[i].pass_on_stack
    1151                 :          0 :         && GET_CODE (args[i].reg) != PARALLEL
    1152                 :          0 :         && args[i].mode == BLKmode
    1153                 :          0 :         && MEM_P (args[i].value)
    1154                 :          0 :         && (MEM_ALIGN (args[i].value)
    1155                 :          0 :             < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
    1156                 :            :       {
    1157                 :          0 :         int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
    1158                 :          0 :         int endian_correction = 0;
    1159                 :            : 
    1160                 :          0 :         if (args[i].partial)
    1161                 :            :           {
    1162                 :          0 :             gcc_assert (args[i].partial % UNITS_PER_WORD == 0);
    1163                 :          0 :             args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD;
    1164                 :            :           }
    1165                 :            :         else
    1166                 :            :           {
    1167                 :          0 :             args[i].n_aligned_regs
    1168                 :          0 :               = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
    1169                 :            :           }
    1170                 :            : 
    1171                 :          0 :         args[i].aligned_regs = XNEWVEC (rtx, args[i].n_aligned_regs);
    1172                 :            : 
    1173                 :            :         /* Structures smaller than a word are normally aligned to the
    1174                 :            :            least significant byte.  On a BYTES_BIG_ENDIAN machine,
    1175                 :            :            this means we must skip the empty high order bytes when
    1176                 :            :            calculating the bit offset.  */
    1177                 :          0 :         if (bytes < UNITS_PER_WORD
    1178                 :            : #ifdef BLOCK_REG_PADDING
    1179                 :            :             && (BLOCK_REG_PADDING (args[i].mode,
    1180                 :            :                                    TREE_TYPE (args[i].tree_value), 1)
    1181                 :            :                 == PAD_DOWNWARD)
    1182                 :            : #else
    1183                 :            :             && BYTES_BIG_ENDIAN
    1184                 :            : #endif
    1185                 :            :             )
    1186                 :            :           endian_correction = BITS_PER_WORD - bytes * BITS_PER_UNIT;
    1187                 :            : 
    1188                 :          0 :         for (j = 0; j < args[i].n_aligned_regs; j++)
    1189                 :            :           {
    1190                 :          0 :             rtx reg = gen_reg_rtx (word_mode);
    1191                 :          0 :             rtx word = operand_subword_force (args[i].value, j, BLKmode);
    1192                 :          0 :             int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
    1193                 :            : 
    1194                 :          0 :             args[i].aligned_regs[j] = reg;
    1195                 :          0 :             word = extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
    1196                 :            :                                       word_mode, word_mode, false, NULL);
    1197                 :            : 
    1198                 :            :             /* There is no need to restrict this code to loading items
    1199                 :            :                in TYPE_ALIGN sized hunks.  The bitfield instructions can
    1200                 :            :                load up entire word sized registers efficiently.
    1201                 :            : 
    1202                 :            :                ??? This may not be needed anymore.
    1203                 :            :                We use to emit a clobber here but that doesn't let later
    1204                 :            :                passes optimize the instructions we emit.  By storing 0 into
    1205                 :            :                the register later passes know the first AND to zero out the
    1206                 :            :                bitfield being set in the register is unnecessary.  The store
    1207                 :            :                of 0 will be deleted as will at least the first AND.  */
    1208                 :            : 
    1209                 :          0 :             emit_move_insn (reg, const0_rtx);
    1210                 :            : 
    1211                 :          0 :             bytes -= bitsize / BITS_PER_UNIT;
    1212                 :          0 :             store_bit_field (reg, bitsize, endian_correction, 0, 0,
    1213                 :            :                              word_mode, word, false);
    1214                 :            :           }
    1215                 :            :       }
    1216                 :          0 : }
    1217                 :            : 
    1218                 :            : /* The limit set by -Walloc-larger-than=.  */
    1219                 :            : static GTY(()) tree alloc_object_size_limit;
    1220                 :            : 
    1221                 :            : /* Initialize ALLOC_OBJECT_SIZE_LIMIT based on the -Walloc-size-larger-than=
    1222                 :            :    setting if the option is specified, or to the maximum object size if it
    1223                 :            :    is not.  Return the initialized value.  */
    1224                 :            : 
    1225                 :            : static tree
    1226                 :      27832 : alloc_max_size (void)
    1227                 :            : {
    1228                 :      27832 :   if (alloc_object_size_limit)
    1229                 :            :     return alloc_object_size_limit;
    1230                 :            : 
    1231                 :       7301 :   HOST_WIDE_INT limit = warn_alloc_size_limit;
    1232                 :       7301 :   if (limit == HOST_WIDE_INT_MAX)
    1233                 :       7276 :     limit = tree_to_shwi (TYPE_MAX_VALUE (ptrdiff_type_node));
    1234                 :            : 
    1235                 :       7301 :   alloc_object_size_limit = build_int_cst (size_type_node, limit);
    1236                 :            : 
    1237                 :       7301 :   return alloc_object_size_limit;
    1238                 :            : }
    1239                 :            : 
    1240                 :            : /* Return true when EXP's range can be determined and set RANGE[] to it
    1241                 :            :    after adjusting it if necessary to make EXP a represents a valid size
    1242                 :            :    of object, or a valid size argument to an allocation function declared
    1243                 :            :    with attribute alloc_size (whose argument may be signed), or to a string
    1244                 :            :    manipulation function like memset.  When ALLOW_ZERO is true, allow
    1245                 :            :    returning a range of [0, 0] for a size in an anti-range [1, N] where
    1246                 :            :    N > PTRDIFF_MAX.  A zero range is a (nearly) invalid argument to
    1247                 :            :    allocation functions like malloc but it is a valid argument to
    1248                 :            :    functions like memset.  */
    1249                 :            : 
    1250                 :            : bool
    1251                 :     386424 : get_size_range (tree exp, tree range[2], bool allow_zero /* = false */)
    1252                 :            : {
    1253                 :     386424 :   if (!exp)
    1254                 :            :     return false;
    1255                 :            : 
    1256                 :     386424 :   if (tree_fits_uhwi_p (exp))
    1257                 :            :     {
    1258                 :            :       /* EXP is a constant.  */
    1259                 :     260163 :       range[0] = range[1] = exp;
    1260                 :     260163 :       return true;
    1261                 :            :     }
    1262                 :            : 
    1263                 :     126261 :   tree exptype = TREE_TYPE (exp);
    1264                 :     126261 :   bool integral = INTEGRAL_TYPE_P (exptype);
    1265                 :            : 
    1266                 :     126261 :   wide_int min, max;
    1267                 :     126261 :   enum value_range_kind range_type;
    1268                 :            : 
    1269                 :     126261 :   if (integral)
    1270                 :     126239 :     range_type = determine_value_range (exp, &min, &max);
    1271                 :            :   else
    1272                 :            :     range_type = VR_VARYING;
    1273                 :            : 
    1274                 :     126239 :   if (range_type == VR_VARYING)
    1275                 :            :     {
    1276                 :      80213 :       if (integral)
    1277                 :            :         {
    1278                 :            :           /* Use the full range of the type of the expression when
    1279                 :            :              no value range information is available.  */
    1280                 :      80191 :           range[0] = TYPE_MIN_VALUE (exptype);
    1281                 :      80191 :           range[1] = TYPE_MAX_VALUE (exptype);
    1282                 :      80191 :           return true;
    1283                 :            :         }
    1284                 :            : 
    1285                 :         22 :       range[0] = NULL_TREE;
    1286                 :         22 :       range[1] = NULL_TREE;
    1287                 :         22 :       return false;
    1288                 :            :     }
    1289                 :            : 
    1290                 :      46048 :   unsigned expprec = TYPE_PRECISION (exptype);
    1291                 :            : 
    1292                 :      46048 :   bool signed_p = !TYPE_UNSIGNED (exptype);
    1293                 :            : 
    1294                 :      46048 :   if (range_type == VR_ANTI_RANGE)
    1295                 :            :     {
    1296                 :       9044 :       if (signed_p)
    1297                 :            :         {
    1298                 :         42 :           if (wi::les_p (max, 0))
    1299                 :            :             {
    1300                 :            :               /* EXP is not in a strictly negative range.  That means
    1301                 :            :                  it must be in some (not necessarily strictly) positive
    1302                 :            :                  range which includes zero.  Since in signed to unsigned
    1303                 :            :                  conversions negative values end up converted to large
    1304                 :            :                  positive values, and otherwise they are not valid sizes,
    1305                 :            :                  the resulting range is in both cases [0, TYPE_MAX].  */
    1306                 :          9 :               min = wi::zero (expprec);
    1307                 :          9 :               max = wi::to_wide (TYPE_MAX_VALUE (exptype));
    1308                 :            :             }
    1309                 :         33 :           else if (wi::les_p (min - 1, 0))
    1310                 :            :             {
    1311                 :            :               /* EXP is not in a negative-positive range.  That means EXP
    1312                 :            :                  is either negative, or greater than max.  Since negative
    1313                 :            :                  sizes are invalid make the range [MAX + 1, TYPE_MAX].  */
    1314                 :         27 :               min = max + 1;
    1315                 :         27 :               max = wi::to_wide (TYPE_MAX_VALUE (exptype));
    1316                 :            :             }
    1317                 :            :           else
    1318                 :            :             {
    1319                 :          6 :               max = min - 1;
    1320                 :          6 :               min = wi::zero (expprec);
    1321                 :            :             }
    1322                 :            :         }
    1323                 :      17933 :       else if (wi::eq_p (0, min - 1))
    1324                 :            :         {
    1325                 :            :           /* EXP is unsigned and not in the range [1, MAX].  That means
    1326                 :            :              it's either zero or greater than MAX.  Even though 0 would
    1327                 :            :              normally be detected by -Walloc-zero, unless ALLOW_ZERO
    1328                 :            :              is true, set the range to [MAX, TYPE_MAX] so that when MAX
    1329                 :            :              is greater than the limit the whole range is diagnosed.  */
    1330                 :         71 :           if (allow_zero)
    1331                 :         28 :             min = max = wi::zero (expprec);
    1332                 :            :           else
    1333                 :            :             {
    1334                 :         43 :               min = max + 1;
    1335                 :         43 :               max = wi::to_wide (TYPE_MAX_VALUE (exptype));
    1336                 :            :             }
    1337                 :            :         }
    1338                 :            :       else
    1339                 :            :         {
    1340                 :       8931 :           max = min - 1;
    1341                 :       8931 :           min = wi::zero (expprec);
    1342                 :            :         }
    1343                 :            :     }
    1344                 :            : 
    1345                 :      46048 :   range[0] = wide_int_to_tree (exptype, min);
    1346                 :      46048 :   range[1] = wide_int_to_tree (exptype, max);
    1347                 :            : 
    1348                 :      46048 :   return true;
    1349                 :            : }
    1350                 :            : 
    1351                 :            : /* Diagnose a call EXP to function FN decorated with attribute alloc_size
    1352                 :            :    whose argument numbers given by IDX with values given by ARGS exceed
    1353                 :            :    the maximum object size or cause an unsigned oveflow (wrapping) when
    1354                 :            :    multiplied.  FN is null when EXP is a call via a function pointer.
    1355                 :            :    When ARGS[0] is null the function does nothing.  ARGS[1] may be null
    1356                 :            :    for functions like malloc, and non-null for those like calloc that
    1357                 :            :    are decorated with a two-argument attribute alloc_size.  */
    1358                 :            : 
    1359                 :            : void
    1360                 :      27832 : maybe_warn_alloc_args_overflow (tree fn, tree exp, tree args[2], int idx[2])
    1361                 :            : {
    1362                 :            :   /* The range each of the (up to) two arguments is known to be in.  */
    1363                 :      27832 :   tree argrange[2][2] = { { NULL_TREE, NULL_TREE }, { NULL_TREE, NULL_TREE } };
    1364                 :            : 
    1365                 :            :   /* Maximum object size set by -Walloc-size-larger-than= or SIZE_MAX / 2.  */
    1366                 :      27832 :   tree maxobjsize = alloc_max_size ();
    1367                 :            : 
    1368                 :      27832 :   location_t loc = EXPR_LOCATION (exp);
    1369                 :            : 
    1370                 :      55664 :   tree fntype = fn ? TREE_TYPE (fn) : TREE_TYPE (TREE_TYPE (exp));
    1371                 :      27832 :   bool warned = false;
    1372                 :            : 
    1373                 :            :   /* Validate each argument individually.  */
    1374                 :      56322 :   for (unsigned i = 0; i != 2 && args[i]; ++i)
    1375                 :            :     {
    1376                 :      28490 :       if (TREE_CODE (args[i]) == INTEGER_CST)
    1377                 :            :         {
    1378                 :      17716 :           argrange[i][0] = args[i];
    1379                 :      17716 :           argrange[i][1] = args[i];
    1380                 :            : 
    1381                 :      17716 :           if (tree_int_cst_lt (args[i], integer_zero_node))
    1382                 :            :             {
    1383                 :         24 :               warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    1384                 :            :                                    "%Kargument %i value %qE is negative",
    1385                 :         24 :                                    exp, idx[i] + 1, args[i]);
    1386                 :            :             }
    1387                 :      17692 :           else if (integer_zerop (args[i]))
    1388                 :            :             {
    1389                 :            :               /* Avoid issuing -Walloc-zero for allocation functions other
    1390                 :            :                  than __builtin_alloca that are declared with attribute
    1391                 :            :                  returns_nonnull because there's no portability risk.  This
    1392                 :            :                  avoids warning for such calls to libiberty's xmalloc and
    1393                 :            :                  friends.
    1394                 :            :                  Also avoid issuing the warning for calls to function named
    1395                 :            :                  "alloca".  */
    1396                 :        475 :               if (fn && fndecl_built_in_p (fn, BUILT_IN_ALLOCA)
    1397                 :        490 :                   ? IDENTIFIER_LENGTH (DECL_NAME (fn)) != 6
    1398                 :        245 :                   : !lookup_attribute ("returns_nonnull",
    1399                 :        245 :                                        TYPE_ATTRIBUTES (fntype)))
    1400                 :        238 :                 warned = warning_at (loc, OPT_Walloc_zero,
    1401                 :            :                                      "%Kargument %i value is zero",
    1402                 :        238 :                                      exp, idx[i] + 1);
    1403                 :            :             }
    1404                 :      17447 :           else if (tree_int_cst_lt (maxobjsize, args[i]))
    1405                 :            :             {
    1406                 :            :               /* G++ emits calls to ::operator new[](SIZE_MAX) in C++98
    1407                 :            :                  mode and with -fno-exceptions as a way to indicate array
    1408                 :            :                  size overflow.  There's no good way to detect C++98 here
    1409                 :            :                  so avoid diagnosing these calls for all C++ modes.  */
    1410                 :         88 :               if (i == 0
    1411                 :         81 :                   && fn
    1412                 :         65 :                   && !args[1]
    1413                 :         59 :                   && lang_GNU_CXX ()
    1414                 :          7 :                   && DECL_IS_OPERATOR_NEW_P (fn)
    1415                 :         88 :                   && integer_all_onesp (args[i]))
    1416                 :          7 :                 continue;
    1417                 :            : 
    1418                 :         74 :               warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    1419                 :            :                                    "%Kargument %i value %qE exceeds "
    1420                 :            :                                    "maximum object size %E",
    1421                 :         74 :                                    exp, idx[i] + 1, args[i], maxobjsize);
    1422                 :            :             }
    1423                 :            :         }
    1424                 :      10774 :       else if (TREE_CODE (args[i]) == SSA_NAME
    1425                 :      10774 :                && get_size_range (args[i], argrange[i]))
    1426                 :            :         {
    1427                 :            :           /* Verify that the argument's range is not negative (including
    1428                 :            :              upper bound of zero).  */
    1429                 :      10762 :           if (tree_int_cst_lt (argrange[i][0], integer_zero_node)
    1430                 :      10762 :               && tree_int_cst_le (argrange[i][1], integer_zero_node))
    1431                 :            :             {
    1432                 :         31 :               warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    1433                 :            :                                    "%Kargument %i range [%E, %E] is negative",
    1434                 :         31 :                                    exp, idx[i] + 1,
    1435                 :            :                                    argrange[i][0], argrange[i][1]);
    1436                 :            :             }
    1437                 :      10731 :           else if (tree_int_cst_lt (maxobjsize, argrange[i][0]))
    1438                 :            :             {
    1439                 :         31 :               warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    1440                 :            :                                    "%Kargument %i range [%E, %E] exceeds "
    1441                 :            :                                    "maximum object size %E",
    1442                 :         31 :                                    exp, idx[i] + 1,
    1443                 :            :                                    argrange[i][0], argrange[i][1],
    1444                 :            :                                    maxobjsize);
    1445                 :            :             }
    1446                 :            :         }
    1447                 :            :     }
    1448                 :            : 
    1449                 :      27832 :   if (!argrange[0])
    1450                 :            :     return;
    1451                 :            : 
    1452                 :            :   /* For a two-argument alloc_size, validate the product of the two
    1453                 :            :      arguments if both of their values or ranges are known.  */
    1454                 :      27615 :   if (!warned && tree_fits_uhwi_p (argrange[0][0])
    1455                 :      27560 :       && argrange[1][0] && tree_fits_uhwi_p (argrange[1][0])
    1456                 :        566 :       && !integer_onep (argrange[0][0])
    1457                 :      28252 :       && !integer_onep (argrange[1][0]))
    1458                 :            :     {
    1459                 :            :       /* Check for overflow in the product of a function decorated with
    1460                 :            :          attribute alloc_size (X, Y).  */
    1461                 :        170 :       unsigned szprec = TYPE_PRECISION (size_type_node);
    1462                 :        170 :       wide_int x = wi::to_wide (argrange[0][0], szprec);
    1463                 :        170 :       wide_int y = wi::to_wide (argrange[1][0], szprec);
    1464                 :            : 
    1465                 :        170 :       wi::overflow_type vflow;
    1466                 :        170 :       wide_int prod = wi::umul (x, y, &vflow);
    1467                 :            : 
    1468                 :        170 :       if (vflow)
    1469                 :          2 :         warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    1470                 :            :                              "%Kproduct %<%E * %E%> of arguments %i and %i "
    1471                 :            :                              "exceeds %<SIZE_MAX%>",
    1472                 :            :                              exp, argrange[0][0], argrange[1][0],
    1473                 :          2 :                              idx[0] + 1, idx[1] + 1);
    1474                 :        168 :       else if (wi::ltu_p (wi::to_wide (maxobjsize, szprec), prod))
    1475                 :         12 :         warned = warning_at (loc, OPT_Walloc_size_larger_than_,
    1476                 :            :                              "%Kproduct %<%E * %E%> of arguments %i and %i "
    1477                 :            :                              "exceeds maximum object size %E",
    1478                 :            :                              exp, argrange[0][0], argrange[1][0],
    1479                 :         12 :                              idx[0] + 1, idx[1] + 1,
    1480                 :            :                              maxobjsize);
    1481                 :            : 
    1482                 :        170 :       if (warned)
    1483                 :            :         {
    1484                 :            :           /* Print the full range of each of the two arguments to make
    1485                 :            :              it clear when it is, in fact, in a range and not constant.  */
    1486                 :         14 :           if (argrange[0][0] != argrange [0][1])
    1487                 :          1 :             inform (loc, "argument %i in the range [%E, %E]",
    1488                 :          1 :                     idx[0] + 1, argrange[0][0], argrange[0][1]);
    1489                 :         14 :           if (argrange[1][0] != argrange [1][1])
    1490                 :          1 :             inform (loc, "argument %i in the range [%E, %E]",
    1491                 :          1 :                     idx[1] + 1, argrange[1][0], argrange[1][1]);
    1492                 :            :         }
    1493                 :            :     }
    1494                 :            : 
    1495                 :      27832 :   if (warned && fn)
    1496                 :            :     {
    1497                 :        206 :       location_t fnloc = DECL_SOURCE_LOCATION (fn);
    1498                 :            : 
    1499                 :        206 :       if (DECL_IS_BUILTIN (fn))
    1500                 :         58 :         inform (loc,
    1501                 :            :                 "in a call to built-in allocation function %qD", fn);
    1502                 :            :       else
    1503                 :        148 :         inform (fnloc,
    1504                 :            :                 "in a call to allocation function %qD declared here", fn);
    1505                 :            :     }
    1506                 :            : }
    1507                 :            : 
    1508                 :            : /* If EXPR refers to a character array or pointer declared attribute
    1509                 :            :    nonstring return a decl for that array or pointer and set *REF to
    1510                 :            :    the referenced enclosing object or pointer.  Otherwise returns
    1511                 :            :    null.  */
    1512                 :            : 
    1513                 :            : tree
    1514                 :     128338 : get_attr_nonstring_decl (tree expr, tree *ref)
    1515                 :            : {
    1516                 :     131278 :   tree decl = expr;
    1517                 :     131278 :   tree var = NULL_TREE;
    1518                 :     131278 :   if (TREE_CODE (decl) == SSA_NAME)
    1519                 :            :     {
    1520                 :      35102 :       gimple *def = SSA_NAME_DEF_STMT (decl);
    1521                 :            : 
    1522                 :      35102 :       if (is_gimple_assign (def))
    1523                 :            :         {
    1524                 :      17306 :           tree_code code = gimple_assign_rhs_code (def);
    1525                 :      17306 :           if (code == ADDR_EXPR
    1526                 :      17306 :               || code == COMPONENT_REF
    1527                 :      10583 :               || code == VAR_DECL)
    1528                 :       8742 :             decl = gimple_assign_rhs1 (def);
    1529                 :            :         }
    1530                 :            :       else
    1531                 :      17796 :         var = SSA_NAME_VAR (decl);
    1532                 :            :     }
    1533                 :            : 
    1534                 :     131278 :   if (TREE_CODE (decl) == ADDR_EXPR)
    1535                 :      15783 :     decl = TREE_OPERAND (decl, 0);
    1536                 :            : 
    1537                 :            :   /* To simplify calling code, store the referenced DECL regardless of
    1538                 :            :      the attribute determined below, but avoid storing the SSA_NAME_VAR
    1539                 :            :      obtained above (it's not useful for dataflow purposes).  */
    1540                 :     131278 :   if (ref)
    1541                 :       5043 :     *ref = decl;
    1542                 :            : 
    1543                 :            :   /* Use the SSA_NAME_VAR that was determined above to see if it's
    1544                 :            :      declared nonstring.  Otherwise drill down into the referenced
    1545                 :            :      DECL.  */
    1546                 :     131278 :   if (var)
    1547                 :            :     decl = var;
    1548                 :     115304 :   else if (TREE_CODE (decl) == ARRAY_REF)
    1549                 :       5749 :     decl = TREE_OPERAND (decl, 0);
    1550                 :     109555 :   else if (TREE_CODE (decl) == COMPONENT_REF)
    1551                 :       6785 :     decl = TREE_OPERAND (decl, 1);
    1552                 :     102770 :   else if (TREE_CODE (decl) == MEM_REF)
    1553                 :       2940 :     return get_attr_nonstring_decl (TREE_OPERAND (decl, 0), ref);
    1554                 :            : 
    1555                 :     128338 :   if (DECL_P (decl)
    1556                 :     168491 :       && lookup_attribute ("nonstring", DECL_ATTRIBUTES (decl)))
    1557                 :       4320 :     return decl;
    1558                 :            : 
    1559                 :            :   return NULL_TREE;
    1560                 :            : }
    1561                 :            : 
    1562                 :            : /* Warn about passing a non-string array/pointer to a function that
    1563                 :            :    expects a nul-terminated string argument.  */
    1564                 :            : 
    1565                 :            : void
    1566                 :    3877620 : maybe_warn_nonstring_arg (tree fndecl, tree exp)
    1567                 :            : {
    1568                 :    3877620 :   if (!fndecl || !fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
    1569                 :    3362140 :     return;
    1570                 :            : 
    1571                 :     709565 :   if (TREE_NO_WARNING (exp) || !warn_stringop_overflow)
    1572                 :            :     return;
    1573                 :            : 
    1574                 :            :   /* Avoid clearly invalid calls (more checking done below).  */
    1575                 :     702711 :   unsigned nargs = call_expr_nargs (exp);
    1576                 :     702711 :   if (!nargs)
    1577                 :            :     return;
    1578                 :            : 
    1579                 :            :   /* The bound argument to a bounded string function like strncpy.  */
    1580                 :     515551 :   tree bound = NULL_TREE;
    1581                 :            : 
    1582                 :            :   /* The longest known or possible string argument to one of the comparison
    1583                 :            :      functions.  If the length is less than the bound it is used instead.
    1584                 :            :      Since the length is only used for warning and not for code generation
    1585                 :            :      disable strict mode in the calls to get_range_strlen below.  */
    1586                 :     515551 :   tree maxlen = NULL_TREE;
    1587                 :            : 
    1588                 :            :   /* It's safe to call "bounded" string functions with a non-string
    1589                 :            :      argument since the functions provide an explicit bound for this
    1590                 :            :      purpose.  The exception is strncat where the bound may refer to
    1591                 :            :      either the destination or the source.  */
    1592                 :     515551 :   int fncode = DECL_FUNCTION_CODE (fndecl);
    1593                 :     515551 :   switch (fncode)
    1594                 :            :     {
    1595                 :            :     case BUILT_IN_STRCMP:
    1596                 :            :     case BUILT_IN_STRNCMP:
    1597                 :            :     case BUILT_IN_STRNCASECMP:
    1598                 :            :       {
    1599                 :            :         /* For these, if one argument refers to one or more of a set
    1600                 :            :            of string constants or arrays of known size, determine
    1601                 :            :            the range of their known or possible lengths and use it
    1602                 :            :            conservatively as the bound for the unbounded function,
    1603                 :            :            and to adjust the range of the bound of the bounded ones.  */
    1604                 :       4705 :         for (unsigned argno = 0;
    1605                 :       9104 :              argno < MIN (nargs, 2)
    1606                 :       9104 :                && !(maxlen && TREE_CODE (maxlen) == INTEGER_CST); argno++)
    1607                 :            :           {
    1608                 :       4705 :             tree arg = CALL_EXPR_ARG (exp, argno);
    1609                 :       4705 :             if (!get_attr_nonstring_decl (arg))
    1610                 :            :               {
    1611                 :       4387 :                 c_strlen_data lendata = { };
    1612                 :            :                 /* Set MAXBOUND to an arbitrary non-null non-integer
    1613                 :            :                    node as a request to have it set to the length of
    1614                 :            :                    the longest string in a PHI.  */
    1615                 :       4387 :                 lendata.maxbound = arg;
    1616                 :       4387 :                 get_range_strlen (arg, &lendata, /* eltsize = */ 1);
    1617                 :       4387 :                 maxlen = lendata.maxbound;
    1618                 :            :               }
    1619                 :            :           }
    1620                 :            :       }
    1621                 :            :       /* Fall through.  */
    1622                 :            : 
    1623                 :       6632 :     case BUILT_IN_STRNCAT:
    1624                 :       6632 :     case BUILT_IN_STPNCPY:
    1625                 :       6632 :     case BUILT_IN_STRNCPY:
    1626                 :       6632 :       if (nargs > 2)
    1627                 :       3731 :         bound = CALL_EXPR_ARG (exp, 2);
    1628                 :            :       break;
    1629                 :            : 
    1630                 :        124 :     case BUILT_IN_STRNDUP:
    1631                 :        124 :       if (nargs > 1)
    1632                 :        124 :         bound = CALL_EXPR_ARG (exp, 1);
    1633                 :            :       break;
    1634                 :            : 
    1635                 :        253 :     case BUILT_IN_STRNLEN:
    1636                 :        253 :       {
    1637                 :        253 :         tree arg = CALL_EXPR_ARG (exp, 0);
    1638                 :        253 :         if (!get_attr_nonstring_decl (arg))
    1639                 :            :           {
    1640                 :        210 :             c_strlen_data lendata = { };
    1641                 :            :             /* Set MAXBOUND to an arbitrary non-null non-integer
    1642                 :            :                node as a request to have it set to the length of
    1643                 :            :                the longest string in a PHI.  */
    1644                 :        210 :             lendata.maxbound = arg;
    1645                 :        210 :             get_range_strlen (arg, &lendata, /* eltsize = */ 1);
    1646                 :        210 :             maxlen = lendata.maxbound;
    1647                 :            :           }
    1648                 :        253 :         if (nargs > 1)
    1649                 :        252 :           bound = CALL_EXPR_ARG (exp, 1);
    1650                 :            :         break;
    1651                 :            :       }
    1652                 :            : 
    1653                 :            :     default:
    1654                 :            :       break;
    1655                 :            :     }
    1656                 :            : 
    1657                 :            :   /* Determine the range of the bound argument (if specified).  */
    1658                 :     515551 :   tree bndrng[2] = { NULL_TREE, NULL_TREE };
    1659                 :     515551 :   if (bound)
    1660                 :            :     {
    1661                 :       4107 :       STRIP_NOPS (bound);
    1662                 :       4107 :       get_size_range (bound, bndrng);
    1663                 :            :     }
    1664                 :            : 
    1665                 :     515551 :   location_t loc = EXPR_LOCATION (exp);
    1666                 :            : 
    1667                 :     515551 :   if (bndrng[0])
    1668                 :            :     {
    1669                 :            :       /* Diagnose excessive bound prior the adjustment below and
    1670                 :            :          regardless of attribute nonstring.  */
    1671                 :       4085 :       tree maxobjsize = max_object_size ();
    1672                 :       4085 :       if (tree_int_cst_lt (maxobjsize, bndrng[0]))
    1673                 :            :         {
    1674                 :         67 :           if (tree_int_cst_equal (bndrng[0], bndrng[1]))
    1675                 :         55 :             warning_at (loc, OPT_Wstringop_overflow_,
    1676                 :            :                         "%K%qD specified bound %E "
    1677                 :            :                         "exceeds maximum object size %E",
    1678                 :            :                         exp, fndecl, bndrng[0], maxobjsize);
    1679                 :            :           else
    1680                 :         12 :             warning_at (loc, OPT_Wstringop_overflow_,
    1681                 :            :                         "%K%qD specified bound [%E, %E] "
    1682                 :            :                         "exceeds maximum object size %E",
    1683                 :            :                         exp, fndecl, bndrng[0], bndrng[1], maxobjsize);
    1684                 :         67 :           return;
    1685                 :            :         }
    1686                 :            :     }
    1687                 :            : 
    1688                 :     515484 :   if (maxlen && !integer_all_onesp (maxlen))
    1689                 :            :     {
    1690                 :            :       /* Add one for the nul.  */
    1691                 :       1734 :       maxlen = const_binop (PLUS_EXPR, TREE_TYPE (maxlen), maxlen,
    1692                 :            :                             size_one_node);
    1693                 :            : 
    1694                 :       1734 :       if (!bndrng[0])
    1695                 :            :         {
    1696                 :            :           /* Conservatively use the upper bound of the lengths for
    1697                 :            :              both the lower and the upper bound of the operation.  */
    1698                 :        980 :           bndrng[0] = maxlen;
    1699                 :        980 :           bndrng[1] = maxlen;
    1700                 :        980 :           bound = void_type_node;
    1701                 :            :         }
    1702                 :        754 :       else if (maxlen)
    1703                 :            :         {
    1704                 :            :           /* Replace the bound on the operation with the upper bound
    1705                 :            :              of the length of the string if the latter is smaller.  */
    1706                 :        751 :           if (tree_int_cst_lt (maxlen, bndrng[0]))
    1707                 :         49 :             bndrng[0] = maxlen;
    1708                 :        702 :           else if (tree_int_cst_lt (maxlen, bndrng[1]))
    1709                 :        183 :             bndrng[1] = maxlen;
    1710                 :            :         }
    1711                 :            :     }
    1712                 :            : 
    1713                 :            :   /* Iterate over the built-in function's formal arguments and check
    1714                 :            :      each const char* against the actual argument.  If the actual
    1715                 :            :      argument is declared attribute non-string issue a warning unless
    1716                 :            :      the argument's maximum length is bounded.  */
    1717                 :     515484 :   function_args_iterator it;
    1718                 :     515484 :   function_args_iter_init (&it, TREE_TYPE (fndecl));
    1719                 :            : 
    1720                 :    1709900 :   for (unsigned argno = 0; ; ++argno, function_args_iter_next (&it))
    1721                 :            :     {
    1722                 :            :       /* Avoid iterating past the declared argument in a call
    1723                 :            :          to function declared without a prototype.  */
    1724                 :    1709900 :       if (argno >= nargs)
    1725                 :            :         break;
    1726                 :            : 
    1727                 :    1270660 :       tree argtype = function_args_iter_cond (&it);
    1728                 :    1270660 :       if (!argtype)
    1729                 :            :         break;
    1730                 :            : 
    1731                 :    1194420 :       if (TREE_CODE (argtype) != POINTER_TYPE)
    1732                 :    1193310 :         continue;
    1733                 :            : 
    1734                 :     742592 :       argtype = TREE_TYPE (argtype);
    1735                 :            : 
    1736                 :    1379910 :       if (TREE_CODE (argtype) != INTEGER_TYPE
    1737                 :     875004 :           || !TYPE_READONLY (argtype))
    1738                 :     637316 :         continue;
    1739                 :            : 
    1740                 :     105276 :       argtype = TYPE_MAIN_VARIANT (argtype);
    1741                 :     105276 :       if (argtype != char_type_node)
    1742                 :       5093 :         continue;
    1743                 :            : 
    1744                 :     100183 :       tree callarg = CALL_EXPR_ARG (exp, argno);
    1745                 :     100183 :       if (TREE_CODE (callarg) == ADDR_EXPR)
    1746                 :      81210 :         callarg = TREE_OPERAND (callarg, 0);
    1747                 :            : 
    1748                 :            :       /* See if the destination is declared with attribute "nonstring".  */
    1749                 :     100183 :       tree decl = get_attr_nonstring_decl (callarg);
    1750                 :     100183 :       if (!decl)
    1751                 :      99079 :         continue;
    1752                 :            : 
    1753                 :            :       /* The maximum number of array elements accessed.  */
    1754                 :       1104 :       offset_int wibnd = 0;
    1755                 :            : 
    1756                 :       1104 :       if (argno && fncode == BUILT_IN_STRNCAT)
    1757                 :            :         {
    1758                 :            :           /* See if the bound in strncat is derived from the length
    1759                 :            :              of the strlen of the destination (as it's expected to be).
    1760                 :            :              If so, reset BOUND and FNCODE to trigger a warning.  */
    1761                 :        180 :           tree dstarg = CALL_EXPR_ARG (exp, 0);
    1762                 :        180 :           if (is_strlen_related_p (dstarg, bound))
    1763                 :            :             {
    1764                 :            :               /* The bound applies to the destination, not to the source,
    1765                 :            :                  so reset these to trigger a warning without mentioning
    1766                 :            :                  the bound.  */
    1767                 :            :               bound = NULL;
    1768                 :            :               fncode = 0;
    1769                 :            :             }
    1770                 :        175 :           else if (bndrng[1])
    1771                 :            :             /* Use the upper bound of the range for strncat.  */
    1772                 :        175 :             wibnd = wi::to_offset (bndrng[1]);
    1773                 :            :         }
    1774                 :        924 :       else if (bndrng[0])
    1775                 :            :         /* Use the lower bound of the range for functions other than
    1776                 :            :            strncat.  */
    1777                 :        632 :         wibnd = wi::to_offset (bndrng[0]);
    1778                 :            : 
    1779                 :            :       /* Determine the size of the argument array if it is one.  */
    1780                 :       1104 :       offset_int asize = wibnd;
    1781                 :       1104 :       bool known_size = false;
    1782                 :       1104 :       tree type = TREE_TYPE (decl);
    1783                 :            : 
    1784                 :            :       /* Determine the array size.  For arrays of unknown bound and
    1785                 :            :          pointers reset BOUND to trigger the appropriate warning.  */
    1786                 :       1104 :       if (TREE_CODE (type) == ARRAY_TYPE)
    1787                 :            :         {
    1788                 :        917 :           if (tree arrbnd = TYPE_DOMAIN (type))
    1789                 :            :             {
    1790                 :        887 :               if ((arrbnd = TYPE_MAX_VALUE (arrbnd)))
    1791                 :            :                 {
    1792                 :        887 :                   asize = wi::to_offset (arrbnd) + 1;
    1793                 :        887 :                   known_size = true;
    1794                 :            :                 }
    1795                 :            :             }
    1796                 :         30 :           else if (bound == void_type_node)
    1797                 :         10 :             bound = NULL_TREE;
    1798                 :            :         }
    1799                 :        187 :       else if (bound == void_type_node)
    1800                 :         15 :         bound = NULL_TREE;
    1801                 :            : 
    1802                 :            :       /* In a call to strncat with a bound in a range whose lower but
    1803                 :            :          not upper bound is less than the array size, reset ASIZE to
    1804                 :            :          be the same as the bound and the other variable to trigger
    1805                 :            :          the apprpriate warning below.  */
    1806                 :       1104 :       if (fncode == BUILT_IN_STRNCAT
    1807                 :        175 :           && bndrng[0] != bndrng[1]
    1808                 :       1154 :           && wi::ltu_p (wi::to_offset (bndrng[0]), asize)
    1809                 :       1174 :           && (!known_size
    1810                 :         65 :               || wi::ltu_p (asize, wibnd)))
    1811                 :            :         {
    1812                 :         20 :           asize = wibnd;
    1813                 :         20 :           bound = NULL_TREE;
    1814                 :         20 :           fncode = 0;
    1815                 :            :         }
    1816                 :            : 
    1817                 :       1104 :       bool warned = false;
    1818                 :            : 
    1819                 :       2208 :       auto_diagnostic_group d;
    1820                 :       1104 :       if (wi::ltu_p (asize, wibnd))
    1821                 :            :         {
    1822                 :        235 :           if (bndrng[0] == bndrng[1])
    1823                 :        196 :             warned = warning_at (loc, OPT_Wstringop_overflow_,
    1824                 :            :                                  "%qD argument %i declared attribute "
    1825                 :            :                                  "%<nonstring%> is smaller than the specified "
    1826                 :            :                                  "bound %wu",
    1827                 :            :                                  fndecl, argno + 1, wibnd.to_uhwi ());
    1828                 :         39 :           else if (wi::ltu_p (asize, wi::to_offset (bndrng[0])))
    1829                 :         29 :             warned = warning_at (loc, OPT_Wstringop_overflow_,
    1830                 :            :                                  "%qD argument %i declared attribute "
    1831                 :            :                                  "%<nonstring%> is smaller than "
    1832                 :            :                                  "the specified bound [%E, %E]",
    1833                 :            :                                  fndecl, argno + 1, bndrng[0], bndrng[1]);
    1834                 :            :           else
    1835                 :         10 :             warned = warning_at (loc, OPT_Wstringop_overflow_,
    1836                 :            :                                  "%qD argument %i declared attribute "
    1837                 :            :                                  "%<nonstring%> may be smaller than "
    1838                 :            :                                  "the specified bound [%E, %E]",
    1839                 :            :                                  fndecl, argno + 1, bndrng[0], bndrng[1]);
    1840                 :            :         }
    1841                 :        869 :       else if (fncode == BUILT_IN_STRNCAT)
    1842                 :            :         ; /* Avoid warning for calls to strncat() when the bound
    1843                 :            :              is equal to the size of the non-string argument.  */
    1844                 :        739 :       else if (!bound)
    1845                 :        342 :         warned = warning_at (loc, OPT_Wstringop_overflow_,
    1846                 :            :                              "%qD argument %i declared attribute %<nonstring%>",
    1847                 :            :                              fndecl, argno + 1);
    1848                 :            : 
    1849                 :        577 :       if (warned)
    1850                 :        577 :         inform (DECL_SOURCE_LOCATION (decl),
    1851                 :            :                 "argument %qD declared here", decl);
    1852                 :    1194420 :     }
    1853                 :            : }
    1854                 :            : 
    1855                 :            : /* Issue an error if CALL_EXPR was flagged as requiring
    1856                 :            :    tall-call optimization.  */
    1857                 :            : 
    1858                 :            : static void
    1859                 :       6930 : maybe_complain_about_tail_call (tree call_expr, const char *reason)
    1860                 :            : {
    1861                 :       6930 :   gcc_assert (TREE_CODE (call_expr) == CALL_EXPR);
    1862                 :       6930 :   if (!CALL_EXPR_MUST_TAIL_CALL (call_expr))
    1863                 :            :     return;
    1864                 :            : 
    1865                 :         10 :   error_at (EXPR_LOCATION (call_expr), "cannot tail-call: %s", reason);
    1866                 :            : }
    1867                 :            : 
    1868                 :            : /* Used to define rdwr_map below.  */
    1869                 :            : struct rdwr_access_hash: int_hash<int, -1> { };
    1870                 :            : 
    1871                 :            : /* A mapping between argument number corresponding to attribute access
    1872                 :            :    mode (read_only, write_only, or read_write) and operands.  */
    1873                 :            : typedef hash_map<rdwr_access_hash, attr_access> rdwr_map;
    1874                 :            : 
    1875                 :            : /* Initialize a mapping for a call to function FNDECL declared with
    1876                 :            :    attribute access.  Each attribute positional operand inserts one
    1877                 :            :    entry into the mapping with the operand number as the key.  */
    1878                 :            : 
    1879                 :            : static void
    1880                 :    3876220 : init_attr_rdwr_indices (rdwr_map *rwm, tree fntype)
    1881                 :            : {
    1882                 :    3876220 :   if (!fntype)
    1883                 :            :     return;
    1884                 :            : 
    1885                 :    3876930 :   for (tree access = TYPE_ATTRIBUTES (fntype);
    1886                 :    3876930 :        (access = lookup_attribute ("access", access));
    1887                 :        714 :        access = TREE_CHAIN (access))
    1888                 :            :     {
    1889                 :            :       /* The TREE_VALUE of an attribute is a TREE_LIST whose TREE_VALUE
    1890                 :            :          is the attribute argument's value.  */
    1891                 :        714 :       tree mode = TREE_VALUE (access);
    1892                 :        714 :       gcc_assert (TREE_CODE (mode) == TREE_LIST);
    1893                 :        714 :       mode = TREE_VALUE (mode);
    1894                 :        714 :       gcc_assert (TREE_CODE (mode) == STRING_CST);
    1895                 :            : 
    1896                 :        714 :       const char *modestr = TREE_STRING_POINTER (mode);
    1897                 :       1992 :       for (const char *m = modestr; *m; )
    1898                 :            :         {
    1899                 :       1278 :           attr_access acc = { };
    1900                 :            : 
    1901                 :       1278 :           switch (*m)
    1902                 :            :             {
    1903                 :        232 :             case 'r': acc.mode = acc.read_only; break;
    1904                 :        175 :             case 'w': acc.mode = acc.write_only; break;
    1905                 :        871 :             default: acc.mode = acc.read_write; break;
    1906                 :            :             }
    1907                 :            : 
    1908                 :       1278 :           char *end;
    1909                 :       1278 :           acc.ptrarg = strtoul (++m, &end, 10);
    1910                 :       1278 :           m = end;
    1911                 :       1278 :           if (*m == ',')
    1912                 :            :             {
    1913                 :        181 :               acc.sizarg = strtoul (++m, &end, 10);
    1914                 :        181 :               m = end;
    1915                 :            :             }
    1916                 :            :           else
    1917                 :       1097 :             acc.sizarg = UINT_MAX;
    1918                 :            : 
    1919                 :       1278 :           acc.ptr = NULL_TREE;
    1920                 :       1278 :           acc.size = NULL_TREE;
    1921                 :            : 
    1922                 :            :           /* Unconditionally add an entry for the required pointer
    1923                 :            :              operand of the attribute, and one for the optional size
    1924                 :            :              operand when it's specified.  */
    1925                 :       1278 :           rwm->put (acc.ptrarg, acc);
    1926                 :       1278 :           if (acc.sizarg != UINT_MAX)
    1927                 :        181 :             rwm->put (acc.sizarg, acc);
    1928                 :            :         }
    1929                 :            :     }
    1930                 :            : }
    1931                 :            : 
    1932                 :            : /* Returns the type of the argument ARGNO to function with type FNTYPE
    1933                 :            :    or null when the typoe cannot be determined or no such argument exists.  */
    1934                 :            : 
    1935                 :            : static tree
    1936                 :        674 : fntype_argno_type (tree fntype, unsigned argno)
    1937                 :            : {
    1938                 :        674 :   if (!prototype_p (fntype))
    1939                 :            :     return NULL_TREE;
    1940                 :            : 
    1941                 :        674 :   tree argtype;
    1942                 :        674 :   function_args_iterator it;
    1943                 :       1384 :   FOREACH_FUNCTION_ARGS (fntype, argtype, it)
    1944                 :       1384 :     if (argno-- == 0)
    1945                 :        674 :       return argtype;
    1946                 :            : 
    1947                 :            :   return NULL_TREE;
    1948                 :            : }
    1949                 :            : 
    1950                 :            : /* Helper to append the "rdwr" attribute specification described
    1951                 :            :    by ACCESS to the array ATTRSTR with size STRSIZE.  Used in
    1952                 :            :    diagnostics.  */
    1953                 :            : 
    1954                 :            : static inline void
    1955                 :        174 : append_attrname (const std::pair<int, attr_access> &access,
    1956                 :            :                  char *attrstr, size_t strsize)
    1957                 :            : {
    1958                 :            :   /* Append the relevant attribute to the string.  This (deliberately)
    1959                 :            :      appends the attribute pointer operand even when none was specified.  */
    1960                 :        174 :   size_t len = strlen (attrstr);
    1961                 :            : 
    1962                 :        348 :   const char *atname
    1963                 :        174 :     = (access.second.mode == attr_access::read_only
    1964                 :        174 :        ? "read_only"
    1965                 :            :        : (access.second.mode == attr_access::write_only
    1966                 :            :           ? "write_only" : "read_write"));
    1967                 :            : 
    1968                 :        174 :   const char *sep = len ? ", " : "";
    1969                 :            : 
    1970                 :        174 :   if (access.second.sizarg == UINT_MAX)
    1971                 :        140 :     snprintf (attrstr + len, strsize - len,
    1972                 :            :               "%s%s (%i)", sep, atname,
    1973                 :        140 :               access.second.ptrarg + 1);
    1974                 :            :   else
    1975                 :         34 :     snprintf (attrstr + len, strsize - len,
    1976                 :            :               "%s%s (%i, %i)", sep, atname,
    1977                 :         34 :               access.second.ptrarg + 1, access.second.sizarg + 1);
    1978                 :        174 : }
    1979                 :            : 
    1980                 :            : /* Iterate over attribute access read-only, read-write, and write-only
    1981                 :            :    arguments and diagnose past-the-end accesses and related problems
    1982                 :            :    in the function call EXP.  */
    1983                 :            : 
    1984                 :            : static void
    1985                 :    3876220 : maybe_warn_rdwr_sizes (rdwr_map *rwm, tree exp)
    1986                 :            : {
    1987                 :    3876220 :   tree fndecl = NULL_TREE;
    1988                 :    3876220 :   tree fntype = NULL_TREE;
    1989                 :    3876220 :   if (tree fnaddr = CALL_EXPR_FN (exp))
    1990                 :            :     {
    1991                 :    3876220 :       if (TREE_CODE (fnaddr) == ADDR_EXPR)
    1992                 :            :         {
    1993                 :    3687180 :           fndecl = TREE_OPERAND (fnaddr, 0);
    1994                 :    3687180 :           fntype = TREE_TYPE (fndecl);
    1995                 :            :         }
    1996                 :            :       else
    1997                 :     189040 :         fntype = TREE_TYPE (TREE_TYPE (fnaddr));
    1998                 :            :     }
    1999                 :            : 
    2000                 :    3876220 :   if (!fntype)
    2001                 :    3876040 :     return;
    2002                 :            : 
    2003                 :            :   /* A string describing the attributes that the warnings issued by this
    2004                 :            :      function apply to.  Used to print one informational note per function
    2005                 :            :      call, rather than one per warning.  That reduces clutter.  */
    2006                 :    3876220 :   char attrstr[80];
    2007                 :    3876220 :   attrstr[0] = 0;
    2008                 :            : 
    2009                 :    7754020 :   for (rdwr_map::iterator it = rwm->begin (); it != rwm->end (); ++it)
    2010                 :            :     {
    2011                 :        794 :       std::pair<int, attr_access> access = *it;
    2012                 :            : 
    2013                 :            :       /* Get the function call arguments corresponding to the attribute's
    2014                 :            :          positional arguments.  When both arguments have been specified
    2015                 :            :          there will be two entries in *RWM, one for each.  They are
    2016                 :            :          cross-referenced by their respective argument numbers in
    2017                 :            :          ACCESS.PTRARG and ACCESS.SIZARG.  */
    2018                 :        794 :       const int ptridx = access.second.ptrarg;
    2019                 :        794 :       const int sizidx = access.second.sizarg;
    2020                 :            : 
    2021                 :        794 :       gcc_assert (ptridx != -1);
    2022                 :        794 :       gcc_assert (access.first == ptridx || access.first == sizidx);
    2023                 :            : 
    2024                 :            :       /* The pointer is set to null for the entry corresponding to
    2025                 :            :          the size argument.  Skip it.  It's handled when the entry
    2026                 :            :          corresponding to the pointer argument comes up.  */
    2027                 :        794 :       if (!access.second.ptr)
    2028                 :        131 :         continue;
    2029                 :            : 
    2030                 :        674 :       tree argtype = fntype_argno_type (fntype, ptridx);
    2031                 :        674 :       argtype = TREE_TYPE (argtype);
    2032                 :            : 
    2033                 :        674 :       tree size;
    2034                 :        674 :       if (sizidx == -1)
    2035                 :            :         {
    2036                 :            :           /* If only the pointer attribute operand was specified
    2037                 :            :              and not size, set SIZE to the size of one element of
    2038                 :            :              the pointed to type to detect smaller objects (null
    2039                 :            :              pointers are diagnosed in this case only if
    2040                 :            :              the pointer is also declared with attribute nonnull.  */
    2041                 :        549 :           size = size_one_node;
    2042                 :            :         }
    2043                 :            :       else
    2044                 :        250 :         size = rwm->get (sizidx)->size;
    2045                 :            : 
    2046                 :        674 :       tree ptr = access.second.ptr;
    2047                 :        674 :       tree sizrng[2] = { size_zero_node, build_all_ones_cst (sizetype) };
    2048                 :        674 :       if (get_size_range (size, sizrng, true)
    2049                 :        674 :           && tree_int_cst_sgn (sizrng[0]) < 0
    2050                 :        694 :           && tree_int_cst_sgn (sizrng[1]) < 0)
    2051                 :            :         {
    2052                 :            :           /* Warn about negative sizes.  */
    2053                 :          3 :           bool warned = false;
    2054                 :          3 :           location_t loc = EXPR_LOCATION (exp);
    2055                 :          3 :           if (tree_int_cst_equal (sizrng[0], sizrng[1]))
    2056                 :          2 :             warned = warning_at (loc, OPT_Wstringop_overflow_,
    2057                 :            :                                  "%Kargument %i value %E is negative",
    2058                 :          2 :                                  exp, sizidx + 1, size);
    2059                 :            :           else
    2060                 :          1 :             warned = warning_at (loc, OPT_Wstringop_overflow_,
    2061                 :            :                                  "%Kargument %i range [%E, %E] is negative",
    2062                 :          1 :                                  exp, sizidx + 1, sizrng[0], sizrng[1]);
    2063                 :          3 :           if (warned)
    2064                 :            :             {
    2065                 :          3 :               append_attrname (access, attrstr, sizeof attrstr);
    2066                 :            :               /* Avoid warning again for the same attribute.  */
    2067                 :          3 :               continue;
    2068                 :            :             }
    2069                 :            :         }
    2070                 :            : 
    2071                 :        671 :       if (tree_int_cst_sgn (sizrng[0]) >= 0)
    2072                 :            :         {
    2073                 :        654 :           if (COMPLETE_TYPE_P (argtype))
    2074                 :            :             {
    2075                 :            :               /* Multiple SIZE by the size of the type the pointer
    2076                 :            :                  argument points to.  If it's incomplete the size
    2077                 :            :                  is used as is.  */
    2078                 :        224 :               size = NULL_TREE;
    2079                 :        224 :               if (tree argsize = TYPE_SIZE_UNIT (argtype))
    2080                 :        224 :                 if (TREE_CODE (argsize) == INTEGER_CST)
    2081                 :            :                   {
    2082                 :        224 :                     const int prec = TYPE_PRECISION (sizetype);
    2083                 :        224 :                     wide_int minsize = wi::to_wide (sizrng[0], prec);
    2084                 :        224 :                     minsize *= wi::to_wide (argsize, prec);
    2085                 :        224 :                     size = wide_int_to_tree (sizetype, minsize);
    2086                 :            :                   }
    2087                 :            :             }
    2088                 :            :         }
    2089                 :            :       else
    2090                 :            :         size = NULL_TREE;
    2091                 :            : 
    2092                 :        671 :       if (sizidx >= 0
    2093                 :        122 :           && integer_zerop (ptr)
    2094                 :        690 :           && tree_int_cst_sgn (sizrng[0]) > 0)
    2095                 :            :         {
    2096                 :            :           /* Warn about null pointers with positive sizes.  This is
    2097                 :            :              different from also declaring the pointer argument with
    2098                 :            :              attribute nonnull when the function accepts null pointers
    2099                 :            :              only when the corresponding size is zero.  */
    2100                 :          8 :           bool warned = false;
    2101                 :          8 :           location_t loc = EXPR_LOCATION (exp);
    2102                 :          8 :           if (tree_int_cst_equal (sizrng[0], sizrng[1]))
    2103                 :          5 :             warned = warning_at (loc, OPT_Wnonnull,
    2104                 :            :                                  "%Kargument %i is null but the corresponding "
    2105                 :            :                                  "size argument %i value is %E",
    2106                 :          5 :                                  exp, ptridx + 1, sizidx + 1, size);
    2107                 :            :           else
    2108                 :          3 :             warned = warning_at (loc, OPT_Wnonnull,
    2109                 :            :                                  "%Kargument %i is null but the corresponding "
    2110                 :            :                                  "size argument %i range is [%E, %E]",
    2111                 :          3 :                                  exp, ptridx + 1, sizidx + 1,
    2112                 :            :                                  sizrng[0], sizrng[1]);
    2113                 :          8 :           if (warned)
    2114                 :            :             {
    2115                 :          8 :               append_attrname (access, attrstr, sizeof attrstr);
    2116                 :            :               /* Avoid warning again for the same attribute.  */
    2117                 :          8 :               continue;
    2118                 :            :             }
    2119                 :            :         }
    2120                 :            : 
    2121                 :        663 :       tree objsize = compute_objsize (ptr, 0);
    2122                 :            : 
    2123                 :        663 :       tree srcsize;
    2124                 :        663 :       if (access.second.mode == attr_access::write_only)
    2125                 :            :         {
    2126                 :            :           /* For a write-only argument there is no source.  */
    2127                 :            :           srcsize = NULL_TREE;
    2128                 :            :         }
    2129                 :            :       else
    2130                 :            :         {
    2131                 :            :           /* For read-only and read-write attributes also set the source
    2132                 :            :              size.  */
    2133                 :        534 :           srcsize = objsize;
    2134                 :        534 :           if (access.second.mode == attr_access::read_only)
    2135                 :            :             {
    2136                 :            :               /* For a read-only attribute there is no destination so
    2137                 :            :                  clear OBJSIZE.  This emits "reading N bytes" kind of
    2138                 :            :                  diagnostics instead of the "writing N bytes" kind.  */
    2139                 :        139 :               objsize = NULL_TREE;
    2140                 :            :             }
    2141                 :            :         }
    2142                 :            : 
    2143                 :            :       /* Clear the no-warning bit in case it was set in a prior
    2144                 :            :          iteration so that accesses via different arguments are
    2145                 :            :          diagnosed.  */
    2146                 :        663 :       TREE_NO_WARNING (exp) = false;
    2147                 :        663 :       check_access (exp, NULL_TREE, NULL_TREE, size, /*maxread=*/ NULL_TREE,
    2148                 :            :                     srcsize, objsize);
    2149                 :            : 
    2150                 :        663 :       if (TREE_NO_WARNING (exp))
    2151                 :            :         /* If check_access issued a warning above, append the relevant
    2152                 :            :            attribute to the string.  */
    2153                 :        163 :         append_attrname (access, attrstr, sizeof attrstr);
    2154                 :            :     }
    2155                 :            : 
    2156                 :    3876220 :   if (!*attrstr)
    2157                 :            :     return;
    2158                 :            : 
    2159                 :        172 :   if (fndecl)
    2160                 :        152 :     inform (DECL_SOURCE_LOCATION (fndecl),
    2161                 :            :             "in a call to function %qD declared with attribute %qs",
    2162                 :            :             fndecl, attrstr);
    2163                 :            :   else
    2164                 :         20 :     inform (EXPR_LOCATION (fndecl),
    2165                 :            :             "in a call with type %qT and attribute %qs",
    2166                 :            :             fntype, attrstr);
    2167                 :            : 
    2168                 :            :   /* Set the bit in case if was cleared and not set above.  */
    2169                 :        172 :   TREE_NO_WARNING (exp) = true;
    2170                 :            : }
    2171                 :            : 
    2172                 :            : /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
    2173                 :            :    CALL_EXPR EXP.
    2174                 :            : 
    2175                 :            :    NUM_ACTUALS is the total number of parameters.
    2176                 :            : 
    2177                 :            :    N_NAMED_ARGS is the total number of named arguments.
    2178                 :            : 
    2179                 :            :    STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
    2180                 :            :    value, or null.
    2181                 :            : 
    2182                 :            :    FNDECL is the tree code for the target of this call (if known)
    2183                 :            : 
    2184                 :            :    ARGS_SO_FAR holds state needed by the target to know where to place
    2185                 :            :    the next argument.
    2186                 :            : 
    2187                 :            :    REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
    2188                 :            :    for arguments which are passed in registers.
    2189                 :            : 
    2190                 :            :    OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
    2191                 :            :    and may be modified by this routine.
    2192                 :            : 
    2193                 :            :    OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
    2194                 :            :    flags which may be modified by this routine.
    2195                 :            : 
    2196                 :            :    MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
    2197                 :            :    that requires allocation of stack space.
    2198                 :            : 
    2199                 :            :    CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
    2200                 :            :    the thunked-to function.  */
    2201                 :            : 
    2202                 :            : static void
    2203                 :    3876220 : initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
    2204                 :            :                                  struct arg_data *args,
    2205                 :            :                                  struct args_size *args_size,
    2206                 :            :                                  int n_named_args ATTRIBUTE_UNUSED,
    2207                 :            :                                  tree exp, tree struct_value_addr_value,
    2208                 :            :                                  tree fndecl, tree fntype,
    2209                 :            :                                  cumulative_args_t args_so_far,
    2210                 :            :                                  int reg_parm_stack_space,
    2211                 :            :                                  rtx *old_stack_level,
    2212                 :            :                                  poly_int64_pod *old_pending_adj,
    2213                 :            :                                  int *must_preallocate, int *ecf_flags,
    2214                 :            :                                  bool *may_tailcall, bool call_from_thunk_p)
    2215                 :            : {
    2216                 :    3876220 :   CUMULATIVE_ARGS *args_so_far_pnt = get_cumulative_args (args_so_far);
    2217                 :    3876220 :   location_t loc = EXPR_LOCATION (exp);
    2218                 :            : 
    2219                 :            :   /* Count arg position in order args appear.  */
    2220                 :    3876220 :   int argpos;
    2221                 :            : 
    2222                 :    3876220 :   int i;
    2223                 :            : 
    2224                 :    3876220 :   args_size->constant = 0;
    2225                 :    3876220 :   args_size->var = 0;
    2226                 :            : 
    2227                 :    3876220 :   bitmap_obstack_initialize (NULL);
    2228                 :            : 
    2229                 :            :   /* In this loop, we consider args in the order they are written.
    2230                 :            :      We fill up ARGS from the back.  */
    2231                 :            : 
    2232                 :    3876220 :   i = num_actuals - 1;
    2233                 :    3876220 :   {
    2234                 :    3876220 :     int j = i;
    2235                 :    3876220 :     call_expr_arg_iterator iter;
    2236                 :    3876220 :     tree arg;
    2237                 :    3876220 :     bitmap slots = NULL;
    2238                 :            : 
    2239                 :    3876220 :     if (struct_value_addr_value)
    2240                 :            :       {
    2241                 :     175743 :         args[j].tree_value = struct_value_addr_value;
    2242                 :     175743 :         j--;
    2243                 :            :       }
    2244                 :    3876220 :     argpos = 0;
    2245                 :   11115900 :     FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
    2246                 :            :       {
    2247                 :    7239640 :         tree argtype = TREE_TYPE (arg);
    2248                 :            : 
    2249                 :    7239640 :         if (targetm.calls.split_complex_arg
    2250                 :          0 :             && argtype
    2251                 :          0 :             && TREE_CODE (argtype) == COMPLEX_TYPE
    2252                 :    7239640 :             && targetm.calls.split_complex_arg (argtype))
    2253                 :            :           {
    2254                 :          0 :             tree subtype = TREE_TYPE (argtype);
    2255                 :          0 :             args[j].tree_value = build1 (REALPART_EXPR, subtype, arg);
    2256                 :          0 :             j--;
    2257                 :          0 :             args[j].tree_value = build1 (IMAGPART_EXPR, subtype, arg);
    2258                 :            :           }
    2259                 :            :         else
    2260                 :    7239640 :           args[j].tree_value = arg;
    2261                 :    7239640 :         j--;
    2262                 :    7239640 :         argpos++;
    2263                 :            :       }
    2264                 :            : 
    2265                 :    3876220 :     if (slots)
    2266                 :            :       BITMAP_FREE (slots);
    2267                 :            :   }
    2268                 :            : 
    2269                 :    3876220 :   bitmap_obstack_release (NULL);
    2270                 :            : 
    2271                 :            :   /* Extract attribute alloc_size from the type of the called expression
    2272                 :            :      (which could be a function or a function pointer) and if set, store
    2273                 :            :      the indices of the corresponding arguments in ALLOC_IDX, and then
    2274                 :            :      the actual argument(s) at those indices in ALLOC_ARGS.  */
    2275                 :    3876220 :   int alloc_idx[2] = { -1, -1 };
    2276                 :    7752430 :   if (tree alloc_size = lookup_attribute ("alloc_size",
    2277                 :    3876220 :                                           TYPE_ATTRIBUTES (fntype)))
    2278                 :            :     {
    2279                 :      27826 :       tree args = TREE_VALUE (alloc_size);
    2280                 :      27826 :       alloc_idx[0] = TREE_INT_CST_LOW (TREE_VALUE (args)) - 1;
    2281                 :      27826 :       if (TREE_CHAIN (args))
    2282                 :        658 :         alloc_idx[1] = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args))) - 1;
    2283                 :            :     }
    2284                 :            : 
    2285                 :            :   /* Array for up to the two attribute alloc_size arguments.  */
    2286                 :    3876220 :   tree alloc_args[] = { NULL_TREE, NULL_TREE };
    2287                 :            : 
    2288                 :            :   /* Map of attribute read_only, write_only, or read_write specifications
    2289                 :            :      for function arguments.  */
    2290                 :    3876220 :   rdwr_map rdwr_idx;
    2291                 :    3876220 :   init_attr_rdwr_indices (&rdwr_idx, fntype);
    2292                 :            : 
    2293                 :            :   /* I counts args in order (to be) pushed; ARGPOS counts in order written.  */
    2294                 :   11291600 :   for (argpos = 0; argpos < num_actuals; i--, argpos++)
    2295                 :            :     {
    2296                 :    7415380 :       tree type = TREE_TYPE (args[i].tree_value);
    2297                 :    7415380 :       int unsignedp;
    2298                 :            : 
    2299                 :            :       /* Replace erroneous argument with constant zero.  */
    2300                 :   14830800 :       if (type == error_mark_node || !COMPLETE_TYPE_P (type))
    2301                 :          0 :         args[i].tree_value = integer_zero_node, type = integer_type_node;
    2302                 :            : 
    2303                 :            :       /* If TYPE is a transparent union or record, pass things the way
    2304                 :            :          we would pass the first field of the union or record.  We have
    2305                 :            :          already verified that the modes are the same.  */
    2306                 :    7415380 :       if (RECORD_OR_UNION_TYPE_P (type) && TYPE_TRANSPARENT_AGGR (type))
    2307                 :       3563 :         type = TREE_TYPE (first_field (type));
    2308                 :            : 
    2309                 :            :       /* Decide where to pass this arg.
    2310                 :            : 
    2311                 :            :          args[i].reg is nonzero if all or part is passed in registers.
    2312                 :            : 
    2313                 :            :          args[i].partial is nonzero if part but not all is passed in registers,
    2314                 :            :          and the exact value says how many bytes are passed in registers.
    2315                 :            : 
    2316                 :            :          args[i].pass_on_stack is nonzero if the argument must at least be
    2317                 :            :          computed on the stack.  It may then be loaded back into registers
    2318                 :            :          if args[i].reg is nonzero.
    2319                 :            : 
    2320                 :            :          These decisions are driven by the FUNCTION_... macros and must agree
    2321                 :            :          with those made by function.c.  */
    2322                 :            : 
    2323                 :            :       /* See if this argument should be passed by invisible reference.  */
    2324                 :    7415380 :       function_arg_info arg (type, argpos < n_named_args);
    2325                 :    7415380 :       if (pass_by_reference (args_so_far_pnt, arg))
    2326                 :            :         {
    2327                 :        325 :           bool callee_copies;
    2328                 :        325 :           tree base = NULL_TREE;
    2329                 :            : 
    2330                 :        325 :           callee_copies = reference_callee_copied (args_so_far_pnt, arg);
    2331                 :            : 
    2332                 :            :           /* If we're compiling a thunk, pass through invisible references
    2333                 :            :              instead of making a copy.  */
    2334                 :        325 :           if (call_from_thunk_p
    2335                 :        325 :               || (callee_copies
    2336                 :          0 :                   && !TREE_ADDRESSABLE (type)
    2337                 :          0 :                   && (base = get_base_address (args[i].tree_value))
    2338                 :          0 :                   && TREE_CODE (base) != SSA_NAME
    2339                 :          0 :                   && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
    2340                 :            :             {
    2341                 :            :               /* We may have turned the parameter value into an SSA name.
    2342                 :            :                  Go back to the original parameter so we can take the
    2343                 :            :                  address.  */
    2344                 :          0 :               if (TREE_CODE (args[i].tree_value) == SSA_NAME)
    2345                 :            :                 {
    2346                 :          0 :                   gcc_assert (SSA_NAME_IS_DEFAULT_DEF (args[i].tree_value));
    2347                 :          0 :                   args[i].tree_value = SSA_NAME_VAR (args[i].tree_value);
    2348                 :          0 :                   gcc_assert (TREE_CODE (args[i].tree_value) == PARM_DECL);
    2349                 :            :                 }
    2350                 :            :               /* Argument setup code may have copied the value to register.  We
    2351                 :            :                  revert that optimization now because the tail call code must
    2352                 :            :                  use the original location.  */
    2353                 :          0 :               if (TREE_CODE (args[i].tree_value) == PARM_DECL
    2354                 :          0 :                   && !MEM_P (DECL_RTL (args[i].tree_value))
    2355                 :          0 :                   && DECL_INCOMING_RTL (args[i].tree_value)
    2356                 :          0 :                   && MEM_P (DECL_INCOMING_RTL (args[i].tree_value)))
    2357                 :          0 :                 set_decl_rtl (args[i].tree_value,
    2358                 :          0 :                               DECL_INCOMING_RTL (args[i].tree_value));
    2359                 :            : 
    2360                 :          0 :               mark_addressable (args[i].tree_value);
    2361                 :            : 
    2362                 :            :               /* We can't use sibcalls if a callee-copied argument is
    2363                 :            :                  stored in the current function's frame.  */
    2364                 :          0 :               if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
    2365                 :            :                 {
    2366                 :          0 :                   *may_tailcall = false;
    2367                 :          0 :                   maybe_complain_about_tail_call (exp,
    2368                 :            :                                                   "a callee-copied argument is"
    2369                 :            :                                                   " stored in the current"
    2370                 :            :                                                   " function's frame");
    2371                 :            :                 }
    2372                 :            : 
    2373                 :          0 :               args[i].tree_value = build_fold_addr_expr_loc (loc,
    2374                 :            :                                                          args[i].tree_value);
    2375                 :          0 :               type = TREE_TYPE (args[i].tree_value);
    2376                 :            : 
    2377                 :          0 :               if (*ecf_flags & ECF_CONST)
    2378                 :          0 :                 *ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE);
    2379                 :            :             }
    2380                 :            :           else
    2381                 :            :             {
    2382                 :            :               /* We make a copy of the object and pass the address to the
    2383                 :            :                  function being called.  */
    2384                 :        325 :               rtx copy;
    2385                 :            : 
    2386                 :        325 :               if (!COMPLETE_TYPE_P (type)
    2387                 :        325 :                   || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
    2388                 :        376 :                   || (flag_stack_check == GENERIC_STACK_CHECK
    2389                 :          0 :                       && compare_tree_int (TYPE_SIZE_UNIT (type),
    2390                 :            :                                            STACK_CHECK_MAX_VAR_SIZE) > 0))
    2391                 :            :                 {
    2392                 :            :                   /* This is a variable-sized object.  Make space on the stack
    2393                 :            :                      for it.  */
    2394                 :        274 :                   rtx size_rtx = expr_size (args[i].tree_value);
    2395                 :            : 
    2396                 :        274 :                   if (*old_stack_level == 0)
    2397                 :            :                     {
    2398                 :        170 :                       emit_stack_save (SAVE_BLOCK, old_stack_level);
    2399                 :        170 :                       *old_pending_adj = pending_stack_adjust;
    2400                 :        170 :                       pending_stack_adjust = 0;
    2401                 :            :                     }
    2402                 :            : 
    2403                 :            :                   /* We can pass TRUE as the 4th argument because we just
    2404                 :            :                      saved the stack pointer and will restore it right after
    2405                 :            :                      the call.  */
    2406                 :        274 :                   copy = allocate_dynamic_stack_space (size_rtx,
    2407                 :        274 :                                                        TYPE_ALIGN (type),
    2408                 :        274 :                                                        TYPE_ALIGN (type),
    2409                 :            :                                                        max_int_size_in_bytes
    2410                 :            :                                                        (type),
    2411                 :            :                                                        true);
    2412                 :        274 :                   copy = gen_rtx_MEM (BLKmode, copy);
    2413                 :        274 :                   set_mem_attributes (copy, type, 1);
    2414                 :            :                 }
    2415                 :            :               else
    2416                 :         51 :                 copy = assign_temp (type, 1, 0);
    2417                 :            : 
    2418                 :        325 :               store_expr (args[i].tree_value, copy, 0, false, false);
    2419                 :            : 
    2420                 :            :               /* Just change the const function to pure and then let
    2421                 :            :                  the next test clear the pure based on
    2422                 :            :                  callee_copies.  */
    2423                 :        325 :               if (*ecf_flags & ECF_CONST)
    2424                 :            :                 {
    2425                 :          0 :                   *ecf_flags &= ~ECF_CONST;
    2426                 :          0 :                   *ecf_flags |= ECF_PURE;
    2427                 :            :                 }
    2428                 :            : 
    2429                 :        325 :               if (!callee_copies && *ecf_flags & ECF_PURE)
    2430                 :          3 :                 *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
    2431                 :            : 
    2432                 :        325 :               args[i].tree_value
    2433                 :        325 :                 = build_fold_addr_expr_loc (loc, make_tree (type, copy));
    2434                 :        325 :               type = TREE_TYPE (args[i].tree_value);
    2435                 :        325 :               *may_tailcall = false;
    2436                 :        325 :               maybe_complain_about_tail_call (exp,
    2437                 :            :                                               "argument must be passed"
    2438                 :            :                                               " by copying");
    2439                 :            :             }
    2440                 :        325 :           arg.pass_by_reference = true;
    2441                 :            :         }
    2442                 :            : 
    2443                 :    7415380 :       unsignedp = TYPE_UNSIGNED (type);
    2444                 :    7415380 :       arg.type = type;
    2445                 :    7415380 :       arg.mode
    2446                 :   14830800 :         = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
    2447                 :    7109780 :                                  fndecl ? TREE_TYPE (fndecl) : fntype, 0);
    2448                 :            : 
    2449                 :    7415380 :       args[i].unsignedp = unsignedp;
    2450                 :    7415380 :       args[i].mode = arg.mode;
    2451                 :            : 
    2452                 :    7415380 :       targetm.calls.warn_parameter_passing_abi (args_so_far, type);
    2453                 :            : 
    2454                 :    7415380 :       args[i].reg = targetm.calls.function_arg (args_so_far, arg);
    2455                 :            : 
    2456                 :    7415380 :       if (args[i].reg && CONST_INT_P (args[i].reg))
    2457                 :          0 :         args[i].reg = NULL;
    2458                 :            : 
    2459                 :            :       /* If this is a sibling call and the machine has register windows, the
    2460                 :            :          register window has to be unwinded before calling the routine, so
    2461                 :            :          arguments have to go into the incoming registers.  */
    2462                 :    7415380 :       if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
    2463                 :          0 :         args[i].tail_call_reg
    2464                 :          0 :           = targetm.calls.function_incoming_arg (args_so_far, arg);
    2465                 :            :       else
    2466                 :    7415380 :         args[i].tail_call_reg = args[i].reg;
    2467                 :            : 
    2468                 :    7415380 :       if (args[i].reg)
    2469                 :    5829090 :         args[i].partial = targetm.calls.arg_partial_bytes (args_so_far, arg);
    2470                 :            : 
    2471                 :    7415380 :       args[i].pass_on_stack = targetm.calls.must_pass_in_stack (arg);
    2472                 :            : 
    2473                 :            :       /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
    2474                 :            :          it means that we are to pass this arg in the register(s) designated
    2475                 :            :          by the PARALLEL, but also to pass it in the stack.  */
    2476                 :    7415380 :       if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
    2477                 :     175715 :           && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
    2478                 :          0 :         args[i].pass_on_stack = 1;
    2479                 :            : 
    2480                 :            :       /* If this is an addressable type, we must preallocate the stack
    2481                 :            :          since we must evaluate the object into its final location.
    2482                 :            : 
    2483                 :            :          If this is to be passed in both registers and the stack, it is simpler
    2484                 :            :          to preallocate.  */
    2485                 :    7415380 :       if (TREE_ADDRESSABLE (type)
    2486                 :    7415380 :           || (args[i].pass_on_stack && args[i].reg != 0))
    2487                 :          0 :         *must_preallocate = 1;
    2488                 :            : 
    2489                 :            :       /* Compute the stack-size of this argument.  */
    2490                 :    7415380 :       if (args[i].reg == 0 || args[i].partial != 0
    2491                 :    5829090 :                || reg_parm_stack_space > 0
    2492                 :    5764110 :                || args[i].pass_on_stack)
    2493                 :    1651270 :         locate_and_pad_parm (arg.mode, type,
    2494                 :            : #ifdef STACK_PARMS_IN_REG_PARM_AREA
    2495                 :            :                              1,
    2496                 :            : #else
    2497                 :            :                              args[i].reg != 0,
    2498                 :            : #endif
    2499                 :            :                              reg_parm_stack_space,
    2500                 :    1651270 :                              args[i].pass_on_stack ? 0 : args[i].partial,
    2501                 :            :                              fndecl, args_size, &args[i].locate);
    2502                 :            : #ifdef BLOCK_REG_PADDING
    2503                 :            :       else
    2504                 :            :         /* The argument is passed entirely in registers.  See at which
    2505                 :            :            end it should be padded.  */
    2506                 :            :         args[i].locate.where_pad =
    2507                 :            :           BLOCK_REG_PADDING (arg.mode, type,
    2508                 :            :                              int_size_in_bytes (type) <= UNITS_PER_WORD);
    2509                 :            : #endif
    2510                 :            : 
    2511                 :            :       /* Update ARGS_SIZE, the total stack space for args so far.  */
    2512                 :            : 
    2513                 :    7415380 :       args_size->constant += args[i].locate.size.constant;
    2514                 :    7415380 :       if (args[i].locate.size.var)
    2515                 :          0 :         ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
    2516                 :            : 
    2517                 :            :       /* Increment ARGS_SO_FAR, which has info about which arg-registers
    2518                 :            :          have been used, etc.  */
    2519                 :            : 
    2520                 :            :       /* ??? Traditionally we've passed TYPE_MODE here, instead of the
    2521                 :            :          promoted_mode used for function_arg above.  However, the
    2522                 :            :          corresponding handling of incoming arguments in function.c
    2523                 :            :          does pass the promoted mode.  */
    2524                 :    7415380 :       arg.mode = TYPE_MODE (type);
    2525                 :    7415380 :       targetm.calls.function_arg_advance (args_so_far, arg);
    2526                 :            : 
    2527                 :            :       /* Store argument values for functions decorated with attribute
    2528                 :            :          alloc_size.  */
    2529                 :    7415380 :       if (argpos == alloc_idx[0])
    2530                 :      27824 :         alloc_args[0] = args[i].tree_value;
    2531                 :    7387560 :       else if (argpos == alloc_idx[1])
    2532                 :        658 :         alloc_args[1] = args[i].tree_value;
    2533                 :            : 
    2534                 :            :       /* Save the actual argument that corresponds to the access attribute
    2535                 :            :          operand for later processing.  */
    2536                 :   14830800 :       if (attr_access *access = rdwr_idx.get (argpos))
    2537                 :            :         {
    2538                 :        794 :           if (POINTER_TYPE_P (type))
    2539                 :            :             {
    2540                 :        674 :               access->ptr = args[i].tree_value;
    2541                 :        674 :               gcc_assert (access->size == NULL_TREE);
    2542                 :            :             }
    2543                 :            :           else
    2544                 :            :             {
    2545                 :        120 :               access->size = args[i].tree_value;
    2546                 :        120 :               gcc_assert (access->ptr == NULL_TREE);
    2547                 :            :             }
    2548                 :            :         }
    2549                 :            :     }
    2550                 :            : 
    2551                 :    3876220 :   if (alloc_args[0])
    2552                 :            :     {
    2553                 :            :       /* Check the arguments of functions decorated with attribute
    2554                 :            :          alloc_size.  */
    2555                 :      27824 :       maybe_warn_alloc_args_overflow (fndecl, exp, alloc_args, alloc_idx);
    2556                 :            :     }
    2557                 :            : 
    2558                 :            :   /* Detect passing non-string arguments to functions expecting
    2559                 :            :      nul-terminated strings.  */
    2560                 :    3876220 :   maybe_warn_nonstring_arg (fndecl, exp);
    2561                 :            : 
    2562                 :            :   /* Check read_only, write_only, and read_write arguments.  */
    2563                 :    3876220 :   maybe_warn_rdwr_sizes (&rdwr_idx, exp);
    2564                 :    3876220 : }
    2565                 :            : 
    2566                 :            : /* Update ARGS_SIZE to contain the total size for the argument block.
    2567                 :            :    Return the original constant component of the argument block's size.
    2568                 :            : 
    2569                 :            :    REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
    2570                 :            :    for arguments passed in registers.  */
    2571                 :            : 
    2572                 :            : static poly_int64
    2573                 :    3876220 : compute_argument_block_size (int reg_parm_stack_space,
    2574                 :            :                              struct args_size *args_size,
    2575                 :            :                              tree fndecl ATTRIBUTE_UNUSED,
    2576                 :            :                              tree fntype ATTRIBUTE_UNUSED,
    2577                 :            :                              int preferred_stack_boundary ATTRIBUTE_UNUSED)
    2578                 :            : {
    2579                 :    3876220 :   poly_int64 unadjusted_args_size = args_size->constant;
    2580                 :            : 
    2581                 :            :   /* For accumulate outgoing args mode we don't need to align, since the frame
    2582                 :            :      will be already aligned.  Align to STACK_BOUNDARY in order to prevent
    2583                 :            :      backends from generating misaligned frame sizes.  */
    2584                 :    3876220 :   if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
    2585                 :        414 :     preferred_stack_boundary = STACK_BOUNDARY;
    2586                 :            : 
    2587                 :            :   /* Compute the actual size of the argument block required.  The variable
    2588                 :            :      and constant sizes must be combined, the size may have to be rounded,
    2589                 :            :      and there may be a minimum required size.  */
    2590                 :            : 
    2591                 :    3876220 :   if (args_size->var)
    2592                 :            :     {
    2593                 :          0 :       args_size->var = ARGS_SIZE_TREE (*args_size);
    2594                 :          0 :       args_size->constant = 0;
    2595                 :            : 
    2596                 :          0 :       preferred_stack_boundary /= BITS_PER_UNIT;
    2597                 :          0 :       if (preferred_stack_boundary > 1)
    2598                 :            :         {
    2599                 :            :           /* We don't handle this case yet.  To handle it correctly we have
    2600                 :            :              to add the delta, round and subtract the delta.
    2601                 :            :              Currently no machine description requires this support.  */
    2602                 :          0 :           gcc_assert (multiple_p (stack_pointer_delta,
    2603                 :            :                                   preferred_stack_boundary));
    2604                 :          0 :           args_size->var = round_up (args_size->var, preferred_stack_boundary);
    2605                 :            :         }
    2606                 :            : 
    2607                 :          0 :       if (reg_parm_stack_space > 0)
    2608                 :            :         {
    2609                 :          0 :           args_size->var
    2610                 :          0 :             = size_binop (MAX_EXPR, args_size->var,
    2611                 :            :                           ssize_int (reg_parm_stack_space));
    2612                 :            : 
    2613                 :            :           /* The area corresponding to register parameters is not to count in
    2614                 :            :              the size of the block we need.  So make the adjustment.  */
    2615                 :          0 :           if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
    2616                 :          0 :             args_size->var
    2617                 :          0 :               = size_binop (MINUS_EXPR, args_size->var,
    2618                 :            :                             ssize_int (reg_parm_stack_space));
    2619                 :            :         }
    2620                 :            :     }
    2621                 :            :   else
    2622                 :            :     {
    2623                 :    3876220 :       preferred_stack_boundary /= BITS_PER_UNIT;
    2624                 :    3876220 :       if (preferred_stack_boundary < 1)
    2625                 :      91160 :         preferred_stack_boundary = 1;
    2626                 :    3876220 :       args_size->constant = (aligned_upper_bound (args_size->constant
    2627                 :    3876220 :                                                   + stack_pointer_delta,
    2628                 :    3876220 :                                                   preferred_stack_boundary)
    2629                 :    3876220 :                              - stack_pointer_delta);
    2630                 :            : 
    2631                 :    3876220 :       args_size->constant = upper_bound (args_size->constant,
    2632                 :    3876220 :                                          reg_parm_stack_space);
    2633                 :            : 
    2634                 :    7032750 :       if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
    2635                 :    3840280 :         args_size->constant -= reg_parm_stack_space;
    2636                 :            :     }
    2637                 :    3876220 :   return unadjusted_args_size;
    2638                 :            : }
    2639                 :            : 
    2640                 :            : /* Precompute parameters as needed for a function call.
    2641                 :            : 
    2642                 :            :    FLAGS is mask of ECF_* constants.
    2643                 :            : 
    2644                 :            :    NUM_ACTUALS is the number of arguments.
    2645                 :            : 
    2646                 :            :    ARGS is an array containing information for each argument; this
    2647                 :            :    routine fills in the INITIAL_VALUE and VALUE fields for each
    2648                 :            :    precomputed argument.  */
    2649                 :            : 
    2650                 :            : static void
    2651                 :    3785060 : precompute_arguments (int num_actuals, struct arg_data *args)
    2652                 :            : {
    2653                 :    3785060 :   int i;
    2654                 :            : 
    2655                 :            :   /* If this is a libcall, then precompute all arguments so that we do not
    2656                 :            :      get extraneous instructions emitted as part of the libcall sequence.  */
    2657                 :            : 
    2658                 :            :   /* If we preallocated the stack space, and some arguments must be passed
    2659                 :            :      on the stack, then we must precompute any parameter which contains a
    2660                 :            :      function call which will store arguments on the stack.
    2661                 :            :      Otherwise, evaluating the parameter may clobber previous parameters
    2662                 :            :      which have already been stored into the stack.  (we have code to avoid
    2663                 :            :      such case by saving the outgoing stack arguments, but it results in
    2664                 :            :      worse code)  */
    2665                 :    3785060 :   if (!ACCUMULATE_OUTGOING_ARGS)
    2666                 :    3764530 :     return;
    2667                 :            : 
    2668                 :      73371 :   for (i = 0; i < num_actuals; i++)
    2669                 :            :     {
    2670                 :      52843 :       tree type;
    2671                 :      52843 :       machine_mode mode;
    2672                 :            : 
    2673                 :      52843 :       if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
    2674                 :      52843 :         continue;
    2675                 :            : 
    2676                 :            :       /* If this is an addressable type, we cannot pre-evaluate it.  */
    2677                 :          0 :       type = TREE_TYPE (args[i].tree_value);
    2678                 :          0 :       gcc_assert (!TREE_ADDRESSABLE (type));
    2679                 :            : 
    2680                 :          0 :       args[i].initial_value = args[i].value
    2681                 :          0 :         = expand_normal (args[i].tree_value);
    2682                 :            : 
    2683                 :          0 :       mode = TYPE_MODE (type);
    2684                 :          0 :       if (mode != args[i].mode)
    2685                 :            :         {
    2686                 :          0 :           int unsignedp = args[i].unsignedp;
    2687                 :          0 :           args[i].value
    2688                 :          0 :             = convert_modes (args[i].mode, mode,
    2689                 :            :                              args[i].value, args[i].unsignedp);
    2690                 :            : 
    2691                 :            :           /* CSE will replace this only if it contains args[i].value
    2692                 :            :              pseudo, so convert it down to the declared mode using
    2693                 :            :              a SUBREG.  */
    2694                 :          0 :           if (REG_P (args[i].value)
    2695                 :          0 :               && GET_MODE_CLASS (args[i].mode) == MODE_INT
    2696                 :          0 :               && promote_mode (type, mode, &unsignedp) != args[i].mode)
    2697                 :            :             {
    2698                 :          0 :               args[i].initial_value
    2699                 :          0 :                 = gen_lowpart_SUBREG (mode, args[i].value);
    2700                 :          0 :               SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
    2701                 :          0 :               SUBREG_PROMOTED_SET (args[i].initial_value, args[i].unsignedp);
    2702                 :            :             }
    2703                 :            :         }
    2704                 :            :     }
    2705                 :            : }
    2706                 :            : 
    2707                 :            : /* Given the current state of MUST_PREALLOCATE and information about
    2708                 :            :    arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
    2709                 :            :    compute and return the final value for MUST_PREALLOCATE.  */
    2710                 :            : 
    2711                 :            : static int
    2712                 :    3876220 : finalize_must_preallocate (int must_preallocate, int num_actuals,
    2713                 :            :                            struct arg_data *args, struct args_size *args_size)
    2714                 :            : {
    2715                 :            :   /* See if we have or want to preallocate stack space.
    2716                 :            : 
    2717                 :            :      If we would have to push a partially-in-regs parm
    2718                 :            :      before other stack parms, preallocate stack space instead.
    2719                 :            : 
    2720                 :            :      If the size of some parm is not a multiple of the required stack
    2721                 :            :      alignment, we must preallocate.
    2722                 :            : 
    2723                 :            :      If the total size of arguments that would otherwise create a copy in
    2724                 :            :      a temporary (such as a CALL) is more than half the total argument list
    2725                 :            :      size, preallocation is faster.
    2726                 :            : 
    2727                 :            :      Another reason to preallocate is if we have a machine (like the m88k)
    2728                 :            :      where stack alignment is required to be maintained between every
    2729                 :            :      pair of insns, not just when the call is made.  However, we assume here
    2730                 :            :      that such machines either do not have push insns (and hence preallocation
    2731                 :            :      would occur anyway) or the problem is taken care of with
    2732                 :            :      PUSH_ROUNDING.  */
    2733                 :            : 
    2734                 :    3876220 :   if (! must_preallocate)
    2735                 :            :     {
    2736                 :            :       int partial_seen = 0;
    2737                 :   11215800 :       poly_int64 copy_to_evaluate_size = 0;
    2738                 :            :       int i;
    2739                 :            : 
    2740                 :   11215800 :       for (i = 0; i < num_actuals && ! must_preallocate; i++)
    2741                 :            :         {
    2742                 :    7361340 :           if (args[i].partial > 0 && ! args[i].pass_on_stack)
    2743                 :            :             partial_seen = 1;
    2744                 :    7361340 :           else if (partial_seen && args[i].reg == 0)
    2745                 :          0 :             must_preallocate = 1;
    2746                 :            : 
    2747                 :    7361340 :           if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
    2748                 :    7361340 :               && (TREE_CODE (args[i].tree_value) == CALL_EXPR
    2749                 :     225845 :                   || TREE_CODE (args[i].tree_value) == TARGET_EXPR
    2750                 :     225845 :                   || TREE_CODE (args[i].tree_value) == COND_EXPR
    2751                 :     225845 :                   || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
    2752                 :          0 :             copy_to_evaluate_size
    2753                 :          0 :               += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
    2754                 :            :         }
    2755                 :            : 
    2756                 :    3854500 :       if (maybe_ne (args_size->constant, 0)
    2757                 :    3854500 :           && maybe_ge (copy_to_evaluate_size * 2, args_size->constant))
    2758                 :            :         must_preallocate = 1;
    2759                 :            :     }
    2760                 :    3876220 :   return must_preallocate;
    2761                 :            : }
    2762                 :            : 
    2763                 :            : /* If we preallocated stack space, compute the address of each argument
    2764                 :            :    and store it into the ARGS array.
    2765                 :            : 
    2766                 :            :    We need not ensure it is a valid memory address here; it will be
    2767                 :            :    validized when it is used.
    2768                 :            : 
    2769                 :            :    ARGBLOCK is an rtx for the address of the outgoing arguments.  */
    2770                 :            : 
    2771                 :            : static void
    2772                 :    3876220 : compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
    2773                 :            : {
    2774                 :    3876220 :   if (argblock)
    2775                 :            :     {
    2776                 :     111693 :       rtx arg_reg = argblock;
    2777                 :     111693 :       int i;
    2778                 :     111693 :       poly_int64 arg_offset = 0;
    2779                 :            : 
    2780                 :     111693 :       if (GET_CODE (argblock) == PLUS)
    2781                 :            :         {
    2782                 :          0 :           arg_reg = XEXP (argblock, 0);
    2783                 :          0 :           arg_offset = rtx_to_poly_int64 (XEXP (argblock, 1));
    2784                 :            :         }
    2785                 :            : 
    2786                 :     307615 :       for (i = 0; i < num_actuals; i++)
    2787                 :            :         {
    2788                 :     206727 :           rtx offset = ARGS_SIZE_RTX (args[i].locate.offset);
    2789                 :     206727 :           rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
    2790                 :     195922 :           rtx addr;
    2791                 :     195922 :           unsigned int align, boundary;
    2792                 :     195922 :           poly_uint64 units_on_stack = 0;
    2793                 :     195922 :           machine_mode partial_mode = VOIDmode;
    2794                 :            : 
    2795                 :            :           /* Skip this parm if it will not be passed on the stack.  */
    2796                 :     195922 :           if (! args[i].pass_on_stack
    2797                 :     195922 :               && args[i].reg != 0
    2798                 :     185450 :               && args[i].partial == 0)
    2799                 :     195922 :             continue;
    2800                 :            : 
    2801                 :      10472 :           if (TYPE_EMPTY_P (TREE_TYPE (args[i].tree_value)))
    2802                 :        185 :             continue;
    2803                 :            : 
    2804                 :      18043 :           addr = simplify_gen_binary (PLUS, Pmode, arg_reg, offset);
    2805                 :      18043 :           addr = plus_constant (Pmode, addr, arg_offset);
    2806                 :            : 
    2807                 :      10287 :           if (args[i].partial != 0)
    2808                 :            :             {
    2809                 :            :               /* Only part of the parameter is being passed on the stack.
    2810                 :            :                  Generate a simple memory reference of the correct size.  */
    2811                 :          0 :               units_on_stack = args[i].locate.size.constant;
    2812                 :          0 :               poly_uint64 bits_on_stack = units_on_stack * BITS_PER_UNIT;
    2813                 :          0 :               partial_mode = int_mode_for_size (bits_on_stack, 1).else_blk ();
    2814                 :          0 :               args[i].stack = gen_rtx_MEM (partial_mode, addr);
    2815                 :          0 :               set_mem_size (args[i].stack, units_on_stack);
    2816                 :            :             }
    2817                 :            :           else
    2818                 :            :             {
    2819                 :      10287 :               args[i].stack = gen_rtx_MEM (args[i].mode, addr);
    2820                 :      20574 :               set_mem_attributes (args[i].stack,
    2821                 :      10287 :                                   TREE_TYPE (args[i].tree_value), 1);
    2822                 :            :             }
    2823                 :      10287 :           align = BITS_PER_UNIT;
    2824                 :      10287 :           boundary = args[i].locate.boundary;
    2825                 :      10287 :           poly_int64 offset_val;
    2826                 :      10287 :           if (args[i].locate.where_pad != PAD_DOWNWARD)
    2827                 :            :             align = boundary;
    2828                 :          0 :           else if (poly_int_rtx_p (offset, &offset_val))
    2829                 :            :             {
    2830                 :          0 :               align = least_bit_hwi (boundary);
    2831                 :          0 :               unsigned int offset_align
    2832                 :          0 :                 = known_alignment (offset_val) * BITS_PER_UNIT;
    2833                 :          0 :               if (offset_align != 0)
    2834                 :          0 :                 align = MIN (align, offset_align);
    2835                 :            :             }
    2836                 :      10287 :           set_mem_align (args[i].stack, align);
    2837                 :            : 
    2838                 :      18043 :           addr = simplify_gen_binary (PLUS, Pmode, arg_reg, slot_offset);
    2839                 :      18043 :           addr = plus_constant (Pmode, addr, arg_offset);
    2840                 :            : 
    2841                 :      10287 :           if (args[i].partial != 0)
    2842                 :            :             {
    2843                 :            :               /* Only part of the parameter is being passed on the stack.
    2844                 :            :                  Generate a simple memory reference of the correct size.
    2845                 :            :                */
    2846                 :          0 :               args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
    2847                 :          0 :               set_mem_size (args[i].stack_slot, units_on_stack);
    2848                 :            :             }
    2849                 :            :           else
    2850                 :            :             {
    2851                 :      10287 :               args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
    2852                 :      20574 :               set_mem_attributes (args[i].stack_slot,
    2853                 :      10287 :                                   TREE_TYPE (args[i].tree_value), 1);
    2854                 :            :             }
    2855                 :      10287 :           set_mem_align (args[i].stack_slot, args[i].locate.boundary);
    2856                 :            : 
    2857                 :            :           /* Function incoming arguments may overlap with sibling call
    2858                 :            :              outgoing arguments and we cannot allow reordering of reads
    2859                 :            :              from function arguments with stores to outgoing arguments
    2860                 :            :              of sibling calls.  */
    2861                 :      10287 :           set_mem_alias_set (args[i].stack, 0);
    2862                 :      10287 :           set_mem_alias_set (args[i].stack_slot, 0);
    2863                 :            :         }
    2864                 :            :     }
    2865                 :    3876220 : }
    2866                 :            : 
    2867                 :            : /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
    2868                 :            :    in a call instruction.
    2869                 :            : 
    2870                 :            :    FNDECL is the tree node for the target function.  For an indirect call
    2871                 :            :    FNDECL will be NULL_TREE.
    2872                 :            : 
    2873                 :            :    ADDR is the operand 0 of CALL_EXPR for this call.  */
    2874                 :            : 
    2875                 :            : static rtx
    2876                 :    3876220 : rtx_for_function_call (tree fndecl, tree addr)
    2877                 :            : {
    2878                 :    3876220 :   rtx funexp;
    2879                 :            : 
    2880                 :            :   /* Get the function to call, in the form of RTL.  */
    2881                 :    3876220 :   if (fndecl)
    2882                 :            :     {
    2883                 :    3730970 :       if (!TREE_USED (fndecl) && fndecl != current_function_decl)
    2884                 :     396645 :         TREE_USED (fndecl) = 1;
    2885                 :            : 
    2886                 :            :       /* Get a SYMBOL_REF rtx for the function address.  */
    2887                 :    3730970 :       funexp = XEXP (DECL_RTL (fndecl), 0);
    2888                 :            :     }
    2889                 :            :   else
    2890                 :            :     /* Generate an rtx (probably a pseudo-register) for the address.  */
    2891                 :            :     {
    2892                 :     145248 :       push_temp_slots ();
    2893                 :     145248 :       funexp = expand_normal (addr);
    2894                 :     145248 :       pop_temp_slots ();        /* FUNEXP can't be BLKmode.  */
    2895                 :            :     }
    2896                 :    3876220 :   return funexp;
    2897                 :            : }
    2898                 :            : 
    2899                 :            : /* Return the static chain for this function, if any.  */
    2900                 :            : 
    2901                 :            : rtx
    2902                 :    9643070 : rtx_for_static_chain (const_tree fndecl_or_type, bool incoming_p)
    2903                 :            : {
    2904                 :   19286100 :   if (DECL_P (fndecl_or_type) && !DECL_STATIC_CHAIN (fndecl_or_type))
    2905                 :            :     return NULL;
    2906                 :            : 
    2907                 :     157234 :   return targetm.calls.static_chain (fndecl_or_type, incoming_p);
    2908                 :            : }
    2909                 :            : 
    2910                 :            : /* Internal state for internal_arg_pointer_based_exp and its helpers.  */
    2911                 :            : static struct
    2912                 :            : {
    2913                 :            :   /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
    2914                 :            :      or NULL_RTX if none has been scanned yet.  */
    2915                 :            :   rtx_insn *scan_start;
    2916                 :            :   /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
    2917                 :            :      based on crtl->args.internal_arg_pointer.  The element is NULL_RTX if the
    2918                 :            :      pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
    2919                 :            :      with fixed offset, or PC if this is with variable or unknown offset.  */
    2920                 :            :   vec<rtx> cache;
    2921                 :            : } internal_arg_pointer_exp_state;
    2922                 :            : 
    2923                 :            : static rtx internal_arg_pointer_based_exp (const_rtx, bool);
    2924                 :            : 
    2925                 :            : /* Helper function for internal_arg_pointer_based_exp.  Scan insns in
    2926                 :            :    the tail call sequence, starting with first insn that hasn't been
    2927                 :            :    scanned yet, and note for each pseudo on the LHS whether it is based
    2928                 :            :    on crtl->args.internal_arg_pointer or not, and what offset from that
    2929                 :            :    that pointer it has.  */
    2930                 :            : 
    2931                 :            : static void
    2932                 :       1374 : internal_arg_pointer_based_exp_scan (void)
    2933                 :            : {
    2934                 :       1374 :   rtx_insn *insn, *scan_start = internal_arg_pointer_exp_state.scan_start;
    2935                 :            : 
    2936                 :       1374 :   if (scan_start == NULL_RTX)
    2937                 :       1238 :     insn = get_insns ();
    2938                 :            :   else
    2939                 :        136 :     insn = NEXT_INSN (scan_start);
    2940                 :            : 
    2941                 :       9200 :   while (insn)
    2942                 :            :     {
    2943                 :       7826 :       rtx set = single_set (insn);
    2944                 :       7826 :       if (set && REG_P (SET_DEST (set)) && !HARD_REGISTER_P (SET_DEST (set)))
    2945                 :            :         {
    2946                 :       2397 :           rtx val = NULL_RTX;
    2947                 :       2397 :           unsigned int idx = REGNO (SET_DEST (set)) - FIRST_PSEUDO_REGISTER;
    2948                 :            :           /* Punt on pseudos set multiple times.  */
    2949                 :       2397 :           if (idx < internal_arg_pointer_exp_state.cache.length ()
    2950                 :       2397 :               && (internal_arg_pointer_exp_state.cache[idx]
    2951                 :          0 :                   != NULL_RTX))
    2952                 :          0 :             val = pc_rtx;
    2953                 :            :           else
    2954                 :       2397 :             val = internal_arg_pointer_based_exp (SET_SRC (set), false);
    2955                 :       2397 :           if (val != NULL_RTX)
    2956                 :            :             {
    2957                 :          0 :               if (idx >= internal_arg_pointer_exp_state.cache.length ())
    2958                 :          0 :                 internal_arg_pointer_exp_state.cache
    2959                 :          0 :                   .safe_grow_cleared (idx + 1);
    2960                 :          0 :               internal_arg_pointer_exp_state.cache[idx] = val;
    2961                 :            :             }
    2962                 :            :         }
    2963                 :       7826 :       if (NEXT_INSN (insn) == NULL_RTX)
    2964                 :       1373 :         scan_start = insn;
    2965                 :       9200 :       insn = NEXT_INSN (insn);
    2966                 :            :     }
    2967                 :            : 
    2968                 :       1374 :   internal_arg_pointer_exp_state.scan_start = scan_start;
    2969                 :       1374 : }
    2970                 :            : 
    2971                 :            : /* Compute whether RTL is based on crtl->args.internal_arg_pointer.  Return
    2972                 :            :    NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
    2973                 :            :    it with fixed offset, or PC if this is with variable or unknown offset.
    2974                 :            :    TOPLEVEL is true if the function is invoked at the topmost level.  */
    2975                 :            : 
    2976                 :            : static rtx
    2977                 :      11386 : internal_arg_pointer_based_exp (const_rtx rtl, bool toplevel)
    2978                 :            : {
    2979                 :      11386 :   if (CONSTANT_P (rtl))
    2980                 :            :     return NULL_RTX;
    2981                 :            : 
    2982                 :      11328 :   if (rtl == crtl->args.internal_arg_pointer)
    2983                 :       4024 :     return const0_rtx;
    2984                 :            : 
    2985                 :       7304 :   if (REG_P (rtl) && HARD_REGISTER_P (rtl))
    2986                 :            :     return NULL_RTX;
    2987                 :            : 
    2988                 :       7286 :   poly_int64 offset;
    2989                 :       7286 :   if (GET_CODE (rtl) == PLUS && poly_int_rtx_p (XEXP (rtl, 1), &offset))
    2990                 :            :     {
    2991                 :       2375 :       rtx val = internal_arg_pointer_based_exp (XEXP (rtl, 0), toplevel);
    2992                 :       2375 :       if (val == NULL_RTX || val == pc_rtx)
    2993                 :            :         return val;
    2994                 :       3886 :       return plus_constant (Pmode, val, offset);
    2995                 :            :     }
    2996                 :            : 
    2997                 :            :   /* When called at the topmost level, scan pseudo assignments in between the
    2998                 :            :      last scanned instruction in the tail call sequence and the latest insn
    2999                 :            :      in that sequence.  */
    3000                 :       4911 :   if (toplevel)
    3001                 :       1374 :     internal_arg_pointer_based_exp_scan ();
    3002                 :            : 
    3003                 :       4911 :   if (REG_P (rtl))
    3004                 :            :     {
    3005                 :       2166 :       unsigned int idx = REGNO (rtl) - FIRST_PSEUDO_REGISTER;
    3006                 :       2166 :       if (idx < internal_arg_pointer_exp_state.cache.length ())
    3007                 :          0 :         return internal_arg_pointer_exp_state.cache[idx];
    3008                 :            : 
    3009                 :            :       return NULL_RTX;
    3010                 :            :     }
    3011                 :            : 
    3012                 :       2745 :   subrtx_iterator::array_type array;
    3013                 :       7444 :   FOR_EACH_SUBRTX (iter, array, rtl, NONCONST)
    3014                 :            :     {
    3015                 :       4699 :       const_rtx x = *iter;
    3016                 :       4699 :       if (REG_P (x) && internal_arg_pointer_based_exp (x, false) != NULL_RTX)
    3017                 :          0 :         return pc_rtx;
    3018                 :       4699 :       if (MEM_P (x))
    3019                 :       1587 :         iter.skip_subrtxes ();
    3020                 :            :     }
    3021                 :            : 
    3022                 :       2745 :   return NULL_RTX;
    3023                 :            : }
    3024                 :            : 
    3025                 :            : /* Return true if SIZE bytes starting from address ADDR might overlap an
    3026                 :            :    already-clobbered argument area.  This function is used to determine
    3027                 :            :    if we should give up a sibcall.  */
    3028                 :            : 
    3029                 :            : static bool
    3030                 :      16709 : mem_might_overlap_already_clobbered_arg_p (rtx addr, poly_uint64 size)
    3031                 :            : {
    3032                 :      16709 :   poly_int64 i;
    3033                 :      16709 :   unsigned HOST_WIDE_INT start, end;
    3034                 :      16709 :   rtx val;
    3035                 :            : 
    3036                 :      16709 :   if (bitmap_empty_p (stored_args_map)
    3037                 :      16709 :       && stored_args_watermark == HOST_WIDE_INT_M1U)
    3038                 :            :     return false;
    3039                 :       5418 :   val = internal_arg_pointer_based_exp (addr, true);
    3040                 :       5418 :   if (val == NULL_RTX)
    3041                 :            :     return false;
    3042                 :       4024 :   else if (!poly_int_rtx_p (val, &i))
    3043                 :            :     return true;
    3044                 :            : 
    3045                 :       4024 :   if (known_eq (size, 0U))
    3046                 :            :     return false;
    3047                 :            : 
    3048                 :       4024 :   if (STACK_GROWS_DOWNWARD)
    3049                 :       4024 :     i -= crtl->args.pretend_args_size;
    3050                 :            :   else
    3051                 :            :     i += crtl->args.pretend_args_size;
    3052                 :            : 
    3053                 :       4024 :   if (ARGS_GROW_DOWNWARD)
    3054                 :            :     i = -i - size;
    3055                 :            : 
    3056                 :            :   /* We can ignore any references to the function's pretend args,
    3057                 :            :      which at this point would manifest as negative values of I.  */
    3058                 :       4024 :   if (known_le (i, 0) && known_le (size, poly_uint64 (-i)))
    3059                 :            :     return false;
    3060                 :            : 
    3061                 :       4024 :   start = maybe_lt (i, 0) ? 0 : constant_lower_bound (i);
    3062                 :       4024 :   if (!(i + size).is_constant (&end))
    3063                 :            :     end = HOST_WIDE_INT_M1U;
    3064                 :            : 
    3065                 :       4024 :   if (end > stored_args_watermark)
    3066                 :            :     return true;
    3067                 :            : 
    3068                 :       4024 :   end = MIN (end, SBITMAP_SIZE (stored_args_map));
    3069                 :      23056 :   for (unsigned HOST_WIDE_INT k = start; k < end; ++k)
    3070                 :      19036 :     if (bitmap_bit_p (stored_args_map, k))
    3071                 :            :       return true;
    3072                 :            : 
    3073                 :            :   return false;
    3074                 :            : }
    3075                 :            : 
    3076                 :            : /* Do the register loads required for any wholly-register parms or any
    3077                 :            :    parms which are passed both on the stack and in a register.  Their
    3078                 :            :    expressions were already evaluated.
    3079                 :            : 
    3080                 :            :    Mark all register-parms as living through the call, putting these USE
    3081                 :            :    insns in the CALL_INSN_FUNCTION_USAGE field.
    3082                 :            : 
    3083                 :            :    When IS_SIBCALL, perform the check_sibcall_argument_overlap
    3084                 :            :    checking, setting *SIBCALL_FAILURE if appropriate.  */
    3085                 :            : 
    3086                 :            : static void
    3087                 :    3876220 : load_register_parameters (struct arg_data *args, int num_actuals,
    3088                 :            :                           rtx *call_fusage, int flags, int is_sibcall,
    3089                 :            :                           int *sibcall_failure)
    3090                 :            : {
    3091                 :    3876220 :   int i, j;
    3092                 :            : 
    3093                 :   11291600 :   for (i = 0; i < num_actuals; i++)
    3094                 :            :     {
    3095                 :   14830800 :       rtx reg = ((flags & ECF_SIBCALL)
    3096                 :    7415420 :                  ? args[i].tail_call_reg : args[i].reg);
    3097                 :    7415420 :       if (reg)
    3098                 :            :         {
    3099                 :    5829110 :           int partial = args[i].partial;
    3100                 :    5829110 :           int nregs;
    3101                 :    5829110 :           poly_int64 size = 0;
    3102                 :    5829110 :           HOST_WIDE_INT const_size = 0;
    3103                 :    5829110 :           rtx_insn *before_arg = get_last_insn ();
    3104                 :    5829110 :           tree type = TREE_TYPE (args[i].tree_value);
    3105                 :    5829110 :           if (RECORD_OR_UNION_TYPE_P (type) && TYPE_TRANSPARENT_AGGR (type))
    3106                 :       3014 :             type = TREE_TYPE (first_field (type));
    3107                 :            :           /* Set non-negative if we must move a word at a time, even if
    3108                 :            :              just one word (e.g, partial == 4 && mode == DFmode).  Set
    3109                 :            :              to -1 if we just use a normal move insn.  This value can be
    3110                 :            :              zero if the argument is a zero size structure.  */
    3111                 :    5829110 :           nregs = -1;
    3112                 :    5829110 :           if (GET_CODE (reg) == PARALLEL)
    3113                 :            :             ;
    3114                 :    5653390 :           else if (partial)
    3115                 :            :             {
    3116                 :          0 :               gcc_assert (partial % UNITS_PER_WORD == 0);
    3117                 :          0 :               nregs = partial / UNITS_PER_WORD;
    3118                 :            :             }
    3119                 :    5653390 :           else if (TYPE_MODE (type) == BLKmode)
    3120                 :            :             {
    3121                 :            :               /* Variable-sized parameters should be described by a
    3122                 :            :                  PARALLEL instead.  */
    3123                 :       1201 :               const_size = int_size_in_bytes (type);
    3124                 :       1201 :               gcc_assert (const_size >= 0);
    3125                 :       1201 :               nregs = (const_size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
    3126                 :       1201 :               size = const_size;
    3127                 :            :             }
    3128                 :            :           else
    3129                 :   11304400 :             size = GET_MODE_SIZE (args[i].mode);
    3130                 :            : 
    3131                 :            :           /* Handle calls that pass values in multiple non-contiguous
    3132                 :            :              locations.  The Irix 6 ABI has examples of this.  */
    3133                 :            : 
    3134                 :    5829110 :           if (GET_CODE (reg) == PARALLEL)
    3135                 :     175715 :             emit_group_move (reg, args[i].parallel_value);
    3136                 :            : 
    3137                 :            :           /* If simple case, just do move.  If normal partial, store_one_arg
    3138                 :            :              has already loaded the register for us.  In all other cases,
    3139                 :            :              load the register(s) from memory.  */
    3140                 :            : 
    3141                 :    5653390 :           else if (nregs == -1)
    3142                 :            :             {
    3143                 :    5652190 :               emit_move_insn (reg, args[i].value);
    3144                 :            : #ifdef BLOCK_REG_PADDING
    3145                 :            :               /* Handle case where we have a value that needs shifting
    3146                 :            :                  up to the msb.  eg. a QImode value and we're padding
    3147                 :            :                  upward on a BYTES_BIG_ENDIAN machine.  */
    3148                 :            :               if (args[i].locate.where_pad
    3149                 :            :                   == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))
    3150                 :            :                 {
    3151                 :            :                   gcc_checking_assert (ordered_p (size, UNITS_PER_WORD));
    3152                 :            :                   if (maybe_lt (size, UNITS_PER_WORD))
    3153                 :            :                     {
    3154                 :            :                       rtx x;
    3155                 :            :                       poly_int64 shift
    3156                 :            :                         = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
    3157                 :            : 
    3158                 :            :                       /* Assigning REG here rather than a temp makes
    3159                 :            :                          CALL_FUSAGE report the whole reg as used.
    3160                 :            :                          Strictly speaking, the call only uses SIZE
    3161                 :            :                          bytes at the msb end, but it doesn't seem worth
    3162                 :            :                          generating rtl to say that.  */
    3163                 :            :                       reg = gen_rtx_REG (word_mode, REGNO (reg));
    3164                 :            :                       x = expand_shift (LSHIFT_EXPR, word_mode,
    3165                 :            :                                         reg, shift, reg, 1);
    3166                 :            :                       if (x != reg)
    3167                 :            :                         emit_move_insn (reg, x);
    3168                 :            :                     }
    3169                 :            :                 }
    3170                 :            : #endif
    3171                 :            :             }
    3172                 :            : 
    3173                 :            :           /* If we have pre-computed the values to put in the registers in
    3174                 :            :              the case of non-aligned structures, copy them in now.  */
    3175                 :            : 
    3176                 :       1201 :           else if (args[i].n_aligned_regs != 0)
    3177                 :          0 :             for (j = 0; j < args[i].n_aligned_regs; j++)
    3178                 :          0 :               emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
    3179                 :          0 :                               args[i].aligned_regs[j]);
    3180                 :            : 
    3181                 :       1201 :           else if (partial == 0 || args[i].pass_on_stack)
    3182                 :            :             {
    3183                 :            :               /* SIZE and CONST_SIZE are 0 for partial arguments and
    3184                 :            :                  the size of a BLKmode type otherwise.  */
    3185                 :       1201 :               gcc_checking_assert (known_eq (size, const_size));
    3186                 :       1201 :               rtx mem = validize_mem (copy_rtx (args[i].value));
    3187                 :            : 
    3188                 :            :               /* Check for overlap with already clobbered argument area,
    3189                 :            :                  providing that this has non-zero size.  */
    3190                 :       1201 :               if (is_sibcall
    3191                 :         22 :                   && const_size != 0
    3192                 :       1223 :                   && (mem_might_overlap_already_clobbered_arg_p
    3193                 :       1223 :                       (XEXP (args[i].value, 0), const_size)))
    3194                 :          0 :                 *sibcall_failure = 1;
    3195                 :            : 
    3196                 :       1201 :               if (const_size % UNITS_PER_WORD == 0
    3197                 :       2243 :                   || MEM_ALIGN (mem) % BITS_PER_WORD == 0)
    3198                 :        209 :                 move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode);
    3199                 :            :               else
    3200                 :            :                 {
    3201                 :        992 :                   if (nregs > 1)
    3202                 :          0 :                     move_block_to_reg (REGNO (reg), mem, nregs - 1,
    3203                 :            :                                        args[i].mode);
    3204                 :        992 :                   rtx dest = gen_rtx_REG (word_mode, REGNO (reg) + nregs - 1);
    3205                 :        992 :                   unsigned int bitoff = (nregs - 1) * BITS_PER_WORD;
    3206                 :        992 :                   unsigned int bitsize = const_size * BITS_PER_UNIT - bitoff;
    3207                 :        992 :                   rtx x = extract_bit_field (mem, bitsize, bitoff, 1, dest,
    3208                 :            :                                              word_mode, word_mode, false,
    3209                 :            :                                              NULL);
    3210                 :        992 :                   if (BYTES_BIG_ENDIAN)
    3211                 :            :                     x = expand_shift (LSHIFT_EXPR, word_mode, x,
    3212                 :            :                                       BITS_PER_WORD - bitsize, dest, 1);
    3213                 :        992 :                   if (x != dest)
    3214                 :        990 :                     emit_move_insn (dest, x);
    3215                 :            :                 }
    3216                 :            : 
    3217                 :            :               /* Handle a BLKmode that needs shifting.  */
    3218                 :            :               if (nregs == 1 && const_size < UNITS_PER_WORD
    3219                 :            : #ifdef BLOCK_REG_PADDING
    3220                 :            :                   && args[i].locate.where_pad == PAD_DOWNWARD
    3221                 :            : #else
    3222                 :            :                   && BYTES_BIG_ENDIAN
    3223                 :            : #endif
    3224                 :            :                   )
    3225                 :            :                 {
    3226                 :            :                   rtx dest = gen_rtx_REG (word_mode, REGNO (reg));
    3227                 :            :                   int shift = (UNITS_PER_WORD - const_size) * BITS_PER_UNIT;
    3228                 :            :                   enum tree_code dir = (BYTES_BIG_ENDIAN
    3229                 :            :                                         ? RSHIFT_EXPR : LSHIFT_EXPR);
    3230                 :            :                   rtx x;
    3231                 :            : 
    3232                 :            :                   x = expand_shift (dir, word_mode, dest, shift, dest, 1);
    3233                 :            :                   if (x != dest)
    3234                 :            :                     emit_move_insn (dest, x);
    3235                 :            :                 }
    3236                 :            :             }
    3237                 :            : 
    3238                 :            :           /* When a parameter is a block, and perhaps in other cases, it is
    3239                 :            :              possible that it did a load from an argument slot that was
    3240                 :            :              already clobbered.  */
    3241                 :    5829110 :           if (is_sibcall
    3242                 :    5829110 :               && check_sibcall_argument_overlap (before_arg, &args[i], 0))
    3243                 :          0 :             *sibcall_failure = 1;
    3244                 :            : 
    3245                 :            :           /* Handle calls that pass values in multiple non-contiguous
    3246                 :            :              locations.  The Irix 6 ABI has examples of this.  */
    3247                 :    5829110 :           if (GET_CODE (reg) == PARALLEL)
    3248                 :     175715 :             use_group_regs (call_fusage, reg);
    3249                 :    5653390 :           else if (nregs == -1)
    3250                 :    5652190 :             use_reg_mode (call_fusage, reg, TYPE_MODE (type));
    3251                 :       1201 :           else if (nregs > 0)
    3252                 :       1201 :             use_regs (call_fusage, REGNO (reg), nregs);
    3253                 :            :         }
    3254                 :            :     }
    3255                 :    3876220 : }
    3256                 :            : 
    3257                 :            : /* We need to pop PENDING_STACK_ADJUST bytes.  But, if the arguments
    3258                 :            :    wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
    3259                 :            :    bytes, then we would need to push some additional bytes to pad the
    3260                 :            :    arguments.  So, we try to compute an adjust to the stack pointer for an
    3261                 :            :    amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
    3262                 :            :    bytes.  Then, when the arguments are pushed the stack will be perfectly
    3263                 :            :    aligned.
    3264                 :            : 
    3265                 :            :    Return true if this optimization is possible, storing the adjustment
    3266                 :            :    in ADJUSTMENT_OUT and setting ARGS_SIZE->CONSTANT to the number of
    3267                 :            :    bytes that should be popped after the call.  */
    3268                 :            : 
    3269                 :            : static bool
    3270                 :      10003 : combine_pending_stack_adjustment_and_call (poly_int64_pod *adjustment_out,
    3271                 :            :                                            poly_int64 unadjusted_args_size,
    3272                 :            :                                            struct args_size *args_size,
    3273                 :            :                                            unsigned int preferred_unit_stack_boundary)
    3274                 :            : {
    3275                 :            :   /* The number of bytes to pop so that the stack will be
    3276                 :            :      under-aligned by UNADJUSTED_ARGS_SIZE bytes.  */
    3277                 :      10003 :   poly_int64 adjustment;
    3278                 :            :   /* The alignment of the stack after the arguments are pushed, if we
    3279                 :            :      just pushed the arguments without adjust the stack here.  */
    3280                 :            :   unsigned HOST_WIDE_INT unadjusted_alignment;
    3281                 :            : 
    3282                 :      10003 :   if (!known_misalignment (stack_pointer_delta + unadjusted_args_size,
    3283                 :            :                            preferred_unit_stack_boundary,
    3284                 :            :                            &unadjusted_alignment))
    3285                 :            :     return false;
    3286                 :            : 
    3287                 :            :   /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
    3288                 :            :      as possible -- leaving just enough left to cancel out the
    3289                 :            :      UNADJUSTED_ALIGNMENT.  In other words, we want to ensure that the
    3290                 :            :      PENDING_STACK_ADJUST is non-negative, and congruent to
    3291                 :            :      -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY.  */
    3292                 :            : 
    3293                 :            :   /* Begin by trying to pop all the bytes.  */
    3294                 :      10003 :   unsigned HOST_WIDE_INT tmp_misalignment;
    3295                 :      10003 :   if (!known_misalignment (pending_stack_adjust,
    3296                 :            :                            preferred_unit_stack_boundary,
    3297                 :            :                            &tmp_misalignment))
    3298                 :            :     return false;
    3299                 :      10003 :   unadjusted_alignment -= tmp_misalignment;
    3300                 :      10003 :   adjustment = pending_stack_adjust;
    3301                 :            :   /* Push enough additional bytes that the stack will be aligned
    3302                 :            :      after the arguments are pushed.  */
    3303                 :      10003 :   if (preferred_unit_stack_boundary > 1 && unadjusted_alignment)
    3304                 :       9823 :     adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
    3305                 :            : 
    3306                 :            :   /* We need to know whether the adjusted argument size
    3307                 :            :      (UNADJUSTED_ARGS_SIZE - ADJUSTMENT) constitutes an allocation
    3308                 :            :      or a deallocation.  */
    3309                 :      10003 :   if (!ordered_p (adjustment, unadjusted_args_size))
    3310                 :            :     return false;
    3311                 :            : 
    3312                 :            :   /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
    3313                 :            :      bytes after the call.  The right number is the entire
    3314                 :            :      PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
    3315                 :            :      by the arguments in the first place.  */
    3316                 :            :   args_size->constant
    3317                 :      10003 :     = pending_stack_adjust - adjustment + unadjusted_args_size;
    3318                 :            : 
    3319                 :      10003 :   *adjustment_out = adjustment;
    3320                 :      10003 :   return true;
    3321                 :            : }
    3322                 :            : 
    3323                 :            : /* Scan X expression if it does not dereference any argument slots
    3324                 :            :    we already clobbered by tail call arguments (as noted in stored_args_map
    3325                 :            :    bitmap).
    3326                 :            :    Return nonzero if X expression dereferences such argument slots,
    3327                 :            :    zero otherwise.  */
    3328                 :            : 
    3329                 :            : static int
    3330                 :    1017130 : check_sibcall_argument_overlap_1 (rtx x)
    3331                 :            : {
    3332                 :    1017130 :   RTX_CODE code;
    3333                 :    1017130 :   int i, j;
    3334                 :    1017130 :   const char *fmt;
    3335                 :            : 
    3336                 :    1017130 :   if (x == NULL_RTX)
    3337                 :            :     return 0;
    3338                 :            : 
    3339                 :    1017130 :   code = GET_CODE (x);
    3340                 :            : 
    3341                 :            :   /* We need not check the operands of the CALL expression itself.  */
    3342                 :    1017130 :   if (code == CALL)
    3343                 :            :     return 0;
    3344                 :            : 
    3345                 :     925968 :   if (code == MEM)
    3346                 :      16375 :     return (mem_might_overlap_already_clobbered_arg_p
    3347                 :      32750 :             (XEXP (x, 0), GET_MODE_SIZE (GET_MODE (x))));
    3348                 :            : 
    3349                 :            :   /* Scan all subexpressions.  */
    3350                 :     909593 :   fmt = GET_RTX_FORMAT (code);
    3351                 :    2187280 :   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
    3352                 :            :     {
    3353                 :    1277680 :       if (*fmt == 'e')
    3354                 :            :         {
    3355                 :     637329 :           if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
    3356                 :            :             return 1;
    3357                 :            :         }
    3358                 :     640356 :       else if (*fmt == 'E')
    3359                 :            :         {
    3360                 :       1282 :           for (j = 0; j < XVECLEN (x, i); j++)
    3361                 :        812 :             if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
    3362                 :            :               return 1;
    3363                 :            :         }
    3364                 :            :     }
    3365                 :            :   return 0;
    3366                 :            : }
    3367                 :            : 
    3368                 :            : /* Scan sequence after INSN if it does not dereference any argument slots
    3369                 :            :    we already clobbered by tail call arguments (as noted in stored_args_map
    3370                 :            :    bitmap).  If MARK_STORED_ARGS_MAP, add stack slots for ARG to
    3371                 :            :    stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
    3372                 :            :    should be 0).  Return nonzero if sequence after INSN dereferences such argument
    3373                 :            :    slots, zero otherwise.  */
    3374                 :            : 
    3375                 :            : static int
    3376                 :     234228 : check_sibcall_argument_overlap (rtx_insn *insn, struct arg_data *arg,
    3377                 :            :                                 int mark_stored_args_map)
    3378                 :            : {
    3379                 :     234228 :   poly_uint64 low, high;
    3380                 :     234228 :   unsigned HOST_WIDE_INT const_low, const_high;
    3381                 :            : 
    3382                 :     234228 :   if (insn == NULL_RTX)
    3383                 :     122771 :     insn = get_insns ();
    3384                 :            :   else
    3385                 :     111457 :     insn = NEXT_INSN (insn);
    3386                 :            : 
    3387                 :     613248 :   for (; insn; insn = NEXT_INSN (insn))
    3388                 :     379020 :     if (INSN_P (insn)
    3389                 :     379020 :         && check_sibcall_argument_overlap_1 (PATTERN (insn)))
    3390                 :            :       break;
    3391                 :            : 
    3392                 :     234228 :   if (mark_stored_args_map)
    3393                 :            :     {
    3394                 :       8978 :       if (ARGS_GROW_DOWNWARD)
    3395                 :            :         low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
    3396                 :            :       else
    3397                 :       8978 :         low = arg->locate.slot_offset.constant;
    3398                 :       8978 :       high = low + arg->locate.size.constant;
    3399                 :            : 
    3400                 :       8978 :       const_low = constant_lower_bound (low);
    3401                 :       8978 :       if (high.is_constant (&const_high))
    3402                 :      52558 :         for (unsigned HOST_WIDE_INT i = const_low; i < const_high; ++i)
    3403                 :      43580 :           bitmap_set_bit (stored_args_map, i);
    3404                 :            :       else
    3405                 :            :         stored_args_watermark = MIN (stored_args_watermark, const_low);
    3406                 :            :     }
    3407                 :     234228 :   return insn != NULL_RTX;
    3408                 :            : }
    3409                 :            : 
    3410                 :            : /* Given that a function returns a value of mode MODE at the most
    3411                 :            :    significant end of hard register VALUE, shift VALUE left or right
    3412                 :            :    as specified by LEFT_P.  Return true if some action was needed.  */
    3413                 :            : 
    3414                 :            : bool
    3415                 :          0 : shift_return_value (machine_mode mode, bool left_p, rtx value)
    3416                 :            : {
    3417                 :          0 :   gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
    3418                 :          0 :   machine_mode value_mode = GET_MODE (value);
    3419                 :          0 :   poly_int64 shift = GET_MODE_BITSIZE (value_mode) - GET_MODE_BITSIZE (mode);
    3420                 :            : 
    3421                 :          0 :   if (known_eq (shift, 0))
    3422                 :            :     return false;
    3423                 :            : 
    3424                 :            :   /* Use ashr rather than lshr for right shifts.  This is for the benefit
    3425                 :            :      of the MIPS port, which requires SImode values to be sign-extended
    3426                 :            :      when stored in 64-bit registers.  */
    3427                 :          0 :   if (!force_expand_binop (value_mode, left_p ? ashl_optab : ashr_optab,
    3428                 :            :                            value, gen_int_shift_amount (value_mode, shift),
    3429                 :            :                            value, 1, OPTAB_WIDEN))
    3430                 :          0 :     gcc_unreachable ();
    3431                 :            :   return true;
    3432                 :            : }
    3433                 :            : 
    3434                 :            : /* If X is a likely-spilled register value, copy it to a pseudo
    3435                 :            :    register and return that register.  Return X otherwise.  */
    3436                 :            : 
    3437                 :            : static rtx
    3438                 :     136759 : avoid_likely_spilled_reg (rtx x)
    3439                 :            : {
    3440                 :     136759 :   rtx new_rtx;
    3441                 :            : 
    3442                 :     136759 :   if (REG_P (x)
    3443                 :     136759 :       && HARD_REGISTER_P (x)
    3444                 :     272661 :       && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x))))
    3445                 :            :     {
    3446                 :            :       /* Make sure that we generate a REG rather than a CONCAT.
    3447                 :            :          Moves into CONCATs can need nontrivial instructions,
    3448                 :            :          and the whole point of this function is to avoid
    3449                 :            :          using the hard register directly in such a situation.  */
    3450                 :     135902 :       generating_concat_p = 0;
    3451                 :     135902 :       new_rtx = gen_reg_rtx (GET_MODE (x));
    3452                 :     135902 :       generating_concat_p = 1;
    3453                 :     135902 :       emit_move_insn (new_rtx, x);
    3454                 :     135902 :       return new_rtx;
    3455                 :            :     }
    3456                 :            :   return x;
    3457                 :            : }
    3458                 :            : 
    3459                 :            : /* Helper function for expand_call.
    3460                 :            :    Return false is EXP is not implementable as a sibling call.  */
    3461                 :            : 
    3462                 :            : static bool
    3463                 :      97761 : can_implement_as_sibling_call_p (tree exp,
    3464                 :            :                                  rtx structure_value_addr,
    3465                 :            :                                  tree funtype,
    3466                 :            :                                  int reg_parm_stack_space ATTRIBUTE_UNUSED,
    3467                 :            :                                  tree fndecl,
    3468                 :            :                                  int flags,
    3469                 :            :                                  tree addr,
    3470                 :            :                                  const args_size &args_size)
    3471                 :            : {
    3472                 :      97761 :   if (!targetm.have_sibcall_epilogue ())
    3473                 :            :     {
    3474                 :          0 :       maybe_complain_about_tail_call
    3475                 :          0 :         (exp,
    3476                 :            :          "machine description does not have"
    3477                 :            :          " a sibcall_epilogue instruction pattern");
    3478                 :          0 :       return false;
    3479                 :            :     }
    3480                 :            : 
    3481                 :            :   /* Doing sibling call optimization needs some work, since
    3482                 :            :      structure_value_addr can be allocated on the stack.
    3483                 :            :      It does not seem worth the effort since few optimizable
    3484                 :            :      sibling calls will return a structure.  */
    3485                 :      97761 :   if (structure_value_addr != NULL_RTX)
    3486                 :            :     {
    3487                 :        305 :       maybe_complain_about_tail_call (exp, "callee returns a structure");
    3488                 :        305 :       return false;
    3489                 :            :     }
    3490                 :            : 
    3491                 :            : #ifdef REG_PARM_STACK_SPACE
    3492                 :            :   /* If outgoing reg parm stack space changes, we cannot do sibcall.  */
    3493                 :      97456 :   if (OUTGOING_REG_PARM_STACK_SPACE (funtype)
    3494                 :      97456 :       != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl))
    3495                 :      97456 :       || (reg_parm_stack_space != REG_PARM_STACK_SPACE (current_function_decl)))
    3496                 :            :     {
    3497                 :        776 :       maybe_complain_about_tail_call (exp,
    3498                 :            :                                       "inconsistent size of stack space"
    3499                 :            :                                       " allocated for arguments which are"
    3500                 :            :                                       " passed in registers");
    3501                 :        776 :       return false;
    3502                 :            :     }
    3503                 :            : #endif
    3504                 :            : 
    3505                 :            :   /* Check whether the target is able to optimize the call
    3506                 :            :      into a sibcall.  */
    3507                 :      96680 :   if (!targetm.function_ok_for_sibcall (fndecl, exp))
    3508                 :            :     {
    3509                 :       3705 :       maybe_complain_about_tail_call (exp,
    3510                 :            :                                       "target is not able to optimize the"
    3511                 :            :                                       " call into a sibling call");
    3512                 :       3705 :       return false;
    3513                 :            :     }
    3514                 :            : 
    3515                 :            :   /* Functions that do not return exactly once may not be sibcall
    3516                 :            :      optimized.  */
    3517                 :      92975 :   if (flags & ECF_RETURNS_TWICE)
    3518                 :            :     {
    3519                 :          1 :       maybe_complain_about_tail_call (exp, "callee returns twice");
    3520                 :          1 :       return false;
    3521                 :            :     }
    3522                 :      92974 :   if (flags & ECF_NORETURN)
    3523                 :            :     {
    3524                 :         48 :       maybe_complain_about_tail_call (exp, "callee does not return");
    3525                 :         48 :       return false;
    3526                 :            :     }
    3527                 :            : 
    3528                 :      92926 :   if (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr))))
    3529                 :            :     {
    3530                 :          0 :       maybe_complain_about_tail_call (exp, "volatile function type");
    3531                 :          0 :       return false;
    3532                 :            :     }
    3533                 :            : 
    3534                 :            :   /* If the called function is nested in the current one, it might access
    3535                 :            :      some of the caller's arguments, but could clobber them beforehand if
    3536                 :            :      the argument areas are shared.  */
    3537                 :      92926 :   if (fndecl && decl_function_context (fndecl) == current_function_decl)
    3538                 :            :     {
    3539                 :         55 :       maybe_complain_about_tail_call (exp, "nested function");
    3540                 :         55 :       return false;
    3541                 :            :     }
    3542                 :            : 
    3543                 :            :   /* If this function requires more stack slots than the current
    3544                 :            :      function, we cannot change it into a sibling call.
    3545                 :            :      crtl->args.pretend_args_size is not part of the
    3546                 :            :      stack allocated by our caller.  */
    3547                 :      92871 :   if (maybe_gt (args_size.constant,
    3548                 :            :                 crtl->args.size - crtl->args.pretend_args_size))
    3549                 :            :     {
    3550                 :       1711 :       maybe_complain_about_tail_call (exp,
    3551                 :            :                                       "callee required more stack slots"
    3552                 :            :                                       " than the caller");
    3553                 :       1711 :       return false;
    3554                 :            :     }
    3555                 :            : 
    3556                 :            :   /* If the callee pops its own arguments, then it must pop exactly
    3557                 :            :      the same number of arguments as the current function.  */
    3558                 :      91160 :   if (maybe_ne (targetm.calls.return_pops_args (fndecl, funtype,
    3559                 :      91160 :                                                 args_size.constant),
    3560                 :     182320 :                 targetm.calls.return_pops_args (current_function_decl,
    3561                 :      91160 :                                                 TREE_TYPE
    3562                 :            :                                                 (current_function_decl),
    3563                 :            :                                                 crtl->args.size)))
    3564                 :            :     {
    3565                 :          0 :       maybe_complain_about_tail_call (exp,
    3566                 :            :                                       "inconsistent number of"
    3567                 :            :                                       " popped arguments");
    3568                 :          0 :       return false;
    3569                 :            :     }
    3570                 :            : 
    3571                 :      91160 :   if (!lang_hooks.decls.ok_for_sibcall (fndecl))
    3572                 :            :     {
    3573                 :          0 :       maybe_complain_about_tail_call (exp, "frontend does not support"
    3574                 :            :                                             " sibling call");
    3575                 :          0 :       return false;
    3576                 :            :     }
    3577                 :            : 
    3578                 :            :   /* All checks passed.  */
    3579                 :            :   return true;
    3580                 :            : }
    3581                 :            : 
    3582                 :            : /* Update stack alignment when the parameter is passed in the stack
    3583                 :            :    since the outgoing parameter requires extra alignment on the calling
    3584                 :            :    function side. */
    3585                 :            : 
    3586                 :            : static void
    3587                 :    1686890 : update_stack_alignment_for_call (struct locate_and_pad_arg_data *locate)
    3588                 :            : {
    3589                 :          0 :   if (crtl->stack_alignment_needed < locate->boundary)
    3590                 :       3969 :     crtl->stack_alignment_needed = locate->boundary;
    3591                 :    1686890 :   if (crtl->preferred_stack_boundary < locate->boundary)
    3592                 :       2807 :     crtl->preferred_stack_boundary = locate->boundary;
    3593                 :          0 : }
    3594                 :            : 
    3595                 :            : /* Generate all the code for a CALL_EXPR exp
    3596                 :            :    and return an rtx for its value.
    3597                 :            :    Store the value in TARGET (specified as an rtx) if convenient.
    3598                 :            :    If the value is stored in TARGET then TARGET is returned.
    3599                 :            :    If IGNORE is nonzero, then we ignore the value of the function call.  */
    3600                 :            : 
    3601                 :            : rtx
    3602                 :    3876220 : expand_call (tree exp, rtx target, int ignore)
    3603                 :            : {
    3604                 :            :   /* Nonzero if we are currently expanding a call.  */
    3605                 :    3876220 :   static int currently_expanding_call = 0;
    3606                 :            : 
    3607                 :            :   /* RTX for the function to be called.  */
    3608                 :    3876220 :   rtx funexp;
    3609                 :            :   /* Sequence of insns to perform a normal "call".  */
    3610                 :    3876220 :   rtx_insn *normal_call_insns = NULL;
    3611                 :            :   /* Sequence of insns to perform a tail "call".  */
    3612                 :    3876220 :   rtx_insn *tail_call_insns = NULL;
    3613                 :            :   /* Data type of the function.  */
    3614                 :    3876220 :   tree funtype;
    3615                 :    3876220 :   tree type_arg_types;
    3616                 :    3876220 :   tree rettype;
    3617                 :            :   /* Declaration of the function being called,
    3618                 :            :      or 0 if the function is computed (not known by name).  */
    3619                 :    3876220 :   tree fndecl = 0;
    3620                 :            :   /* The type of the function being called.  */
    3621                 :    3876220 :   tree fntype;
    3622                 :    3876220 :   bool try_tail_call = CALL_EXPR_TAILCALL (exp);
    3623                 :    3876220 :   bool must_tail_call = CALL_EXPR_MUST_TAIL_CALL (exp);
    3624                 :    3876220 :   int pass;
    3625                 :            : 
    3626                 :            :   /* Register in which non-BLKmode value will be returned,
    3627                 :            :      or 0 if no value or if value is BLKmode.  */
    3628                 :    3876220 :   rtx valreg;
    3629                 :            :   /* Address where we should return a BLKmode value;
    3630                 :            :      0 if value not BLKmode.  */
    3631                 :    3876220 :   rtx structure_value_addr = 0;
    3632                 :            :   /* Nonzero if that address is being passed by treating it as
    3633                 :            :      an extra, implicit first parameter.  Otherwise,
    3634                 :            :      it is passed by being copied directly into struct_value_rtx.  */
    3635                 :    3876220 :   int structure_value_addr_parm = 0;
    3636                 :            :   /* Holds the value of implicit argument for the struct value.  */
    3637                 :    3876220 :   tree structure_value_addr_value = NULL_TREE;
    3638                 :            :   /* Size of aggregate value wanted, or zero if none wanted
    3639                 :            :      or if we are using the non-reentrant PCC calling convention
    3640                 :            :      or expecting the value in registers.  */
    3641                 :    3876220 :   poly_int64 struct_value_size = 0;
    3642                 :            :   /* Nonzero if called function returns an aggregate in memory PCC style,
    3643                 :            :      by returning the address of where to find it.  */
    3644                 :    3876220 :   int pcc_struct_value = 0;
    3645                 :    3876220 :   rtx struct_value = 0;
    3646                 :            : 
    3647                 :            :   /* Number of actual parameters in this call, including struct value addr.  */
    3648                 :    3876220 :   int num_actuals;
    3649                 :            :   /* Number of named args.  Args after this are anonymous ones
    3650                 :            :      and they must all go on the stack.  */
    3651                 :    3876220 :   int n_named_args;
    3652                 :            :   /* Number of complex actual arguments that need to be split.  */
    3653                 :    3876220 :   int num_complex_actuals = 0;
    3654                 :            : 
    3655                 :            :   /* Vector of information about each argument.
    3656                 :            :      Arguments are numbered in the order they will be pushed,
    3657                 :            :      not the order they are written.  */
    3658                 :    3876220 :   struct arg_data *args;
    3659                 :            : 
    3660                 :            :   /* Total size in bytes of all the stack-parms scanned so far.  */
    3661                 :    3876220 :   struct args_size args_size;
    3662                 :    3876220 :   struct args_size adjusted_args_size;
    3663                 :            :   /* Size of arguments before any adjustments (such as rounding).  */
    3664                 :    3876220 :   poly_int64 unadjusted_args_size;
    3665                 :            :   /* Data on reg parms scanned so far.  */
    3666                 :    3876220 :   CUMULATIVE_ARGS args_so_far_v;
    3667                 :    3876220 :   cumulative_args_t args_so_far;
    3668                 :            :   /* Nonzero if a reg parm has been scanned.  */
    3669                 :    3876220 :   int reg_parm_seen;
    3670                 :            :   /* Nonzero if this is an indirect function call.  */
    3671                 :            : 
    3672                 :            :   /* Nonzero if we must avoid push-insns in the args for this call.
    3673                 :            :      If stack space is allocated for register parameters, but not by the
    3674                 :            :      caller, then it is preallocated in the fixed part of the stack frame.
    3675                 :            :      So the entire argument block must then be preallocated (i.e., we
    3676                 :            :      ignore PUSH_ROUNDING in that case).  */
    3677                 :            : 
    3678                 :    3876220 :   int must_preallocate = !PUSH_ARGS;
    3679                 :            : 
    3680                 :            :   /* Size of the stack reserved for parameter registers.  */
    3681                 :    3876220 :   int reg_parm_stack_space = 0;
    3682                 :            : 
    3683                 :            :   /* Address of space preallocated for stack parms
    3684                 :            :      (on machines that lack push insns), or 0 if space not preallocated.  */
    3685                 :    3876220 :   rtx argblock = 0;
    3686                 :            : 
    3687                 :            :   /* Mask of ECF_ and ERF_ flags.  */
    3688                 :    3876220 :   int flags = 0;
    3689                 :    3876220 :   int return_flags = 0;
    3690                 :            : #ifdef REG_PARM_STACK_SPACE
    3691                 :            :   /* Define the boundary of the register parm stack space that needs to be
    3692                 :            :      saved, if any.  */
    3693                 :    3876220 :   int low_to_save, high_to_save;
    3694                 :    3876220 :   rtx save_area = 0;            /* Place that it is saved */
    3695                 :            : #endif
    3696                 :            : 
    3697                 :    3876220 :   unsigned int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
    3698                 :    3876220 :   char *initial_stack_usage_map = stack_usage_map;
    3699                 :    3876220 :   unsigned HOST_WIDE_INT initial_stack_usage_watermark = stack_usage_watermark;
    3700                 :    3876220 :   char *stack_usage_map_buf = NULL;
    3701                 :            : 
    3702                 :    3876220 :   poly_int64 old_stack_allocated;
    3703                 :            : 
    3704                 :            :   /* State variables to track stack modifications.  */
    3705                 :    3876220 :   rtx old_stack_level = 0;
    3706                 :    3876220 :   int old_stack_arg_under_construction = 0;
    3707                 :    3876220 :   poly_int64 old_pending_adj = 0;
    3708                 :    3876220 :   int old_inhibit_defer_pop = inhibit_defer_pop;
    3709                 :            : 
    3710                 :            :   /* Some stack pointer alterations we make are performed via
    3711                 :            :      allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
    3712                 :            :      which we then also need to save/restore along the way.  */
    3713                 :    3876220 :   poly_int64 old_stack_pointer_delta = 0;
    3714                 :            : 
    3715                 :    3876220 :   rtx call_fusage;
    3716                 :    3876220 :   tree addr = CALL_EXPR_FN (exp);
    3717                 :    3876220 :   int i;
    3718                 :            :   /* The alignment of the stack, in bits.  */
    3719                 :    3876220 :   unsigned HOST_WIDE_INT preferred_stack_boundary;
    3720                 :            :   /* The alignment of the stack, in bytes.  */
    3721                 :    3876220 :   unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
    3722                 :            :   /* The static chain value to use for this call.  */
    3723                 :    3876220 :   rtx static_chain_value;
    3724                 :            :   /* See if this is "nothrow" function call.  */
    3725                 :    3876220 :   if (TREE_NOTHROW (exp))
    3726                 :    1318300 :     flags |= ECF_NOTHROW;
    3727                 :            : 
    3728                 :            :   /* See if we can find a DECL-node for the actual function, and get the
    3729                 :            :      function attributes (flags) from the function decl or type node.  */
    3730                 :    3876220 :   fndecl = get_callee_fndecl (exp);
    3731                 :    3876220 :   if (fndecl)
    3732                 :            :     {
    3733                 :    3730970 :       fntype = TREE_TYPE (fndecl);
    3734                 :    3730970 :       flags |= flags_from_decl_or_type (fndecl);
    3735                 :    3730970 :       return_flags |= decl_return_flags (fndecl);
    3736                 :            :     }
    3737                 :            :   else
    3738                 :            :     {
    3739                 :     145248 :       fntype = TREE_TYPE (TREE_TYPE (addr));
    3740                 :     145248 :       flags |= flags_from_decl_or_type (fntype);
    3741                 :     145248 :       if (CALL_EXPR_BY_DESCRIPTOR (exp))
    3742                 :          0 :         flags |= ECF_BY_DESCRIPTOR;
    3743                 :            :     }
    3744                 :    3876220 :   rettype = TREE_TYPE (exp);
    3745                 :            : 
    3746                 :    3876220 :   struct_value = targetm.calls.struct_value_rtx (fntype, 0);
    3747                 :            : 
    3748                 :            :   /* Warn if this value is an aggregate type,
    3749                 :            :      regardless of which calling convention we are using for it.  */
    3750                 :    3876220 :   if (AGGREGATE_TYPE_P (rettype))
    3751                 :     268990 :     warning (OPT_Waggregate_return, "function call has aggregate value");
    3752                 :            : 
    3753                 :            :   /* If the result of a non looping pure or const function call is
    3754                 :            :      ignored (or void), and none of its arguments are volatile, we can
    3755                 :            :      avoid expanding the call and just evaluate the arguments for
    3756                 :            :      side-effects.  */
    3757                 :    3876220 :   if ((flags & (ECF_CONST | ECF_PURE))
    3758                 :     185897 :       && (!(flags & ECF_LOOPING_CONST_OR_PURE))
    3759                 :    4032500 :       && (ignore || target == const0_rtx
    3760                 :     156288 :           || TYPE_MODE (rettype) == VOIDmode))
    3761                 :            :     {
    3762                 :          1 :       bool volatilep = false;
    3763                 :          1 :       tree arg;
    3764                 :          1 :       call_expr_arg_iterator iter;
    3765                 :            : 
    3766                 :          3 :       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
    3767                 :          3 :         if (TREE_THIS_VOLATILE (arg))
    3768                 :            :           {
    3769                 :            :             volatilep = true;
    3770                 :            :             break;
    3771                 :            :           }
    3772                 :            : 
    3773                 :          1 :       if (! volatilep)
    3774                 :            :         {
    3775                 :          0 :           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
    3776                 :          0 :             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
    3777                 :          0 :           return const0_rtx;
    3778                 :            :         }
    3779                 :            :     }
    3780                 :            : 
    3781                 :            : #ifdef REG_PARM_STACK_SPACE
    3782                 :    7607180 :   reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl);
    3783                 :            : #endif
    3784                 :            : 
    3785                 :    6430110 :   if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
    3786                 :    7113850 :       && reg_parm_stack_space > 0 && PUSH_ARGS)
    3787                 :          0 :     must_preallocate = 1;
    3788                 :            : 
    3789                 :            :   /* Set up a place to return a structure.  */
    3790                 :            : 
    3791                 :            :   /* Cater to broken compilers.  */
    3792                 :    3876220 :   if (aggregate_value_p (exp, fntype))
    3793                 :            :     {
    3794                 :            :       /* This call returns a big structure.  */
    3795                 :     175743 :       flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
    3796                 :            : 
    3797                 :            : #ifdef PCC_STATIC_STRUCT_RETURN
    3798                 :            :       {
    3799                 :            :         pcc_struct_value = 1;
    3800                 :            :       }
    3801                 :            : #else /* not PCC_STATIC_STRUCT_RETURN */
    3802                 :     175743 :       {
    3803                 :     175743 :         if (!poly_int_tree_p (TYPE_SIZE_UNIT (rettype), &struct_value_size))
    3804                 :         42 :           struct_value_size = -1;
    3805                 :            : 
    3806                 :            :         /* Even if it is semantically safe to use the target as the return
    3807                 :            :            slot, it may be not sufficiently aligned for the return type.  */
    3808                 :     175743 :         if (CALL_EXPR_RETURN_SLOT_OPT (exp)
    3809                 :     169853 :             && target
    3810                 :     169809 :             && MEM_P (target)
    3811                 :            :             /* If rettype is addressable, we may not create a temporary.
    3812                 :            :                If target is properly aligned at runtime and the compiler
    3813                 :            :                just doesn't know about it, it will work fine, otherwise it
    3814                 :            :                will be UB.  */
    3815                 :     175743 :             && (TREE_ADDRESSABLE (rettype)
    3816                 :     109275 :                 || !(MEM_ALIGN (target) < TYPE_ALIGN (rettype)
    3817                 :          0 :                      && targetm.slow_unaligned_access (TYPE_MODE (rettype),
    3818                 :     122164 :                                                        MEM_ALIGN (target)))))
    3819                 :     122164 :           structure_value_addr = XEXP (target, 0);
    3820                 :            :         else
    3821                 :            :           {
    3822                 :            :             /* For variable-sized objects, we must be called with a target
    3823                 :            :                specified.  If we were to allocate space on the stack here,
    3824                 :            :                we would have no way of knowing when to free it.  */
    3825                 :      53579 :             rtx d = assign_temp (rettype, 1, 1);
    3826                 :      53579 :             structure_value_addr = XEXP (d, 0);
    3827                 :      53579 :             target = 0;
    3828                 :            :           }
    3829                 :            :       }
    3830                 :            : #endif /* not PCC_STATIC_STRUCT_RETURN */
    3831                 :            :     }
    3832                 :            : 
    3833                 :            :   /* Figure out the amount to which the stack should be aligned.  */
    3834                 :    3876220 :   preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
    3835                 :    3876220 :   if (fndecl)
    3836                 :            :     {
    3837                 :    3730970 :       struct cgraph_rtl_info *i = cgraph_node::rtl_info (fndecl);
    3838                 :            :       /* Without automatic stack alignment, we can't increase preferred
    3839                 :            :          stack boundary.  With automatic stack alignment, it is
    3840                 :            :          unnecessary since unless we can guarantee that all callers will
    3841                 :            :          align the outgoing stack properly, callee has to align its
    3842                 :            :          stack anyway.  */
    3843                 :    3730970 :       if (i
    3844                 :     802383 :           && i->preferred_incoming_stack_boundary
    3845                 :     596687 :           && i->preferred_incoming_stack_boundary < preferred_stack_boundary)
    3846                 :     198643 :         preferred_stack_boundary = i->preferred_incoming_stack_boundary;
    3847                 :            :     }
    3848                 :            : 
    3849                 :            :   /* Operand 0 is a pointer-to-function; get the type of the function.  */
    3850                 :    3876220 :   funtype = TREE_TYPE (addr);
    3851                 :    3876220 :   gcc_assert (POINTER_TYPE_P (funtype));
    3852                 :    3876220 :   funtype = TREE_TYPE (funtype);
    3853                 :            : 
    3854                 :            :   /* Count whether there are actual complex arguments that need to be split
    3855                 :            :      into their real and imaginary parts.  Munge the type_arg_types
    3856                 :            :      appropriately here as well.  */
    3857                 :    3876220 :   if (targetm.calls.split_complex_arg)
    3858                 :            :     {
    3859                 :          0 :       call_expr_arg_iterator iter;
    3860                 :          0 :       tree arg;
    3861                 :          0 :       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
    3862                 :            :         {
    3863                 :          0 :           tree type = TREE_TYPE (arg);
    3864                 :          0 :           if (type && TREE_CODE (type) == COMPLEX_TYPE
    3865                 :          0 :               && targetm.calls.split_complex_arg (type))
    3866                 :          0 :             num_complex_actuals++;
    3867                 :            :         }
    3868                 :          0 :       type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
    3869                 :            :     }
    3870                 :            :   else
    3871                 :    4381980 :     type_arg_types = TYPE_ARG_TYPES (funtype);
    3872                 :            : 
    3873                 :    3876220 :   if (flags & ECF_MAY_BE_ALLOCA)
    3874                 :         26 :     cfun->calls_alloca = 1;
    3875                 :            : 
    3876                 :            :   /* If struct_value_rtx is 0, it means pass the address
    3877                 :            :      as if it were an extra parameter.  Put the argument expression
    3878                 :            :      in structure_value_addr_value.  */
    3879                 :    3876220 :   if (structure_value_addr && struct_value == 0)
    3880                 :            :     {
    3881                 :            :       /* If structure_value_addr is a REG other than
    3882                 :            :          virtual_outgoing_args_rtx, we can use always use it.  If it
    3883                 :            :          is not a REG, we must always copy it into a register.
    3884                 :            :          If it is virtual_outgoing_args_rtx, we must copy it to another
    3885                 :            :          register in some cases.  */
    3886                 :     175743 :       rtx temp = (!REG_P (structure_value_addr)
    3887                 :       2015 :                   || (ACCUMULATE_OUTGOING_ARGS
    3888                 :          0 :                       && stack_arg_under_construction
    3889                 :          0 :                       && structure_value_addr == virtual_outgoing_args_rtx)
    3890                 :     349471 :                   ? copy_addr_to_reg (convert_memory_address
    3891                 :            :                                       (Pmode, structure_value_addr))
    3892                 :     175743 :                   : structure_value_addr);
    3893                 :            : 
    3894                 :     175743 :       structure_value_addr_value =
    3895                 :     175743 :         make_tree (build_pointer_type (TREE_TYPE (funtype)), temp);
    3896                 :     175743 :       structure_value_addr_parm = 1;
    3897                 :            :     }
    3898                 :            : 
    3899                 :            :   /* Count the arguments and set NUM_ACTUALS.  */
    3900                 :    3876220 :   num_actuals =
    3901                 :    3876220 :     call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm;
    3902                 :            : 
    3903                 :            :   /* Compute number of named args.
    3904                 :            :      First, do a raw count of the args for INIT_CUMULATIVE_ARGS.  */
    3905                 :            : 
    3906                 :    3876220 :   if (type_arg_types != 0)
    3907                 :    3852450 :     n_named_args
    3908                 :    3852450 :       = (list_length (type_arg_types)
    3909                 :            :          /* Count the struct value address, if it is passed as a parm.  */
    3910                 :            :          + structure_value_addr_parm);
    3911                 :            :   else
    3912                 :            :     /* If we know nothing, treat all args as named.  */
    3913                 :            :     n_named_args = num_actuals;
    3914                 :            : 
    3915                 :            :   /* Start updating where the next arg would go.
    3916                 :            : 
    3917                 :            :      On some machines (such as the PA) indirect calls have a different
    3918                 :            :      calling convention than normal calls.  The fourth argument in
    3919                 :            :      INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
    3920                 :            :      or not.  */
    3921                 :    3876220 :   INIT_CUMULATIVE_ARGS (args_so_far_v, funtype, NULL_RTX, fndecl, n_named_args);
    3922                 :    3876220 :   args_so_far = pack_cumulative_args (&args_so_far_v);
    3923                 :            : 
    3924                 :            :   /* Now possibly adjust the number of named args.
    3925                 :            :      Normally, don't include the last named arg if anonymous args follow.
    3926                 :            :      We do include the last named arg if
    3927                 :            :      targetm.calls.strict_argument_naming() returns nonzero.
    3928                 :            :      (If no anonymous args follow, the result of list_length is actually
    3929                 :            :      one too large.  This is harmless.)
    3930                 :            : 
    3931                 :            :      If targetm.calls.pretend_outgoing_varargs_named() returns
    3932                 :            :      nonzero, and targetm.calls.strict_argument_naming() returns zero,
    3933                 :            :      this machine will be able to place unnamed args that were passed
    3934                 :            :      in registers into the stack.  So treat all args as named.  This
    3935                 :            :      allows the insns emitting for a specific argument list to be
    3936                 :            :      independent of the function declaration.
    3937                 :            : 
    3938                 :            :      If targetm.calls.pretend_outgoing_varargs_named() returns zero,
    3939                 :            :      we do not have any reliable way to pass unnamed args in
    3940                 :            :      registers, so we must force them into memory.  */
    3941                 :            : 
    3942                 :    3876220 :   if (type_arg_types != 0
    3943                 :    3876220 :       && targetm.calls.strict_argument_naming (args_so_far))
    3944                 :            :     ;
    3945                 :      23764 :   else if (type_arg_types != 0
    3946                 :      23764 :            && ! targetm.calls.pretend_outgoing_varargs_named (args_so_far))
    3947                 :            :     /* Don't include the last named arg.  */
    3948                 :          0 :     --n_named_args;
    3949                 :            :   else
    3950                 :            :     /* Treat all args as named.  */
    3951                 :            :     n_named_args = num_actuals;
    3952                 :            : 
    3953                 :            :   /* Make a vector to hold all the information about each arg.  */
    3954                 :    3876220 :   args = XCNEWVEC (struct arg_data, num_actuals);
    3955                 :            : 
    3956                 :            :   /* Build up entries in the ARGS array, compute the size of the
    3957                 :            :      arguments into ARGS_SIZE, etc.  */
    3958                 :    3876220 :   initialize_argument_information (num_actuals, args, &args_size,
    3959                 :            :                                    n_named_args, exp,
    3960                 :            :                                    structure_value_addr_value, fndecl, fntype,
    3961                 :            :                                    args_so_far, reg_parm_stack_space,
    3962                 :            :                                    &old_stack_level, &old_pending_adj,
    3963                 :            :                                    &must_preallocate, &flags,
    3964                 :    3876220 :                                    &try_tail_call, CALL_FROM_THUNK_P (exp));
    3965                 :            : 
    3966                 :    3876220 :   if (args_size.var)
    3967                 :          0 :     must_preallocate = 1;
    3968                 :            : 
    3969                 :            :   /* Now make final decision about preallocating stack space.  */
    3970                 :    3876220 :   must_preallocate = finalize_must_preallocate (must_preallocate,
    3971                 :            :                                                 num_actuals, args,
    3972                 :            :                                                 &args_size);
    3973                 :            : 
    3974                 :            :   /* If the structure value address will reference the stack pointer, we
    3975                 :            :      must stabilize it.  We don't need to do this if we know that we are
    3976                 :            :      not going to adjust the stack pointer in processing this call.  */
    3977                 :            : 
    3978                 :    3876220 :   if (structure_value_addr
    3979                 :     175743 :       && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
    3980                 :     175743 :           || reg_mentioned_p (virtual_outgoing_args_rtx,
    3981                 :            :                               structure_value_addr))
    3982                 :    3876220 :       && (args_size.var
    3983                 :          0 :           || (!ACCUMULATE_OUTGOING_ARGS
    3984                 :          0 :               && maybe_ne (args_size.constant, 0))))
    3985                 :          0 :     structure_value_addr = copy_to_reg (structure_value_addr);
    3986                 :            : 
    3987                 :            :   /* Tail calls can make things harder to debug, and we've traditionally
    3988                 :            :      pushed these optimizations into -O2.  Don't try if we're already
    3989                 :            :      expanding a call, as that means we're an argument.  Don't try if
    3990                 :            :      there's cleanups, as we know there's code to follow the call.  */
    3991                 :    3876220 :   if (currently_expanding_call++ != 0
    3992                 :    5958550 :       || (!flag_optimize_sibling_calls && !CALL_FROM_THUNK_P (exp))
    3993                 :    1798080 :       || args_size.var
    3994                 :    5674300 :       || dbg_cnt (tail_call) == false)
    3995                 :    2078130 :     try_tail_call = 0;
    3996                 :            : 
    3997                 :            :   /* Workaround buggy C/C++ wrappers around Fortran routines with
    3998                 :            :      character(len=constant) arguments if the hidden string length arguments
    3999                 :            :      are passed on the stack; if the callers forget to pass those arguments,
    4000                 :            :      attempting to tail call in such routines leads to stack corruption.
    4001                 :            :      Avoid tail calls in functions where at least one such hidden string
    4002                 :            :      length argument is passed (partially or fully) on the stack in the
    4003                 :            :      caller and the callee needs to pass any arguments on the stack.
    4004                 :            :      See PR90329.  */
    4005                 :    3876220 :   if (try_tail_call && maybe_ne (args_size.constant, 0))
    4006                 :      40308 :     for (tree arg = DECL_ARGUMENTS (current_function_decl);
    4007                 :      40308 :          arg; arg = DECL_CHAIN (arg))
    4008                 :      28900 :       if (DECL_HIDDEN_STRING_LENGTH (arg) && DECL_INCOMING_RTL (arg))
    4009                 :            :         {
    4010                 :          0 :           subrtx_iterator::array_type array;
    4011                 :          0 :           FOR_EACH_SUBRTX (iter, array, DECL_INCOMING_RTL (arg), NONCONST)
    4012                 :          0 :             if (MEM_P (*iter))
    4013                 :            :               {
    4014                 :          0 :                 try_tail_call = 0;
    4015                 :          0 :                 break;
    4016                 :            :               }
    4017                 :            :         }
    4018                 :            : 
    4019                 :            :   /* If the user has marked the function as requiring tail-call
    4020                 :            :      optimization, attempt it.  */
    4021                 :    3876220 :   if (must_tail_call)
    4022                 :         14 :     try_tail_call = 1;
    4023                 :            : 
    4024                 :            :   /*  Rest of purposes for tail call optimizations to fail.  */
    4025                 :    3876220 :   if (try_tail_call)
    4026                 :      97761 :     try_tail_call = can_implement_as_sibling_call_p (exp,
    4027                 :            :                                                      structure_value_addr,
    4028                 :            :                                                      funtype,
    4029                 :            :                                                      reg_parm_stack_space,
    4030                 :            :                                                      fndecl,
    4031                 :            :                                                      flags, addr, args_size);
    4032                 :            : 
    4033                 :            :   /* Check if caller and callee disagree in promotion of function
    4034                 :            :      return value.  */
    4035                 :    3876220 :   if (try_tail_call)
    4036                 :            :     {
    4037                 :      91160 :       machine_mode caller_mode, caller_promoted_mode;
    4038                 :      91160 :       machine_mode callee_mode, callee_promoted_mode;
    4039                 :      91160 :       int caller_unsignedp, callee_unsignedp;
    4040                 :      91160 :       tree caller_res = DECL_RESULT (current_function_decl);
    4041                 :            : 
    4042                 :      91160 :       caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
    4043                 :      91160 :       caller_mode = DECL_MODE (caller_res);
    4044                 :      91160 :       callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
    4045                 :      91160 :       callee_mode = TYPE_MODE (TREE_TYPE (funtype));
    4046                 :      91160 :       caller_promoted_mode
    4047                 :      91160 :         = promote_function_mode (TREE_TYPE (caller_res), caller_mode,
    4048                 :            :                                  &caller_unsignedp,
    4049                 :      91160 :                                  TREE_TYPE (current_function_decl), 1);
    4050                 :      91160 :       callee_promoted_mode
    4051                 :      91160 :         = promote_function_mode (TREE_TYPE (funtype), callee_mode,
    4052                 :            :                                  &callee_unsignedp,
    4053                 :            :                                  funtype, 1);
    4054                 :      91160 :       if (caller_mode != VOIDmode
    4055                 :      91160 :           && (caller_promoted_mode != callee_promoted_mode
    4056                 :      14790 :               || ((caller_mode != caller_promoted_mode
    4057                 :      14790 :                    || callee_mode != callee_promoted_mode)
    4058                 :          0 :                   && (caller_unsignedp != callee_unsignedp
    4059                 :          0 :                       || partial_subreg_p (caller_mode, callee_mode)))))
    4060                 :            :         {
    4061                 :          0 :           try_tail_call = 0;
    4062                 :          0 :           maybe_complain_about_tail_call (exp,
    4063                 :            :                                           "caller and callee disagree in"
    4064                 :            :                                           " promotion of function"
    4065                 :            :                                           " return value");
    4066                 :            :         }
    4067                 :            :     }
    4068                 :            : 
    4069                 :            :   /* Ensure current function's preferred stack boundary is at least
    4070                 :            :      what we need.  Stack alignment may also increase preferred stack
    4071                 :            :      boundary.  */
    4072                 :   11291600 :   for (i = 0; i < num_actuals; i++)
    4073                 :    7415380 :     if (reg_parm_stack_space > 0
    4074                 :    7338770 :         || args[i].reg == 0
    4075                 :    5764110 :         || args[i].partial != 0
    4076                 :    5764110 :         || args[i].pass_on_stack)
    4077                 :    9066650 :       update_stack_alignment_for_call (&args[i].locate);
    4078                 :    3876220 :   if (crtl->preferred_stack_boundary < preferred_stack_boundary)
    4079                 :     543854 :     crtl->preferred_stack_boundary = preferred_stack_boundary;
    4080                 :            :   else
    4081                 :            :     preferred_stack_boundary = crtl->preferred_stack_boundary;
    4082                 :            : 
    4083                 :    3876220 :   preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
    4084                 :            : 
    4085                 :    3876220 :   if (flag_callgraph_info)
    4086                 :          0 :     record_final_call (fndecl, EXPR_LOCATION (exp));
    4087                 :            : 
    4088                 :            :   /* We want to make two insn chains; one for a sibling call, the other
    4089                 :            :      for a normal call.  We will select one of the two chains after
    4090                 :            :      initial RTL generation is complete.  */
    4091                 :    7778390 :   for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
    4092                 :            :     {
    4093                 :    3876220 :       int sibcall_failure = 0;
    4094                 :            :       /* We want to emit any pending stack adjustments before the tail
    4095                 :            :          recursion "call".  That way we know any adjustment after the tail
    4096                 :            :          recursion call can be ignored if we indeed use the tail
    4097                 :            :          call expansion.  */
    4098                 :    3876220 :       saved_pending_stack_adjust save;
    4099                 :    3876220 :       rtx_insn *insns, *before_call, *after_args;
    4100                 :    3876220 :       rtx next_arg_reg;
    4101                 :            : 
    4102                 :    3876220 :       if (pass == 0)
    4103                 :            :         {
    4104                 :            :           /* State variables we need to save and restore between
    4105                 :            :              iterations.  */
    4106                 :      91160 :           save_pending_stack_adjust (&save);
    4107                 :            :         }
    4108                 :    3876220 :       if (pass)
    4109                 :    3785060 :         flags &= ~ECF_SIBCALL;
    4110                 :            :       else
    4111                 :      91160 :         flags |= ECF_SIBCALL;
    4112                 :            : 
    4113                 :            :       /* Other state variables that we must reinitialize each time
    4114                 :            :          through the loop (that are not initialized by the loop itself).  */
    4115                 :    3876220 :       argblock = 0;
    4116                 :    3876220 :       call_fusage = 0;
    4117                 :            : 
    4118                 :            :       /* Start a new sequence for the normal call case.
    4119                 :            : 
    4120                 :            :          From this point on, if the sibling call fails, we want to set
    4121                 :            :          sibcall_failure instead of continuing the loop.  */
    4122                 :    3876220 :       start_sequence ();
    4123                 :            : 
    4124                 :            :       /* Don't let pending stack adjusts add up to too much.
    4125                 :            :          Also, do all pending adjustments now if there is any chance
    4126                 :            :          this might be a call to alloca or if we are expanding a sibling
    4127                 :            :          call sequence.
    4128                 :            :          Also do the adjustments before a throwing call, otherwise
    4129                 :            :          exception handling can fail; PR 19225. */
    4130                 :    3876220 :       if (maybe_ge (pending_stack_adjust, 32)
    4131                 :    3830240 :           || (maybe_ne (pending_stack_adjust, 0)
    4132                 :     103620 :               && (flags & ECF_MAY_BE_ALLOCA))
    4133                 :    3830240 :           || (maybe_ne (pending_stack_adjust, 0)
    4134                 :     103620 :               && flag_exceptions && !(flags & ECF_NOTHROW))
    4135                 :    7625710 :           || pass == 0)
    4136                 :     217514 :         do_pending_stack_adjust ();
    4137                 :            : 
    4138                 :            :       /* Precompute any arguments as needed.  */
    4139                 :    3876220 :       if (pass)
    4140                 :    3785060 :         precompute_arguments (num_actuals, args);
    4141                 :            : 
    4142                 :            :       /* Now we are about to start emitting insns that can be deleted
    4143                 :            :          if a libcall is deleted.  */
    4144                 :    3876220 :       if (pass && (flags & ECF_MALLOC))
    4145                 :      69993 :         start_sequence ();
    4146                 :            : 
    4147                 :    3876220 :       if (pass == 0
    4148                 :      91160 :           && crtl->stack_protect_guard
    4149                 :    3876220 :           && targetm.stack_protect_runtime_enabled_p ())
    4150                 :          0 :         stack_protect_epilogue ();
    4151                 :            : 
    4152                 :    3876220 :       adjusted_args_size = args_size;
    4153                 :            :       /* Compute the actual size of the argument block required.  The variable
    4154                 :            :          and constant sizes must be combined, the size may have to be rounded,
    4155                 :            :          and there may be a minimum required size.  When generating a sibcall
    4156                 :            :          pattern, do not round up, since we'll be re-using whatever space our
    4157                 :            :          caller provided.  */
    4158                 :    3876220 :       unadjusted_args_size
    4159                 :            :         = compute_argument_block_size (reg_parm_stack_space,
    4160                 :            :                                        &adjusted_args_size,
    4161                 :            :                                        fndecl, fntype,
    4162                 :            :                                        (pass == 0 ? 0
    4163                 :    7661280 :                                         : preferred_stack_boundary));
    4164                 :            : 
    4165                 :    3876220 :       old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
    4166                 :            : 
    4167                 :            :       /* The argument block when performing a sibling call is the
    4168                 :            :          incoming argument block.  */
    4169                 :    3876220 :       if (pass == 0)
    4170                 :            :         {
    4171                 :      91160 :           argblock = crtl->args.internal_arg_pointer;
    4172                 :      91160 :           if (STACK_GROWS_DOWNWARD)
    4173                 :      91160 :             argblock
    4174                 :      96452 :               = plus_constant (Pmode, argblock, crtl->args.pretend_args_size);
    4175                 :            :           else
    4176                 :            :             argblock
    4177                 :            :               = plus_constant (Pmode, argblock, -crtl->args.pretend_args_size);
    4178                 :            : 
    4179                 :      91160 :           HOST_WIDE_INT map_size = constant_lower_bound (args_size.constant);
    4180                 :      91160 :           stored_args_map = sbitmap_alloc (map_size);
    4181                 :      91160 :           bitmap_clear (stored_args_map);
    4182                 :      91160 :           stored_args_watermark = HOST_WIDE_INT_M1U;
    4183                 :            :         }
    4184                 :            : 
    4185                 :            :       /* If we have no actual push instructions, or shouldn't use them,
    4186                 :            :          make space for all args right now.  */
    4187                 :    3785060 :       else if (adjusted_args_size.var != 0)
    4188                 :            :         {
    4189                 :          0 :           if (old_stack_level == 0)
    4190                 :            :             {
    4191                 :          0 :               emit_stack_save (SAVE_BLOCK, &old_stack_level);
    4192                 :          0 :               old_stack_pointer_delta = stack_pointer_delta;
    4193                 :          0 :               old_pending_adj = pending_stack_adjust;
    4194                 :          0 :               pending_stack_adjust = 0;
    4195                 :            :               /* stack_arg_under_construction says whether a stack arg is
    4196                 :            :                  being constructed at the old stack level.  Pushing the stack
    4197                 :            :                  gets a clean outgoing argument block.  */
    4198                 :          0 :               old_stack_arg_under_construction = stack_arg_under_construction;
    4199                 :          0 :               stack_arg_under_construction = 0;
    4200                 :            :             }
    4201                 :          0 :           argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
    4202                 :          0 :           if (flag_stack_usage_info)
    4203                 :          0 :             current_function_has_unbounded_dynamic_stack_size = 1;
    4204                 :            :         }
    4205                 :            :       else
    4206                 :            :         {
    4207                 :            :           /* Note that we must go through the motions of allocating an argument
    4208                 :            :              block even if the size is zero because we may be storing args
    4209                 :            :              in the area reserved for register arguments, which may be part of
    4210                 :            :              the stack frame.  */
    4211                 :            : 
    4212                 :    6882560 :           poly_int64 needed = adjusted_args_size.constant;
    4213                 :            : 
    4214                 :            :           /* Store the maximum argument space used.  It will be pushed by
    4215                 :            :              the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
    4216                 :            :              checking).  */
    4217                 :            : 
    4218                 :    3785060 :           crtl->outgoing_args_size = upper_bound (crtl->outgoing_args_size,
    4219                 :    3785060 :                                                   needed);
    4220                 :            : 
    4221                 :    3785060 :           if (must_preallocate)
    4222                 :            :             {
    4223                 :      20533 :               if (ACCUMULATE_OUTGOING_ARGS)
    4224                 :            :                 {
    4225                 :            :                   /* Since the stack pointer will never be pushed, it is
    4226                 :            :                      possible for the evaluation of a parm to clobber
    4227                 :            :                      something we have already written to the stack.
    4228                 :            :                      Since most function calls on RISC machines do not use
    4229                 :            :                      the stack, this is uncommon, but must work correctly.
    4230                 :            : 
    4231                 :            :                      Therefore, we save any area of the stack that was already
    4232                 :            :                      written and that we are using.  Here we set up to do this
    4233                 :            :                      by making a new stack usage map from the old one.  The
    4234                 :            :                      actual save will be done by store_one_arg.
    4235                 :            : 
    4236                 :            :                      Another approach might be to try to reorder the argument
    4237                 :            :                      evaluations to avoid this conflicting stack usage.  */
    4238                 :            : 
    4239                 :            :                   /* Since we will be writing into the entire argument area,
    4240                 :            :                      the map must be allocated for its entire size, not just
    4241                 :            :                      the part that is the responsibility of the caller.  */
    4242                 :      21077 :                   if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
    4243                 :      14568 :                     needed += reg_parm_stack_space;
    4244                 :            : 
    4245                 :      20528 :                   poly_int64 limit = needed;
    4246                 :      20528 :                   if (ARGS_GROW_DOWNWARD)
    4247                 :            :                     limit += 1;
    4248                 :            : 
    4249                 :            :                   /* For polynomial sizes, this is the maximum possible
    4250                 :            :                      size needed for arguments with a constant size
    4251                 :            :                      and offset.  */
    4252                 :      20528 :                   HOST_WIDE_INT const_limit = constant_lower_bound (limit);
    4253                 :      20528 :                   highest_outgoing_arg_in_use
    4254                 :      20528 :                     = MAX (initial_highest_arg_in_use, const_limit);
    4255                 :            : 
    4256                 :      20528 :                   free (stack_usage_map_buf);
    4257                 :      20528 :                   stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
    4258                 :      20528 :                   stack_usage_map = stack_usage_map_buf;
    4259                 :            : 
    4260                 :      20528 :                   if (initial_highest_arg_in_use)
    4261                 :          0 :                     memcpy (stack_usage_map, initial_stack_usage_map,
    4262                 :            :                             initial_highest_arg_in_use);
    4263                 :            : 
    4264                 :      20528 :                   if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
    4265                 :       7264 :                     memset (&stack_usage_map[initial_highest_arg_in_use], 0,
    4266                 :            :                            (highest_outgoing_arg_in_use
    4267                 :       7264 :                             - initial_highest_arg_in_use));
    4268                 :      20528 :                   needed = 0;
    4269                 :            : 
    4270                 :            :                   /* The address of the outgoing argument list must not be
    4271                 :            :                      copied to a register here, because argblock would be left
    4272                 :            :                      pointing to the wrong place after the call to
    4273                 :            :                      allocate_dynamic_stack_space below.  */
    4274                 :            : 
    4275                 :      20528 :                   argblock = virtual_outgoing_args_rtx;
    4276                 :            :                 }
    4277                 :            :               else
    4278                 :            :                 {
    4279                 :            :                   /* Try to reuse some or all of the pending_stack_adjust
    4280                 :            :                      to get this space.  */
    4281                 :          5 :                   if (inhibit_defer_pop == 0
    4282                 :         10 :                       && (combine_pending_stack_adjustment_and_call
    4283                 :          5 :                           (&needed,
    4284                 :            :                            unadjusted_args_size,
    4285                 :            :                            &adjusted_args_size,
    4286                 :            :                            preferred_unit_stack_boundary)))
    4287                 :            :                     {
    4288                 :            :                       /* combine_pending_stack_adjustment_and_call computes
    4289                 :            :                          an adjustment before the arguments are allocated.
    4290                 :            :                          Account for them and see whether or not the stack
    4291                 :            :                          needs to go up or down.  */
    4292                 :          5 :                       needed = unadjusted_args_size - needed;
    4293                 :            : 
    4294                 :            :                       /* Checked by
    4295                 :            :                          combine_pending_stack_adjustment_and_call.  */
    4296                 :          5 :                       gcc_checking_assert (ordered_p (needed, 0));
    4297                 :          5 :                       if (maybe_lt (needed, 0))
    4298                 :            :                         {
    4299                 :            :                           /* We're releasing stack space.  */
    4300                 :            :                           /* ??? We can avoid any adjustment at all if we're
    4301                 :            :                              already aligned.  FIXME.  */
    4302                 :          0 :                           pending_stack_adjust = -needed;
    4303                 :          0 :                           do_pending_stack_adjust ();
    4304                 :          0 :                           needed = 0;
    4305                 :            :                         }
    4306                 :            :                       else
    4307                 :            :                         /* We need to allocate space.  We'll do that in
    4308                 :            :                            push_block below.  */
    4309                 :          5 :                         pending_stack_adjust = 0;
    4310                 :            :                     }
    4311                 :            : 
    4312                 :            :                   /* Special case this because overhead of `push_block' in
    4313                 :            :                      this case is non-trivial.  */
    4314                 :          5 :                   if (known_eq (needed, 0))
    4315                 :          3 :                     argblock = virtual_outgoing_args_rtx;
    4316                 :            :                   else
    4317                 :            :                     {
    4318                 :          2 :                       rtx needed_rtx = gen_int_mode (needed, Pmode);
    4319                 :          2 :                       argblock = push_block (needed_rtx, 0, 0);
    4320                 :          2 :                       if (ARGS_GROW_DOWNWARD)
    4321                 :            :                         argblock = plus_constant (Pmode, argblock, needed);
    4322                 :            :                     }
    4323                 :            : 
    4324                 :            :                   /* We only really need to call `copy_to_reg' in the case
    4325                 :            :                      where push insns are going to be used to pass ARGBLOCK
    4326                 :            :                      to a function call in ARGS.  In that case, the stack
    4327                 :            :                      pointer changes value from the allocation point to the
    4328                 :            :                      call point, and hence the value of
    4329                 :            :                      VIRTUAL_OUTGOING_ARGS_RTX changes as well.  But might
    4330                 :            :                      as well always do it.  */
    4331                 :          5 :                   argblock = copy_to_reg (argblock);
    4332                 :            :                 }
    4333                 :            :             }
    4334                 :            :         }
    4335                 :            : 
    4336                 :    3876220 :       if (ACCUMULATE_OUTGOING_ARGS)
    4337                 :            :         {
    4338                 :            :           /* The save/restore code in store_one_arg handles all
    4339                 :            :              cases except one: a constructor call (including a C
    4340                 :            :              function returning a BLKmode struct) to initialize
    4341                 :            :              an argument.  */
    4342                 :      21710 :           if (stack_arg_under_construction)
    4343                 :            :             {
    4344                 :          0 :               rtx push_size
    4345                 :            :                 = (gen_int_mode
    4346                 :          0 :                    (adjusted_args_size.constant
    4347                 :          0 :                     + (OUTGOING_REG_PARM_STACK_SPACE (!fndecl ? fntype
    4348                 :            :                                                       : TREE_TYPE (fndecl))
    4349                 :          0 :                        ? 0 : reg_parm_stack_space), Pmode));
    4350                 :          0 :               if (old_stack_level == 0)
    4351                 :            :                 {
    4352                 :          0 :                   emit_stack_save (SAVE_BLOCK, &old_stack_level);
    4353                 :          0 :                   old_stack_pointer_delta = stack_pointer_delta;
    4354                 :          0 :                   old_pending_adj = pending_stack_adjust;
    4355                 :          0 :                   pending_stack_adjust = 0;
    4356                 :            :                   /* stack_arg_under_construction says whether a stack
    4357                 :            :                      arg is being constructed at the old stack level.
    4358                 :            :                      Pushing the stack gets a clean outgoing argument
    4359                 :            :                      block.  */
    4360                 :          0 :                   old_stack_arg_under_construction
    4361                 :          0 :                     = stack_arg_under_construction;
    4362                 :          0 :                   stack_arg_under_construction = 0;
    4363                 :            :                   /* Make a new map for the new argument list.  */
    4364                 :          0 :                   free (stack_usage_map_buf);
    4365                 :          0 :                   stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
    4366                 :          0 :                   stack_usage_map = stack_usage_map_buf;
    4367                 :          0 :                   highest_outgoing_arg_in_use = 0;
    4368                 :          0 :                   stack_usage_watermark = HOST_WIDE_INT_M1U;
    4369                 :            :                 }
    4370                 :            :               /* We can pass TRUE as the 4th argument because we just
    4371                 :            :                  saved the stack pointer and will restore it right after
    4372                 :            :                  the call.  */
    4373                 :          0 :               allocate_dynamic_stack_space (push_size, 0, BIGGEST_ALIGNMENT,
    4374                 :            :                                             -1, true);
    4375                 :            :             }
    4376                 :            : 
    4377                 :            :           /* If argument evaluation might modify the stack pointer,
    4378                 :            :              copy the address of the argument list to a register.  */
    4379                 :      75745 :           for (i = 0; i < num_actuals; i++)
    4380                 :      54035 :             if (args[i].pass_on_stack)
    4381                 :            :               {
    4382                 :          0 :                 argblock = copy_addr_to_reg (argblock);
    4383                 :          0 :                 break;
    4384                 :            :               }
    4385                 :            :         }
    4386                 :            : 
    4387                 :    3876220 :       compute_argument_addresses (args, argblock, num_actuals);
    4388                 :            : 
    4389                 :            :       /* Stack is properly aligned, pops can't safely be deferred during
    4390                 :            :          the evaluation of the arguments.  */
    4391                 :    3876220 :       NO_DEFER_POP;
    4392                 :            : 
    4393                 :            :       /* Precompute all register parameters.  It isn't safe to compute
    4394                 :            :          anything once we have started filling any specific hard regs.
    4395                 :            :          TLS symbols sometimes need a call to resolve.  Precompute
    4396                 :            :          register parameters before any stack pointer manipulation
    4397                 :            :          to avoid unaligned stack in the called function.  */
    4398                 :    3876220 :       precompute_register_parameters (num_actuals, args, &reg_parm_seen);
    4399                 :            : 
    4400                 :    3876220 :       OK_DEFER_POP;
    4401                 :            : 
    4402                 :            :       /* Perform stack alignment before the first push (the last arg).  */
    4403                 :    3876220 :       if (argblock == 0
    4404                 :    3764530 :           && maybe_gt (adjusted_args_size.constant, reg_parm_stack_space)
    4405                 :    4593330 :           && maybe_ne (adjusted_args_size.constant, unadjusted_args_size))
    4406                 :            :         {
    4407                 :            :           /* When the stack adjustment is pending, we get better code
    4408                 :            :              by combining the adjustments.  */
    4409                 :     592451 :           if (maybe_ne (pending_stack_adjust, 0)
    4410                 :       9998 :               && ! inhibit_defer_pop
    4411                 :     602449 :               && (combine_pending_stack_adjustment_and_call
    4412                 :       9998 :                   (&pending_stack_adjust,
    4413                 :            :                    unadjusted_args_size,
    4414                 :            :                    &adjusted_args_size,
    4415                 :            :                    preferred_unit_stack_boundary)))
    4416                 :       9998 :             do_pending_stack_adjust ();
    4417                 :     582453 :           else if (argblock == 0)
    4418                 :     582453 :             anti_adjust_stack (gen_int_mode (adjusted_args_size.constant
    4419                 :            :                                              - unadjusted_args_size,
    4420                 :    1059100 :                                              Pmode));
    4421                 :            :         }
    4422                 :            :       /* Now that the stack is properly aligned, pops can't safely
    4423                 :            :          be deferred during the evaluation of the arguments.  */
    4424                 :    3876220 :       NO_DEFER_POP;
    4425                 :            : 
    4426                 :            :       /* Record the maximum pushed stack space size.  We need to delay
    4427                 :            :          doing it this far to take into account the optimization done
    4428                 :            :          by combine_pending_stack_adjustment_and_call.  */
    4429                 :    3876220 :       if (flag_stack_usage_info
    4430                 :       1157 :           && !ACCUMULATE_OUTGOING_ARGS
    4431                 :       1157 :           && pass
    4432                 :    3877380 :           && adjusted_args_size.var == 0)
    4433                 :            :         {
    4434                 :            :           poly_int64 pushed = (adjusted_args_size.constant
    4435                 :       1157 :                                + pending_stack_adjust);
    4436                 :       1157 :           current_function_pushed_stack_size
    4437                 :       2314 :             = upper_bound (current_function_pushed_stack_size, pushed);
    4438                 :            :         }
    4439                 :            : 
    4440                 :    3876220 :       funexp = rtx_for_function_call (fndecl, addr);
    4441                 :            : 
    4442                 :    3876220 :       if (CALL_EXPR_STATIC_CHAIN (exp))
    4443                 :      25571 :         static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
    4444                 :            :       else
    4445                 :            :         static_chain_value = 0;
    4446                 :            : 
    4447                 :            : #ifdef REG_PARM_STACK_SPACE
    4448                 :            :       /* Save the fixed argument area if it's part of the caller's frame and
    4449                 :            :          is clobbered by argument setup for this call.  */
    4450                 :    3876220 :       if (ACCUMULATE_OUTGOING_ARGS && pass)
    4451                 :      20528 :         save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
    4452                 :            :                                               &low_to_save, &high_to_save);
    4453                 :            : #endif
    4454                 :            : 
    4455                 :            :       /* Now store (and compute if necessary) all non-register parms.
    4456                 :            :          These come before register parms, since they can require block-moves,
    4457                 :            :          which could clobber the registers used for register parms.
    4458                 :            :          Parms which have partial registers are not stored here,
    4459                 :            :          but we do preallocate space here if they want that.  */
    4460                 :            : 
    4461                 :   11291600 :       for (i = 0; i < num_actuals; i++)
    4462                 :            :         {
    4463                 :    7415420 :           if (args[i].reg == 0 || args[i].pass_on_stack)
    4464                 :            :             {
    4465                 :    1586310 :               rtx_insn *before_arg = get_last_insn ();
    4466                 :            : 
    4467                 :            :               /* We don't allow passing huge (> 2^30 B) arguments
    4468                 :            :                  by value.  It would cause an overflow later on.  */
    4469                 :    1586310 :               if (constant_lower_bound (adjusted_args_size.constant)
    4470                 :            :                   >= (1 << (HOST_BITS_PER_INT - 2)))
    4471                 :            :                 {
    4472                 :          0 :                   sorry ("passing too large argument on stack");
    4473                 :          0 :                   continue;
    4474                 :            :                 }
    4475                 :            : 
    4476                 :    1586310 :               if (store_one_arg (&args[i], argblock, flags,
    4477                 :    1586310 :                                  adjusted_args_size.var != 0,
    4478                 :            :                                  reg_parm_stack_space)
    4479                 :    1586310 :                   || (pass == 0
    4480                 :       8978 :                       && check_sibcall_argument_overlap (before_arg,
    4481                 :            :                                                          &args[i], 1)))
    4482                 :          4 :                 sibcall_failure = 1;
    4483                 :            :               }
    4484                 :            : 
    4485                 :    7415420 :           if (args[i].stack)
    4486                 :      10287 :             call_fusage
    4487                 :      10287 :               = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
    4488                 :            :                                    gen_rtx_USE (VOIDmode, args[i].stack),
    4489                 :            :                                    call_fusage);
    4490                 :            :         }
    4491                 :            : 
    4492                 :            :       /* If we have a parm that is passed in registers but not in memory
    4493                 :            :          and whose alignment does not permit a direct copy into registers,
    4494                 :            :          make a group of pseudos that correspond to each register that we
    4495                 :            :          will later fill.  */
    4496                 :    3876220 :       if (STRICT_ALIGNMENT)
    4497                 :            :         store_unaligned_arguments_into_pseudos (args, num_actuals);
    4498                 :            : 
    4499                 :            :       /* Now store any partially-in-registers parm.
    4500                 :            :          This is the last place a block-move can happen.  */
    4501                 :    3876220 :       if (reg_parm_seen)
    4502                 :    8911780 :         for (i = 0; i < num_actuals; i++)
    4503                 :    6176040 :           if (args[i].partial != 0 && ! args[i].pass_on_stack)
    4504                 :            :             {
    4505                 :          0 :               rtx_insn *before_arg = get_last_insn ();
    4506                 :            : 
    4507                 :            :              /* On targets with weird calling conventions (e.g. PA) it's
    4508                 :            :                 hard to ensure that all cases of argument overlap between
    4509                 :            :                 stack and registers work.  Play it safe and bail out.  */
    4510                 :          0 :               if (ARGS_GROW_DOWNWARD && !STACK_GROWS_DOWNWARD)
    4511                 :            :                 {
    4512                 :            :                   sibcall_failure = 1;
    4513                 :            :                   break;
    4514                 :            :                 }
    4515                 :            : 
    4516                 :          0 :               if (store_one_arg (&args[i], argblock, flags,
    4517                 :          0 :                                  adjusted_args_size.var != 0,
    4518                 :            :                                  reg_parm_stack_space)
    4519                 :          0 :                   || (pass == 0
    4520                 :          0 :                       && check_sibcall_argument_overlap (before_arg,
    4521                 :            :                                                          &args[i], 1)))
    4522                 :          0 :                 sibcall_failure = 1;
    4523                 :            :             }
    4524                 :            : 
    4525                 :            :       bool any_regs = false;
    4526                 :   11291600 :       for (i = 0; i < num_actuals; i++)
    4527                 :    7415420 :         if (args[i].reg != NULL_RTX)
    4528                 :            :           {
    4529                 :    5829110 :             any_regs = true;
    4530                 :    5829110 :             targetm.calls.call_args (args[i].reg, funtype);
    4531                 :            :           }
    4532                 :    3876220 :       if (!any_regs)
    4533                 :    1140480 :         targetm.calls.call_args (pc_rtx, funtype);
    4534                 :            : 
    4535                 :            :       /* Figure out the register where the value, if any, will come back.  */
    4536                 :    3876220 :       valreg = 0;
    4537                 :    3876220 :       if (TYPE_MODE (rettype) != VOIDmode
    4538                 :    3876220 :           && ! structure_value_addr)
    4539                 :            :         {
    4540                 :    1405200 :           if (pcc_struct_value)
    4541                 :            :             valreg = hard_function_value (build_pointer_type (rettype),
    4542                 :            :                                           fndecl, NULL, (pass == 0));
    4543                 :            :           else
    4544                 :    1405200 :             valreg = hard_function_value (rettype, fndecl, fntype,
    4545                 :            :                                           (pass == 0));
    4546                 :            : 
    4547                 :            :           /* If VALREG is a PARALLEL whose first member has a zero
    4548                 :            :              offset, use that.  This is for targets such as m68k that
    4549                 :            :              return the same value in multiple places.  */
    4550                 :    1405200 :           if (GET_CODE (valreg) == PARALLEL)
    4551                 :            :             {
    4552                 :       8380 :               rtx elem = XVECEXP (valreg, 0, 0);
    4553                 :       8380 :               rtx where = XEXP (elem, 0);
    4554                 :       8380 :               rtx offset = XEXP (elem, 1);
    4555                 :       8380 :               if (offset == const0_rtx
    4556                 :       8370 :                   && GET_MODE (where) == GET_MODE (valreg))
    4557                 :          0 :                 valreg = where;
    4558                 :            :             }
    4559                 :            :         }
    4560                 :            : 
    4561                 :            :       /* If register arguments require space on the stack and stack space
    4562                 :            :          was not preallocated, allocate stack space here for arguments
    4563                 :            :          passed in registers.  */
    4564                 :    6430110 :       if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
    4565                 :      35941 :           && !ACCUMULATE_OUTGOING_ARGS
    4566                 :    3905050 :           && must_preallocate == 0 && reg_parm_stack_space > 0)
    4567                 :      28829 :         anti_adjust_stack (GEN_INT (reg_parm_stack_space));
    4568                 :            : 
    4569                 :            :       /* Pass the function the address in which to return a
    4570                 :            :          structure value.  */
    4571                 :    3876220 :       if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
    4572                 :            :         {
    4573                 :          0 :           structure_value_addr
    4574                 :          0 :             = convert_memory_address (Pmode, structure_value_addr);
    4575                 :          0 :           emit_move_insn (struct_value,
    4576                 :          0 :                           force_reg (Pmode,
    4577                 :            :                                      force_operand (structure_value_addr,
    4578                 :            :                                                     NULL_RTX)));
    4579                 :            : 
    4580                 :          0 :           if (REG_P (struct_value))
    4581                 :          0 :             use_reg (&call_fusage, struct_value);
    4582                 :            :         }
    4583                 :            : 
    4584                 :    3876220 :       after_args = get_last_insn ();
    4585                 :    4021470 :       funexp = prepare_call_address (fndecl ? fndecl : fntype, funexp,
    4586                 :            :                                      static_chain_value, &call_fusage,
    4587                 :            :                                      reg_parm_seen, flags);
    4588                 :            : 
    4589                 :    3876220 :       load_register_parameters (args, num_actuals, &call_fusage, flags,
    4590                 :            :                                 pass == 0, &sibcall_failure);
    4591                 :            : 
    4592                 :            :       /* Save a pointer to the last insn before the call, so that we can
    4593                 :            :          later safely search backwards to find the CALL_INSN.  */
    4594                 :    3876220 :       before_call = get_last_insn ();
    4595                 :            : 
    4596                 :            :       /* Set up next argument register.  For sibling calls on machines
    4597                 :            :          with register windows this should be the incoming register.  */
    4598                 :    3876220 :       if (pass == 0)
    4599                 :      91160 :         next_arg_reg = targetm.calls.function_incoming_arg
    4600                 :      91160 :           (args_so_far, function_arg_info::end_marker ());
    4601                 :            :       else
    4602                 :    3785060 :         next_arg_reg = targetm.calls.function_arg
    4603                 :    3785060 :           (args_so_far, function_arg_info::end_marker ());
    4604                 :            : 
    4605                 :    3876220 :       if (pass == 1 && (return_flags & ERF_RETURNS_ARG))
    4606                 :            :         {
    4607                 :      63478 :           int arg_nr = return_flags & ERF_RETURN_ARG_MASK;
    4608                 :      63478 :           arg_nr = num_actuals - arg_nr - 1;
    4609                 :      63478 :           if (arg_nr >= 0
    4610                 :      63478 :               && arg_nr < num_actuals
    4611                 :      63464 :               && args[arg_nr].reg
    4612                 :      61718 :               && valreg
    4613                 :      61718 :               && REG_P (valreg)
    4614                 :      61718 :               && GET_MODE (args[arg_nr].reg) == GET_MODE (valreg))
    4615                 :      61718 :           call_fusage
    4616                 :      61718 :             = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[arg_nr].tree_value)),
    4617                 :            :                                  gen_rtx_SET (valreg, args[arg_nr].reg),
    4618                 :            :                                  call_fusage);
    4619                 :            :         }
    4620                 :            :       /* All arguments and registers used for the call must be set up by
    4621                 :            :          now!  */
    4622                 :            : 
    4623                 :            :       /* Stack must be properly aligned now.  */
    4624                 :    3876220 :       gcc_assert (!pass
    4625                 :            :                   || multiple_p (stack_pointer_delta,
    4626                 :            :                                  preferred_unit_stack_boundary));
    4627                 :            : 
    4628                 :            :       /* Generate the actual call instruction.  */
    4629                 :    3876220 :       emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
    4630                 :            :                    adjusted_args_size.constant, struct_value_size,
    4631                 :            :                    next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
    4632                 :            :                    flags, args_so_far);
    4633                 :            : 
    4634                 :    3876220 :       if (flag_ipa_ra)
    4635                 :            :         {
    4636                 :    2904230 :           rtx_call_insn *last;
    4637                 :    2904230 :           rtx datum = NULL_RTX;
    4638                 :    2904230 :           if (fndecl != NULL_TREE)
    4639                 :            :             {
    4640                 :    2786470 :               datum = XEXP (DECL_RTL (fndecl), 0);
    4641                 :    2786470 :               gcc_assert (datum != NULL_RTX
    4642                 :            :                           && GET_CODE (datum) == SYMBOL_REF);
    4643                 :            :             }
    4644                 :    2904230 :           last = last_call_insn ();
    4645                 :    2904230 :           add_reg_note (last, REG_CALL_DECL, datum);
    4646                 :            :         }
    4647                 :            : 
    4648                 :            :       /* If the call setup or the call itself overlaps with anything
    4649                 :            :          of the argument setup we probably clobbered our call address.
    4650                 :            :          In that case we can't do sibcalls.  */
    4651                 :    3876220 :       if (pass == 0
    4652                 :    3876220 :           && check_sibcall_argument_overlap (after_args, 0, 0))
    4653                 :          0 :         sibcall_failure = 1;
    4654                 :            : 
    4655                 :            :       /* If a non-BLKmode value is returned at the most significant end
    4656                 :            :          of a register, shift the register right by the appropriate amount
    4657                 :            :          and update VALREG accordingly.  BLKmode values are handled by the
    4658                 :            :          group load/store machinery below.  */
    4659                 :    3876220 :       if (!structure_value_addr
    4660                 :            :           && !pcc_struct_value
    4661                 :    3700480 :           && TYPE_MODE (rettype) != VOIDmode
    4662                 :    1405200 :           && TYPE_MODE (rettype) != BLKmode
    4663                 :    1404010 :           && REG_P (valreg)
    4664                 :    5272660 :           && targetm.calls.return_in_msb (rettype))
    4665                 :            :         {
    4666                 :          0 :           if (shift_return_value (TYPE_MODE (rettype), false, valreg))
    4667                 :          0 :             sibcall_failure = 1;
    4668                 :          0 :           valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg));
    4669                 :            :         }
    4670                 :            : 
    4671                 :    3876220 :       if (pass && (flags & ECF_MALLOC))
    4672                 :            :         {
    4673                 :      69993 :           rtx temp = gen_reg_rtx (GET_MODE (valreg));
    4674                 :      69993 :           rtx_insn *last, *insns;
    4675                 :            : 
    4676                 :            :           /* The return value from a malloc-like function is a pointer.  */
    4677                 :      69993 :           if (TREE_CODE (rettype) == POINTER_TYPE)
    4678                 :      73169 :             mark_reg_pointer (temp, MALLOC_ABI_ALIGNMENT);
    4679                 :            : 
    4680                 :      69993 :           emit_move_insn (temp, valreg);
    4681                 :            : 
    4682                 :            :           /* The return value from a malloc-like function cannot alias
    4683                 :            :              anything else.  */
    4684                 :      69993 :           last = get_last_insn ();
    4685                 :      69993 :           add_reg_note (last, REG_NOALIAS, temp);
    4686                 :            : 
    4687                 :            :           /* Write out the sequence.  */
    4688                 :      69993 :           insns = get_insns ();
    4689                 :      69993 :           end_sequence ();
    4690                 :      69993 :           emit_insn (insns);
    4691                 :      69993 :           valreg = temp;
    4692                 :            :         }
    4693                 :            : 
    4694                 :            :       /* For calls to `setjmp', etc., inform
    4695                 :            :          function.c:setjmp_warnings that it should complain if
    4696                 :            :          nonvolatile values are live.  For functions that cannot
    4697                 :            :          return, inform flow that control does not fall through.  */
    4698                 :            : 
    4699                 :    3876220 :       if ((flags & ECF_NORETURN) || pass == 0)
    4700                 :            :         {
    4701                 :            :           /* The barrier must be emitted
    4702                 :            :              immediately after the CALL_INSN.  Some ports emit more
    4703                 :            :              than just a CALL_INSN above, so we must search for it here.  */
    4704                 :            : 
    4705                 :     612150 :           rtx_insn *last = get_last_insn ();
    4706                 :     612213 :           while (!CALL_P (last))
    4707                 :            :             {
    4708                 :         63 :               last = PREV_INSN (last);
    4709                 :            :               /* There was no CALL_INSN?  */
    4710                 :         63 :               gcc_assert (last != before_call);
    4711                 :            :             }
    4712                 :            : 
    4713                 :     612150 :           emit_barrier_after (last);
    4714                 :            : 
    4715                 :            :           /* Stack adjustments after a noreturn call are dead code.
    4716                 :            :              However when NO_DEFER_POP is in effect, we must preserve
    4717                 :            :              stack_pointer_delta.  */
    4718                 :     612150 :           if (inhibit_defer_pop == 0)
    4719                 :            :             {
    4720                 :     612150 :               stack_pointer_delta = old_stack_allocated;
    4721                 :     612150 :               pending_stack_adjust = 0;
    4722                 :            :             }
    4723                 :            :         }
    4724                 :            : 
    4725                 :            :       /* If value type not void, return an rtx for the value.  */
    4726                 :            : 
    4727                 :    3876220 :       if (TYPE_MODE (rettype) == VOIDmode
    4728                 :    3876220 :           || ignore)
    4729                 :    2578770 :         target = const0_rtx;
    4730                 :    1297450 :       else if (structure_value_addr)
    4731                 :            :         {
    4732                 :     170961 :           if (target == 0 || !MEM_P (target))
    4733                 :            :             {
    4734                 :      48797 :               target
    4735                 :      48797 :                 = gen_rtx_MEM (TYPE_MODE (rettype),
    4736                 :      48797 :                                memory_address (TYPE_MODE (rettype),
    4737                 :            :                                                structure_value_addr));
    4738                 :      48797 :               set_mem_attributes (target, rettype, 1);
    4739                 :            :             }
    4740                 :            :         }
    4741                 :    1126490 :       else if (pcc_struct_value)
    4742                 :            :         {
    4743                 :            :           /* This is the special C++ case where we need to
    4744                 :            :              know what the true target was.  We take care to
    4745                 :            :              never use this value more than once in one expression.  */
    4746                 :            :           target = gen_rtx_MEM (TYPE_MODE (rettype),
    4747                 :            :                                 copy_to_reg (valreg));
    4748                 :            :           set_mem_attributes (target, rettype, 1);
    4749                 :            :         }
    4750                 :            :       /* Handle calls that return values in multiple non-contiguous locations.
    4751                 :            :          The Irix 6 ABI has examples of this.  */
    4752                 :    1126490 :       else if (GET_CODE (valreg) == PARALLEL)
    4753                 :            :         {
    4754                 :       8315 :           if (target == 0)
    4755                 :       1065 :             target = emit_group_move_into_temps (valreg);
    4756                 :       7250 :           else if (rtx_equal_p (target, valreg))
    4757                 :            :             ;
    4758                 :       7250 :           else if (GET_CODE (target) == PARALLEL)
    4759                 :            :             /* Handle the result of a emit_group_move_into_temps
    4760                 :            :                call in the previous pass.  */
    4761                 :          0 :             emit_group_move (target, valreg);
    4762                 :            :           else
    4763                 :       7250 :             emit_group_store (target, valreg, rettype,
    4764                 :       7250 :                               int_size_in_bytes (rettype));
    4765                 :            :         }
    4766                 :    1118180 :       else if (target
    4767                 :    1008340 :                && GET_MODE (target) == TYPE_MODE (rettype)
    4768                 :    2126520 :                && GET_MODE (target) == GET_MODE (valreg))
    4769                 :            :         {
    4770                 :    1008340 :           bool may_overlap = false;
    4771                 :            : 
    4772                 :            :           /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
    4773                 :            :              reg to a plain register.  */
    4774                 :    1008340 :           if (!REG_P (target) || HARD_REGISTER_P (target))
    4775                 :      26922 :             valreg = avoid_likely_spilled_reg (valreg);
    4776                 :            : 
    4777                 :            :           /* If TARGET is a MEM in the argument area, and we have
    4778                 :            :              saved part of the argument area, then we can't store
    4779                 :            :              directly into TARGET as it may get overwritten when we
    4780                 :            :              restore the argument save area below.  Don't work too
    4781                 :            :              hard though and simply force TARGET to a register if it
    4782                 :            :              is a MEM; the optimizer is quite likely to sort it out.  */
    4783                 :    1008340 :           if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target))
    4784                 :         13 :             for (i = 0; i < num_actuals; i++)
    4785                 :         12 :               if (args[i].save_area)
    4786                 :            :                 {
    4787                 :            :                   may_overlap = true;
    4788                 :            :                   break;
    4789                 :            :                 }
    4790                 :            : 
    4791                 :          1 :           if (may_overlap)
    4792                 :          0 :             target = copy_to_reg (valreg);
    4793                 :            :           else
    4794                 :            :             {
    4795                 :            :               /* TARGET and VALREG cannot be equal at this point
    4796                 :            :                  because the latter would not have
    4797                 :            :                  REG_FUNCTION_VALUE_P true, while the former would if
    4798                 :            :                  it were referring to the same register.
    4799                 :            : 
    4800                 :            :                  If they refer to the same register, this move will be
    4801                 :            :                  a no-op, except when function inlining is being
    4802                 :            :                  done.  */
    4803                 :    1008340 :               emit_move_insn (target, valreg);
    4804                 :            : 
    4805                 :            :               /* If we are setting a MEM, this code must be executed.
    4806                 :            :                  Since it is emitted after the call insn, sibcall
    4807                 :            :                  optimization cannot be performed in that case.  */
    4808                 :    1008340 :               if (MEM_P (target))
    4809                 :      25787 :                 sibcall_failure = 1;
    4810                 :            :             }
    4811                 :            :         }
    4812                 :            :       else
    4813                 :     109837 :         target = copy_to_reg (avoid_likely_spilled_reg (valreg));
    4814                 :            : 
    4815                 :            :       /* If we promoted this return value, make the proper SUBREG.
    4816                 :            :          TARGET might be const0_rtx here, so be careful.  */
    4817                 :    3876220 :       if (REG_P (target)
    4818                 :    1093190 :           && TYPE_MODE (rettype) != BLKmode
    4819                 :    4969190 :           && GET_MODE (target) != TYPE_MODE (rettype))
    4820                 :            :         {
    4821                 :          0 :           tree type = rettype;
    4822                 :          0 :           int unsignedp = TYPE_UNSIGNED (type);
    4823                 :          0 :           machine_mode pmode;
    4824                 :            : 
    4825                 :            :           /* Ensure we promote as expected, and get the new unsignedness.  */
    4826                 :          0 :           pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
    4827                 :            :                                          funtype, 1);
    4828                 :          0 :           gcc_assert (GET_MODE (target) == pmode);
    4829                 :            : 
    4830                 :          0 :           poly_uint64 offset = subreg_lowpart_offset (TYPE_MODE (type),
    4831                 :          0 :                                                       GET_MODE (target));
    4832                 :          0 :           target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
    4833                 :          0 :           SUBREG_PROMOTED_VAR_P (target) = 1;
    4834                 :          0 :           SUBREG_PROMOTED_SET (target, unsignedp);
    4835                 :            :         }
    4836                 :            : 
    4837                 :            :       /* If size of args is variable or this was a constructor call for a stack
    4838                 :            :          argument, restore saved stack-pointer value.  */
    4839                 :            : 
    4840                 :    3876220 :       if (old_stack_level)
    4841                 :            :         {
    4842                 :        170 :           rtx_insn *prev = get_last_insn ();
    4843                 :            : 
    4844                 :        170 :           emit_stack_restore (SAVE_BLOCK, old_stack_level);
    4845                 :        170 :           stack_pointer_delta = old_stack_pointer_delta;
    4846                 :            : 
    4847                 :        170 :           fixup_args_size_notes (prev, get_last_insn (), stack_pointer_delta);
    4848                 :            : 
    4849                 :        170 :           pending_stack_adjust = old_pending_adj;
    4850                 :        170 :           old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
    4851                 :        170 :           stack_arg_under_construction = old_stack_arg_under_construction;
    4852                 :        170 :           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
    4853                 :        170 :           stack_usage_map = initial_stack_usage_map;
    4854                 :        170 :           stack_usage_watermark = initial_stack_usage_watermark;
    4855                 :        170 :           sibcall_failure = 1;
    4856                 :            :         }
    4857                 :    3876050 :       else if (ACCUMULATE_OUTGOING_ARGS && pass)
    4858                 :            :         {
    4859                 :            : #ifdef REG_PARM_STACK_SPACE
    4860                 :      20528 :           if (save_area)
    4861                 :          0 :             restore_fixed_argument_area (save_area, argblock,
    4862                 :            :                                          high_to_save, low_to_save);
    4863                 :            : #endif
    4864                 :            : 
    4865                 :            :           /* If we saved any argument areas, restore them.  */
    4866                 :      73371 :           for (i = 0; i < num_actuals; i++)
    4867                 :      52843 :             if (args[i].save_area)
    4868                 :            :               {
    4869                 :          0 :                 machine_mode save_mode = GET_MODE (args[i].save_area);
    4870                 :          0 :                 rtx stack_area
    4871                 :          0 :                   = gen_rtx_MEM (save_mode,
    4872                 :          0 :                                  memory_address (save_mode,
    4873                 :            :                                                  XEXP (args[i].stack_slot, 0)));
    4874                 :            : 
    4875                 :          0 :                 if (save_mode != BLKmode)
    4876                 :          0 :                   emit_move_insn (stack_area, args[i].save_area);
    4877                 :            :                 else
    4878                 :          0 :                   emit_block_move (stack_area, args[i].save_area,
    4879                 :            :                                    (gen_int_mode
    4880                 :          0 :                                     (args[i].locate.size.constant, Pmode)),
    4881                 :            :                                    BLOCK_OP_CALL_PARM);
    4882                 :            :               }
    4883                 :            : 
    4884                 :      20528 :           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
    4885                 :      20528 :           stack_usage_map = initial_stack_usage_map;
    4886                 :      20528 :           stack_usage_watermark = initial_stack_usage_watermark;
    4887                 :            :         }
    4888                 :            : 
    4889                 :            :       /* If this was alloca, record the new stack level.  */
    4890                 :    3876220 :       if (flags & ECF_MAY_BE_ALLOCA)
    4891                 :         26 :         record_new_stack_level ();
    4892                 :            : 
    4893                 :            :       /* Free up storage we no longer need.  */
    4894                 :   11291600 :       for (i = 0; i < num_actuals; ++i)
    4895                 :    7415420 :         free (args[i].aligned_regs);
    4896                 :            : 
    4897                 :    3876220 :       targetm.calls.end_call_args ();
    4898                 :            : 
    4899                 :    3876220 :       insns = get_insns ();
    4900                 :    3876220 :       end_sequence ();
    4901                 :            : 
    4902                 :    3876220 :       if (pass == 0)
    4903                 :            :         {
    4904                 :      91160 :           tail_call_insns = insns;
    4905                 :            : 
    4906                 :            :           /* Restore the pending stack adjustment now that we have
    4907                 :            :              finished generating the sibling call sequence.  */
    4908                 :            : 
    4909                 :      91160 :           restore_pending_stack_adjust (&save);
    4910                 :            : 
    4911                 :            :           /* Prepare arg structure for next iteration.  */
    4912                 :     234232 :           for (i = 0; i < num_actuals; i++)
    4913                 :            :             {
    4914                 :     143072 :               args[i].value = 0;
    4915                 :     143072 :               args[i].aligned_regs = 0;
    4916                 :     143072 :               args[i].stack = 0;
    4917                 :            :             }
    4918                 :            : 
    4919                 :      91160 :           sbitmap_free (stored_args_map);
    4920                 :      91160 :           internal_arg_pointer_exp_state.scan_start = NULL;
    4921                 :      91160 :           internal_arg_pointer_exp_state.cache.release ();
    4922                 :            :         }
    4923                 :            :       else
    4924                 :            :         {
    4925                 :    3785060 :           normal_call_insns = insns;
    4926                 :            : 
    4927                 :            :           /* Verify that we've deallocated all the stack we used.  */
    4928                 :    3785060 :           gcc_assert ((flags & ECF_NORETURN)
    4929                 :            :                       || known_eq (old_stack_allocated,
    4930                 :            :                                    stack_pointer_delta
    4931                 :            :                                    - pending_stack_adjust));
    4932                 :            :         }
    4933                 :            : 
    4934                 :            :       /* If something prevents making this a sibling call,
    4935                 :            :          zero out the sequence.  */
    4936                 :    3876220 :       if (sibcall_failure)
    4937                 :      25961 :         tail_call_insns = NULL;
    4938                 :            :       else
    4939                 :            :         break;
    4940                 :            :     }
    4941                 :            : 
    4942                 :            :   /* If tail call production succeeded, we need to remove REG_EQUIV notes on
    4943                 :            :      arguments too, as argument area is now clobbered by the call.  */
    4944                 :    3876220 :   if (tail_call_insns)
    4945                 :            :     {
    4946                 :      91156 :       emit_insn (tail_call_insns);
    4947                 :      91156 :       crtl->tail_call_emit = true;
    4948                 :            :     }
    4949                 :            :   else
    4950                 :            :     {
    4951                 :    3785060 :       emit_insn (normal_call_insns);
    4952                 :    3785060 :       if (try_tail_call)
    4953                 :            :         /* Ideally we'd emit a message for all of the ways that it could
    4954                 :            :            have failed.  */
    4955                 :          4 :         maybe_complain_about_tail_call (exp, "tail call production failed");
    4956                 :            :     }
    4957                 :            : 
    4958                 :    3876220 :   currently_expanding_call--;
    4959                 :            : 
    4960                 :    3876220 :   free (stack_usage_map_buf);
    4961                 :    3876220 :   free (args);
    4962                 :    3876220 :   return target;
    4963                 :            : }
    4964                 :            : 
    4965                 :            : /* A sibling call sequence invalidates any REG_EQUIV notes made for
    4966                 :            :    this function's incoming arguments.
    4967                 :            : 
    4968                 :            :    At the start of RTL generation we know the only REG_EQUIV notes
    4969                 :            :    in the rtl chain are those for incoming arguments, so we can look
    4970                 :            :    for REG_EQUIV notes between the start of the function and the
    4971                 :            :    NOTE_INSN_FUNCTION_BEG.
    4972                 :            : 
    4973                 :            :    This is (slight) overkill.  We could keep track of the highest
    4974                 :            :    argument we clobber and be more selective in removing notes, but it
    4975                 :            :    does not seem to be worth the effort.  */
    4976                 :            : 
    4977                 :            : void
    4978                 :      90924 : fixup_tail_calls (void)
    4979                 :            : {
    4980                 :      90924 :   rtx_insn *insn;
    4981                 :            : 
    4982                 :     770440 :   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
    4983                 :            :     {
    4984                 :     430682 :       rtx note;
    4985                 :            : 
    4986                 :            :       /* There are never REG_EQUIV notes for the incoming arguments
    4987                 :            :          after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it.  */
    4988                 :     430682 :       if (NOTE_P (insn)
    4989                 :     272878 :           && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
    4990                 :            :         break;
    4991                 :            : 
    4992                 :     339758 :       note = find_reg_note (insn, REG_EQUIV, 0);
    4993                 :     339758 :       if (note)
    4994                 :      16725 :         remove_note (insn, note);
    4995                 :     339758 :       note = find_reg_note (insn, REG_EQUIV, 0);
    4996                 :     339758 :       gcc_assert (!note);
    4997                 :            :     }
    4998                 :      90924 : }
    4999                 :            : 
    5000                 :            : /* Traverse a list of TYPES and expand all complex types into their
    5001                 :            :    components.  */
    5002                 :            : static tree
    5003                 :          0 : split_complex_types (tree types)
    5004                 :            : {
    5005                 :          0 :   tree p;
    5006                 :            : 
    5007                 :            :   /* Before allocating memory, check for the common case of no complex.  */
    5008                 :          0 :   for (p = types; p; p = TREE_CHAIN (p))
    5009                 :            :     {
    5010                 :          0 :       tree type = TREE_VALUE (p);
    5011                 :          0 :       if (TREE_CODE (type) == COMPLEX_TYPE
    5012                 :          0 :           && targetm.calls.split_complex_arg (type))
    5013                 :          0 :         goto found;
    5014                 :            :     }
    5015                 :            :   return types;
    5016                 :            : 
    5017                 :          0 :  found:
    5018                 :          0 :   types = copy_list (types);
    5019                 :            : 
    5020                 :          0 :   for (p = types; p; p = TREE_CHAIN (p))
    5021                 :            :     {
    5022                 :          0 :       tree complex_type = TREE_VALUE (p);
    5023                 :            : 
    5024                 :          0 :       if (TREE_CODE (complex_type) == COMPLEX_TYPE
    5025                 :          0 :           && targetm.calls.split_complex_arg (complex_type))
    5026                 :            :         {
    5027                 :          0 :           tree next, imag;
    5028                 :            : 
    5029                 :            :           /* Rewrite complex type with component type.  */
    5030                 :          0 :           TREE_VALUE (p) = TREE_TYPE (complex_type);
    5031                 :          0 :           next = TREE_CHAIN (p);
    5032                 :            : 
    5033                 :            :           /* Add another component type for the imaginary part.  */
    5034                 :          0 :           imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
    5035                 :          0 :           TREE_CHAIN (p) = imag;
    5036                 :          0 :           TREE_CHAIN (imag) = next;
    5037                 :            : 
    5038                 :            :           /* Skip the newly created node.  */
    5039                 :          0 :           p = TREE_CHAIN (p);
    5040                 :            :         }
    5041                 :            :     }
    5042                 :            : 
    5043                 :            :   return types;
    5044                 :            : }
    5045                 :            : 
    5046                 :            : /* Output a library call to function ORGFUN (a SYMBOL_REF rtx)
    5047                 :            :    for a value of mode OUTMODE,
    5048                 :            :    with NARGS different arguments, passed as ARGS.
    5049                 :            :    Store the return value if RETVAL is nonzero: store it in VALUE if
    5050                 :            :    VALUE is nonnull, otherwise pick a convenient location.  In either
    5051                 :            :    case return the location of the stored value.
    5052                 :            : 
    5053                 :            :    FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
    5054                 :            :    `const' calls, LCT_PURE for `pure' calls, or another LCT_ value for
    5055                 :            :    other types of library calls.  */
    5056                 :            : 
    5057                 :            : rtx
    5058                 :      86442 : emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
    5059                 :            :                            enum libcall_type fn_type,
    5060                 :            :                            machine_mode outmode, int nargs, rtx_mode_t *args)
    5061                 :            : {
    5062                 :            :   /* Total size in bytes of all the stack-parms scanned so far.  */
    5063                 :      86442 :   struct args_size args_size;
    5064                 :            :   /* Size of arguments before any adjustments (such as rounding).  */
    5065                 :      86442 :   struct args_size original_args_size;
    5066                 :      86442 :   int argnum;
    5067                 :      86442 :   rtx fun;
    5068                 :            :   /* Todo, choose the correct decl type of orgfun. Sadly this information
    5069                 :            :      isn't present here, so we default to native calling abi here.  */
    5070                 :      86442 :   tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
    5071                 :      86442 :   tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
    5072                 :      86442 :   int count;
    5073                 :      86442 :   rtx argblock = 0;
    5074                 :      86442 :   CUMULATIVE_ARGS args_so_far_v;
    5075                 :      86442 :   cumulative_args_t args_so_far;
    5076                 :      86442 :   struct arg
    5077                 :            :   {
    5078                 :            :     rtx value;
    5079                 :            :     machine_mode mode;
    5080                 :            :     rtx reg;
    5081                 :            :     int partial;
    5082                 :            :     struct locate_and_pad_arg_data locate;
    5083                 :            :     rtx save_area;
    5084                 :            :   };
    5085                 :      86442 :   struct arg *argvec;
    5086                 :      86442 :   int old_inhibit_defer_pop = inhibit_defer_pop;
    5087                 :      86442 :   rtx call_fusage = 0;
    5088                 :      86442 :   rtx mem_value = 0;
    5089                 :      86442 :   rtx valreg;
    5090                 :      86442 :   int pcc_struct_value = 0;
    5091                 :      86442 :   poly_int64 struct_value_size = 0;
    5092                 :      86442 :   int flags;
    5093                 :      86442 :   int reg_parm_stack_space = 0;
    5094                 :      86442 :   poly_int64 needed;
    5095                 :      86442 :   rtx_insn *before_call;
    5096                 :      86442 :   bool have_push_fusage;
    5097                 :      86442 :   tree tfom;                    /* type_for_mode (outmode, 0) */
    5098                 :            : 
    5099                 :            : #ifdef REG_PARM_STACK_SPACE
    5100                 :            :   /* Define the boundary of the register parm stack space that needs to be
    5101                 :            :      save, if any.  */
    5102                 :      86442 :   int low_to_save = 0, high_to_save = 0;
    5103                 :      86442 :   rtx save_area = 0;            /* Place that it is saved.  */
    5104                 :            : #endif
    5105                 :            : 
    5106                 :            :   /* Size of the stack reserved for parameter registers.  */
    5107                 :      86442 :   unsigned int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
    5108                 :      86442 :   char *initial_stack_usage_map = stack_usage_map;
    5109                 :      86442 :   unsigned HOST_WIDE_INT initial_stack_usage_watermark = stack_usage_watermark;
    5110                 :      86442 :   char *stack_usage_map_buf = NULL;
    5111                 :            : 
    5112                 :      86442 :   rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
    5113                 :            : 
    5114                 :            : #ifdef REG_PARM_STACK_SPACE
    5115                 :      86442 :   reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
    5116                 :            : #endif
    5117                 :            : 
    5118                 :            :   /* By default, library functions cannot throw.  */
    5119                 :      86442 :   flags = ECF_NOTHROW;
    5120                 :            : 
    5121                 :      86442 :   switch (fn_type)
    5122                 :            :     {
    5123                 :            :     case LCT_NORMAL:
    5124                 :            :       break;
    5125                 :            :     case LCT_CONST:
    5126                 :            :       flags |= ECF_CONST;
    5127                 :            :       break;
    5128                 :            :     case LCT_PURE:
    5129                 :            :       flags |= ECF_PURE;
    5130                 :            :       break;
    5131                 :            :     case LCT_NORETURN:
    5132                 :            :       flags |= ECF_NORETURN;
    5133                 :            :       break;
    5134                 :            :     case LCT_THROW:
    5135                 :            :       flags &= ~ECF_NOTHROW;
    5136                 :            :       break;
    5137                 :            :     case LCT_RETURNS_TWICE:
    5138                 :            :       flags = ECF_RETURNS_TWICE;
    5139                 :            :       break;
    5140                 :            :     }
    5141                 :      86442 :   fun = orgfun;
    5142                 :            : 
    5143                 :            :   /* Ensure current function's preferred stack boundary is at least
    5144                 :            :      what we need.  */
    5145                 :      86442 :   if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
    5146                 :       7997 :     crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
    5147                 :            : 
    5148                 :            :   /* If this kind of value comes back in memory,
    5149                 :            :      decide where in memory it should come back.  */
    5150                 :      86442 :   if (outmode != VOIDmode)
    5151                 :            :     {
    5152                 :      86442 :       tfom = lang_hooks.types.type_for_mode (outmode, 0);
    5153                 :      86442 :       if (aggregate_value_p (tfom, 0))
    5154                 :            :         {
    5155                 :            : #ifdef PCC_STATIC_STRUCT_RETURN
    5156                 :            :           rtx pointer_reg
    5157                 :            :             = hard_function_value (build_pointer_type (tfom), 0, 0, 0);
    5158                 :            :           mem_value = gen_rtx_MEM (outmode, pointer_reg);
    5159                 :            :           pcc_struct_value = 1;
    5160                 :            :           if (value == 0)
    5161                 :            :             value = gen_reg_rtx (outmode);
    5162                 :            : #else /* not PCC_STATIC_STRUCT_RETURN */
    5163                 :      19824 :           struct_value_size = GET_MODE_SIZE (outmode);
    5164                 :       9912 :           if (value != 0 && MEM_P (value))
    5165                 :            :             mem_value = value;
    5166                 :            :           else
    5167                 :       9912 :             mem_value = assign_temp (tfom, 1, 1);
    5168                 :            : #endif
    5169                 :            :           /* This call returns a big structure.  */
    5170                 :       9912 :           flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
    5171                 :            :         }
    5172                 :            :     }
    5173                 :            :   else
    5174                 :          0 :     tfom = void_type_node;
    5175                 :            : 
    5176                 :            :   /* ??? Unfinished: must pass the memory address as an argument.  */
    5177                 :            : 
    5178                 :            :   /* Copy all the libcall-arguments out of the varargs data
    5179                 :            :      and into a vector ARGVEC.
    5180                 :            : 
    5181                 :            :      Compute how to pass each argument.  We only support a very small subset
    5182                 :            :      of the full argument passing conventions to limit complexity here since
    5183                 :            :      library functions shouldn't have many args.  */
    5184                 :            : 
    5185                 :      86442 :   argvec = XALLOCAVEC (struct arg, nargs + 1);
    5186                 :      86442 :   memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
    5187                 :            : 
    5188                 :            : #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
    5189                 :            :   INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v, outmode, fun);
    5190                 :            : #else
    5191                 :      86442 :   INIT_CUMULATIVE_ARGS (args_so_far_v, NULL_TREE, fun, 0, nargs);
    5192                 :            : #endif
    5193                 :      86442 :   args_so_far = pack_cumulative_args (&args_so_far_v);
    5194                 :            : 
    5195                 :      86442 :   args_size.constant = 0;
    5196                 :      86442 :   args_size.var = 0;
    5197                 :            : 
    5198                 :      86442 :   count = 0;
    5199                 :            : 
    5200                 :      86442 :   push_temp_slots ();
    5201                 :            : 
    5202                 :            :   /* If there's a structure value address to be passed,
    5203                 :            :      either pass it in the special place, or pass it as an extra argument.  */
    5204                 :      86442 :   if (mem_value && struct_value == 0 && ! pcc_struct_value)
    5205                 :            :     {
    5206                 :       9912 :       rtx addr = XEXP (mem_value, 0);
    5207                 :            : 
    5208                 :       9912 :       nargs++;
    5209                 :            : 
    5210                 :            :       /* Make sure it is a reasonable operand for a move or push insn.  */
    5211                 :       9912 :       if (!REG_P (addr) && !MEM_P (addr)
    5212                 :      19824 :           && !(CONSTANT_P (addr)
    5213                 :          0 :                && targetm.legitimate_constant_p (Pmode, addr)))
    5214                 :       9912 :         addr = force_operand (addr, NULL_RTX);
    5215                 :            : 
    5216                 :       9912 :       argvec[count].value = addr;
    5217                 :      19824 :       argvec[count].mode = Pmode;
    5218                 :       9912 :       argvec[count].partial = 0;
    5219                 :            : 
    5220                 :       9912 :       function_arg_info ptr_arg (Pmode, /*named=*/true);
    5221                 :       9912 :       argvec[count].reg = targetm.calls.function_arg (args_so_far, ptr_arg);
    5222                 :       9912 :       gcc_assert (targetm.calls.arg_partial_bytes (args_so_far, ptr_arg) == 0);
    5223                 :            : 
    5224                 :       9912 :       locate_and_pad_parm (Pmode, NULL_TREE,
    5225                 :            : #ifdef STACK_PARMS_IN_REG_PARM_AREA
    5226                 :            :                            1,
    5227                 :            : #else
    5228                 :       9912 :                            argvec[count].reg != 0,
    5229                 :            : #endif
    5230                 :            :                            reg_parm_stack_space, 0,
    5231                 :            :                            NULL_TREE, &args_size, &argvec[count].locate);
    5232                 :            : 
    5233                 :       9912 :       if (argvec[count].reg == 0 || argvec[count].partial != 0
    5234                 :          0 :           || reg_parm_stack_space > 0)
    5235                 :       9912 :         args_size.constant += argvec[count].locate.size.constant;
    5236                 :            : 
    5237                 :       9912 :       targetm.calls.function_arg_advance (args_so_far, ptr_arg);
    5238                 :            : 
    5239                 :       9912 :       count++;
    5240                 :            :     }
    5241                 :            : 
    5242                 :     239172 :   for (unsigned int i = 0; count < nargs; i++, count++)
    5243                 :            :     {
    5244                 :     152730 :       rtx val = args[i].first;
    5245                 :     152730 :       function_arg_info arg (args[i].second, /*named=*/true);
    5246                 :     152730 :       int unsigned_p = 0;
    5247                 :            : 
    5248                 :            :       /* We cannot convert the arg value to the mode the library wants here;
    5249                 :            :          must do it earlier where we know the signedness of the arg.  */
    5250                 :     152730 :       gcc_assert (arg.mode != BLKmode
    5251                 :            :                   && (GET_MODE (val) == arg.mode
    5252                 :            :                       || GET_MODE (val) == VOIDmode));
    5253                 :            : 
    5254                 :            :       /* Make sure it is a reasonable operand for a move or push insn.  */
    5255                 :      24071 :       if (!REG_P (val) && !MEM_P (val)
    5256                 :     192506 :           && !(CONSTANT_P (val)
    5257                 :      19861 :                && targetm.legitimate_constant_p (arg.mode, val)))
    5258                 :         54 :         val = force_operand (val, NULL_RTX);
    5259                 :            : 
    5260                 :     152730 :       if (pass_by_reference (&args_so_far_v, arg))
    5261                 :            :         {
    5262                 :          0 :           rtx slot;
    5263                 :          0 :           int must_copy = !reference_callee_copied (&args_so_far_v, arg);
    5264                 :            : 
    5265                 :            :           /* If this was a CONST function, it is now PURE since it now
    5266                 :            :              reads memory.  */
    5267                 :          0 :           if (flags & ECF_CONST)
    5268                 :            :             {
    5269                 :          0 :               flags &= ~ECF_CONST;
    5270                 :          0 :               flags |= ECF_PURE;
    5271                 :            :             }
    5272                 :            : 
    5273                 :          0 :           if (MEM_P (val) && !must_copy)
    5274                 :            :             {
    5275                 :          0 :               tree val_expr = MEM_EXPR (val);
    5276                 :          0 :               if (val_expr)
    5277                 :          0 :                 mark_addressable (val_expr);
    5278                 :            :               slot = val;
    5279                 :            :             }
    5280                 :            :           else
    5281                 :            :             {
    5282                 :          0 :               slot = assign_temp (lang_hooks.types.type_for_mode (arg.mode, 0),
    5283                 :            :                                   1, 1);
    5284                 :          0 :               emit_move_insn (slot, val);
    5285                 :            :             }
    5286                 :            : 
    5287                 :          0 :           call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
    5288                 :            :                                            gen_rtx_USE (VOIDmode, slot),
    5289                 :            :                                            call_fusage);
    5290                 :          0 :           if (must_copy)
    5291                 :          0 :             call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
    5292                 :            :                                              gen_rtx_CLOBBER (VOIDmode,
    5293                 :            :                                                               slot),
    5294                 :            :                                              call_fusage);
    5295                 :            : 
    5296                 :          0 :           arg.mode = Pmode;
    5297                 :          0 :           arg.pass_by_reference = true;
    5298                 :          0 :           val = force_operand (XEXP (slot, 0), NULL_RTX);
    5299                 :            :         }
    5300                 :            : 
    5301                 :     152730 :       arg.mode = promote_function_mode (NULL_TREE, arg.mode, &unsigned_p,
    5302                 :            :                                         NULL_TREE, 0);
    5303                 :     152730 :       argvec[count].mode = arg.mode;
    5304                 :     152730 :       argvec[count].value = convert_modes (arg.mode, GET_MODE (val), val,
    5305                 :            :                                            unsigned_p);
    5306                 :     152730 :       argvec[count].reg = targetm.calls.function_arg (args_so_far, arg);
    5307                 :            : 
    5308                 :     152730 :       argvec[count].partial
    5309                 :     152730 :         = targetm.calls.arg_partial_bytes (args_so_far, arg);
    5310                 :            : 
    5311                 :     152730 :       if (argvec[count].reg == 0
    5312                 :     127025 :           || argvec[count].partial != 0
    5313                 :     127025 :           || reg_parm_stack_space > 0)
    5314                 :            :         {
    5315                 :      25705 :           locate_and_pad_parm (arg.mode, NULL_TREE,
    5316                 :            : #ifdef STACK_PARMS_IN_REG_PARM_AREA
    5317                 :            :                                1,
    5318                 :            : #else
    5319                 :            :                                argvec[count].reg != 0,
    5320                 :            : #endif
    5321                 :            :                                reg_parm_stack_space, argvec[count].partial,
    5322                 :            :                                NULL_TREE, &args_size, &argvec[count].locate);
    5323                 :      25705 :           args_size.constant += argvec[count].locate.size.constant;
    5324                 :      25705 :           gcc_assert (!argvec[count].locate.size.var);
    5325                 :            :         }
    5326                 :            : #ifdef BLOCK_REG_PADDING
    5327                 :            :       else
    5328                 :            :         /* The argument is passed entirely in registers.  See at which
    5329                 :            :            end it should be padded.  */
    5330                 :            :         argvec[count].locate.where_pad =
    5331                 :            :           BLOCK_REG_PADDING (arg.mode, NULL_TREE,
    5332                 :            :                              known_le (GET_MODE_SIZE (arg.mode),
    5333                 :            :                                        UNITS_PER_WORD));
    5334                 :            : #endif
    5335                 :            : 
    5336                 :     152730 :       targetm.calls.function_arg_advance (args_so_far, arg);
    5337                 :            :     }
    5338                 :            : 
    5339                 :     249084 :   for (int i = 0; i < nargs; i++)
    5340                 :     162642 :     if (reg_parm_stack_space > 0
    5341                 :     162642 :         || argvec[i].reg == 0
    5342                 :     127025 :         || argvec[i].partial != 0)
    5343                 :     198259 :       update_stack_alignment_for_call (&argvec[i].locate);
    5344                 :            : 
    5345                 :            :   /* If this machine requires an external definition for library
    5346                 :            :      functions, write one out.  */
    5347                 :      86442 :   assemble_external_libcall (fun);
    5348                 :            : 
    5349                 :      86442 :   original_args_size = args_size;
    5350                 :      86442 :   args_size.constant = (aligned_upper_bound (args_size.constant
    5351                 :      86442 :                                              + stack_pointer_delta,
    5352                 :      86442 :                                              STACK_BYTES)
    5353                 :      86442 :                         - stack_pointer_delta);
    5354                 :            : 
    5355                 :      86442 :   args_size.constant = upper_bound (args_size.constant,
    5356                 :      86442 :                                     reg_parm_stack_space);
    5357                 :            : 
    5358                 :      86442 :   if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
    5359                 :      86442 :     args_size.constant -= reg_parm_stack_space;
    5360                 :            : 
    5361                 :     172884 :   crtl->outgoing_args_size = upper_bound (crtl->outgoing_args_size,
    5362                 :      86442 :                                           args_size.constant);
    5363                 :            : 
    5364                 :      86442 :   if (flag_stack_usage_info && !ACCUMULATE_OUTGOING_ARGS)
    5365                 :            :     {
    5366                 :          0 :       poly_int64 pushed = args_size.constant + pending_stack_adjust;
    5367                 :          0 :       current_function_pushed_stack_size
    5368                 :          0 :         = upper_bound (current_function_pushed_stack_size, pushed);
    5369                 :            :     }
    5370                 :            : 
    5371                 :      86442 :   if (ACCUMULATE_OUTGOING_ARGS)
    5372                 :            :     {
    5373                 :            :       /* Since the stack pointer will never be pushed, it is possible for
    5374                 :            :          the evaluation of a parm to clobber something we have already
    5375                 :            :          written to the stack.  Since most function calls on RISC machines
    5376                 :            :          do not use the stack, this is uncommon, but must work correctly.
    5377                 :            : 
    5378                 :            :          Therefore, we save any area of the stack that was already written
    5379                 :            :          and that we are using.  Here we set up to do this by making a new
    5380                 :            :          stack usage map from the old one.
    5381                 :            : 
    5382                 :            :          Another approach might be to try to reorder the argument
    5383                 :            :          evaluations to avoid this conflicting stack usage.  */
    5384                 :            : 
    5385                 :         10 :       needed = args_size.constant;
    5386                 :            : 
    5387                 :            :       /* Since we will be writing into the entire argument area, the
    5388                 :            :          map must be allocated for its entire size, not just the part that
    5389                 :            :          is the responsibility of the caller.  */
    5390                 :         10 :       if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
    5391                 :         10 :         needed += reg_parm_stack_space;
    5392                 :            : 
    5393                 :         10 :       poly_int64 limit = needed;
    5394                 :         10 :       if (ARGS_GROW_DOWNWARD)
    5395                 :            :         limit += 1;
    5396                 :            : 
    5397                 :            :       /* For polynomial sizes, this is the maximum possible size needed
    5398                 :            :          for arguments with a constant size and offset.  */
    5399                 :         10 :       HOST_WIDE_INT const_limit = constant_lower_bound (limit);
    5400                 :         10 :       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
    5401                 :            :                                          const_limit);
    5402                 :            : 
    5403                 :         10 :       stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
    5404                 :         10 :       stack_usage_map = stack_usage_map_buf;
    5405                 :            : 
    5406                 :         10 :       if (initial_highest_arg_in_use)
    5407                 :          0 :         memcpy (stack_usage_map, initial_stack_usage_map,
    5408                 :            :                 initial_highest_arg_in_use);
    5409                 :            : 
    5410                 :         10 :       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
    5411                 :          0 :         memset (&stack_usage_map[initial_highest_arg_in_use], 0,
    5412                 :          0 :                highest_outgoing_arg_in_use - initial_highest_arg_in_use);
    5413                 :         10 :       needed = 0;
    5414                 :            : 
    5415                 :            :       /* We must be careful to use virtual regs before they're instantiated,
    5416                 :            :          and real regs afterwards.  Loop optimization, for example, can create
    5417                 :            :          new libcalls after we've instantiated the virtual regs, and if we
    5418                 :            :          use virtuals anyway, they won't match the rtl patterns.  */
    5419                 :            : 
    5420                 :         10 :       if (virtuals_instantiated)
    5421                 :          0 :         argblock = plus_constant (Pmode, stack_pointer_rtx,
    5422                 :          0 :                                   STACK_POINTER_OFFSET);
    5423                 :            :       else
    5424                 :         10 :         argblock = virtual_outgoing_args_rtx;
    5425                 :            :     }
    5426                 :            :   else
    5427                 :            :     {
    5428                 :      86432 :       if (!PUSH_ARGS)
    5429                 :          0 :         argblock = push_block (gen_int_mode (args_size.constant, Pmode), 0, 0);
    5430                 :            :     }
    5431                 :            : 
    5432                 :            :   /* We push args individually in reverse order, perform stack alignment
    5433                 :            :      before the first push (the last arg).  */
    5434                 :         10 :   if (argblock == 0)
    5435                 :      86432 :     anti_adjust_stack (gen_int_mode (args_size.constant
    5436                 :            :                                      - original_args_size.constant,
    5437                 :      98861 :                                      Pmode));
    5438                 :            : 
    5439                 :      86442 :   argnum = nargs - 1;
    5440                 :            : 
    5441                 :            : #ifdef REG_PARM_STACK_SPACE
    5442                 :      86442 :   if (ACCUMULATE_OUTGOING_ARGS)
    5443                 :            :     {
    5444                 :            :       /* The argument list is the property of the called routine and it
    5445                 :            :          may clobber it.  If the fixed area has been used for previous
    5446                 :            :          parameters, we must save and restore it.  */
    5447                 :         10 :       save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
    5448                 :            :                                             &low_to_save, &high_to_save);
    5449                 :            :     }
    5450                 :            : #endif
    5451                 :            : 
    5452                 :            :   /* When expanding a normal call, args are stored in push order,
    5453                 :            :      which is the reverse of what we have here.  */
    5454                 :      86442 :   bool any_regs = false;
    5455                 :     249084 :   for (int i = nargs; i-- > 0; )
    5456                 :     162642 :     if (argvec[i].reg != NULL_RTX)
    5457                 :            :       {
    5458                 :     127025 :         targetm.calls.call_args (argvec[i].reg, NULL_TREE);
    5459                 :     127025 :         any_regs = true;
    5460                 :            :       }
    5461                 :      86442 :   if (!any_regs)
    5462                 :      13512 :     targetm.calls.call_args (pc_rtx, NULL_TREE);
    5463                 :            : 
    5464                 :            :   /* Push the args that need to be pushed.  */
    5465                 :            : 
    5466                 :            :   have_push_fusage = false;
    5467                 :            : 
    5468                 :            :   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
    5469                 :            :      are to be pushed.  */
    5470                 :     249084 :   for (count = 0; count < nargs; count++, argnum--)
    5471                 :            :     {
    5472                 :     162642 :       machine_mode mode = argvec[argnum].mode;
    5473                 :     162642 :       rtx val = argvec[argnum].value;
    5474                 :     162642 :       rtx reg = argvec[argnum].reg;
    5475                 :     162642 :       int partial = argvec[argnum].partial;
    5476                 :     162642 :       unsigned int parm_align = argvec[argnum].locate.boundary;
    5477                 :     162642 :       poly_int64 lower_bound = 0, upper_bound = 0;
    5478                 :            : 
    5479                 :     162642 :       if (! (reg != 0 && partial == 0))
    5480                 :            :         {
    5481                 :      35617 :           rtx use;
    5482                 :            : 
    5483                 :      35617 :           if (ACCUMULATE_OUTGOING_ARGS)
    5484                 :            :             {
    5485                 :            :               /* If this is being stored into a pre-allocated, fixed-size,
    5486                 :            :                  stack area, save any previous data at that location.  */
    5487                 :            : 
    5488                 :          0 :               if (ARGS_GROW_DOWNWARD)
    5489                 :            :                 {
    5490                 :            :                   /* stack_slot is negative, but we want to index stack_usage_map
    5491                 :            :                      with positive values.  */
    5492                 :            :                   upper_bound = -argvec[argnum].locate.slot_offset.constant + 1;
    5493                 :            :                   lower_bound = upper_bound - argvec[argnum].locate.size.constant;
    5494                 :            :                 }
    5495                 :            :               else
    5496                 :            :                 {
    5497                 :          0 :                   lower_bound = argvec[argnum].locate.slot_offset.constant;
    5498                 :          0 :                   upper_bound = lower_bound + argvec[argnum].locate.size.constant;
    5499                 :            :                 }
    5500                 :            : 
    5501                 :          0 :               if (stack_region_maybe_used_p (lower_bound, upper_bound,
    5502                 :            :                                              reg_parm_stack_space))
    5503                 :            :                 {
    5504                 :            :                   /* We need to make a save area.  */
    5505                 :          0 :                   poly_uint64 size
    5506                 :          0 :                     = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
    5507                 :          0 :                   machine_mode save_mode
    5508                 :          0 :                     = int_mode_for_size (size, 1).else_blk ();
    5509                 :          0 :                   rtx adr
    5510                 :          0 :                     = plus_constant (Pmode, argblock,
    5511                 :          0 :                                      argvec[argnum].locate.offset.constant);
    5512                 :          0 :                   rtx stack_area
    5513                 :          0 :                     = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
    5514                 :            : 
    5515                 :          0 :                   if (save_mode == BLKmode)
    5516                 :            :                     {
    5517                 :          0 :                       argvec[argnum].save_area
    5518                 :          0 :                         = assign_stack_temp (BLKmode,
    5519                 :          0 :                                              argvec[argnum].locate.size.constant
    5520                 :            :                                              );
    5521                 :            : 
    5522                 :          0 :                       emit_block_move (validize_mem
    5523                 :            :                                          (copy_rtx (argvec[argnum].save_area)),
    5524                 :            :                                        stack_area,
    5525                 :            :                                        (gen_int_mode
    5526                 :          0 :                                         (argvec[argnum].locate.size.constant,
    5527                 :          0 :                                          Pmode)),
    5528                 :            :                                        BLOCK_OP_CALL_PARM);
    5529                 :            :                     }
    5530                 :            :                   else
    5531                 :            :                     {
    5532                 :          0 :                       argvec[argnum].save_area = gen_reg_rtx (save_mode);
    5533                 :            : 
    5534                 :          0 :                       emit_move_insn (argvec[argnum].save_area, stack_area);
    5535                 :            :                     }
    5536                 :            :                 }
    5537                 :            :             }
    5538                 :            : 
    5539                 :      35617 :           emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align,
    5540                 :      35617 :                           partial, reg, 0, argblock,
    5541                 :            :                           (gen_int_mode
    5542                 :      70145 :                            (argvec[argnum].locate.offset.constant, Pmode)),
    5543                 :            :                           reg_parm_stack_space,
    5544                 :      70145 :                           ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad), false);
    5545                 :            : 
    5546                 :            :           /* Now mark the segment we just used.  */
    5547                 :      35617 :           if (ACCUMULATE_OUTGOING_ARGS)
    5548                 :          0 :             mark_stack_region_used (lower_bound, upper_bound);
    5549                 :            : 
    5550                 :      35617 :           NO_DEFER_POP;
    5551                 :            : 
    5552                 :            :           /* Indicate argument access so that alias.c knows that these
    5553                 :            :              values are live.  */
    5554                 :      35617 :           if (argblock)
    5555                 :          0 :             use = plus_constant (Pmode, argblock,
    5556                 :          0 :                                  argvec[argnum].locate.offset.constant);
    5557                 :      35617 :           else if (have_push_fusage)
    5558                 :      22101 :             continue;
    5559                 :            :           else
    5560                 :            :             {
    5561                 :            :               /* When arguments are pushed, trying to tell alias.c where
    5562                 :            :                  exactly this argument is won't work, because the
    5563                 :            :                  auto-increment causes confusion.  So we merely indicate
    5564                 :            :                  that we access something with a known mode somewhere on
    5565                 :            :                  the stack.  */
    5566                 :      38374 :               use = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
    5567                 :            :                                   gen_rtx_SCRATCH (Pmode));
    5568                 :      13516 :               have_push_fusage = true;
    5569                 :            :             }
    5570                 :      13516 :           use = gen_rtx_MEM (argvec[argnum].mode, use);
    5571                 :      13516 :           use = gen_rtx_USE (VOIDmode, use);
    5572                 :      13516 :           call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage);
    5573                 :            :         }
    5574                 :            :     }
    5575                 :            : 
    5576                 :      86442 :   argnum = nargs - 1;
    5577                 :            : 
    5578                 :      86442 :   fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0);
    5579                 :            : 
    5580                 :            :   /* Now load any reg parms into their regs.  */
    5581                 :            : 
    5582                 :            :   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
    5583                 :            :      are to be pushed.  */
    5584                 :     249084 :   for (count = 0; count < nargs; count++, argnum--)
    5585                 :            :     {
    5586                 :     162642 :       machine_mode mode = argvec[argnum].mode;
    5587                 :     162642 :       rtx val = argvec[argnum].value;
    5588                 :     162642 :       rtx reg = argvec[argnum].reg;
    5589                 :     162642 :       int partial = argvec[argnum].partial;
    5590                 :            :       
    5591                 :            :       /* Handle calls that pass values in multiple non-contiguous
    5592                 :            :          locations.  The PA64 has examples of this for library calls.  */
    5593                 :     162642 :       if (reg != 0 && GET_CODE (reg) == PARALLEL)
    5594                 :       6980 :         emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode));
    5595                 :     159152 :       else if (reg != 0 && partial == 0)
    5596                 :            :         {
    5597                 :     123535 :           emit_move_insn (reg, val);
    5598                 :            : #ifdef BLOCK_REG_PADDING
    5599                 :            :           poly_int64 size = GET_MODE_SIZE (argvec[argnum].mode);
    5600                 :            : 
    5601                 :            :           /* Copied from load_register_parameters.  */
    5602                 :            : 
    5603                 :            :           /* Handle case where we have a value that needs shifting
    5604                 :            :              up to the msb.  eg. a QImode value and we're padding
    5605                 :            :              upward on a BYTES_BIG_ENDIAN machine.  */
    5606                 :            :           if (known_lt (size, UNITS_PER_WORD)
    5607                 :            :               && (argvec[argnum].locate.where_pad
    5608                 :            :                   == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
    5609                 :            :             {
    5610                 :            :               rtx x;
    5611                 :            :               poly_int64 shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
    5612                 :            : 
    5613                 :            :               /* Assigning REG here rather than a temp makes CALL_FUSAGE
    5614                 :            :                  report the whole reg as used.  Strictly speaking, the
    5615                 :            :                  call only uses SIZE bytes at the msb end, but it doesn't
    5616                 :            :                  seem worth generating rtl to say that.  */
    5617                 :            :               reg = gen_rtx_REG (word_mode, REGNO (reg));
    5618                 :            :               x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
    5619                 :            :               if (x != reg)
    5620                 :            :                 emit_move_insn (reg, x);
    5621                 :            :             }
    5622                 :            : #endif
    5623                 :            :         }
    5624                 :            : 
    5625                 :     162642 :       NO_DEFER_POP;
    5626                 :            :     }
    5627                 :            : 
    5628                 :            :   /* Any regs containing parms remain in use through the call.  */
    5629                 :     249084 :   for (count = 0; count < nargs; count++)
    5630                 :            :     {
    5631                 :     162642 :       rtx reg = argvec[count].reg;
    5632                 :     162642 :       if (reg != 0 && GET_CODE (reg) == PARALLEL)
    5633                 :       3490 :         use_group_regs (&call_fusage, reg);
    5634                 :     159152 :       else if (reg != 0)
    5635                 :            :         {
    5636                 :     123535 :           int partial = argvec[count].partial;
    5637                 :     123535 :           if (partial)
    5638                 :            :             {
    5639                 :          0 :               int nregs;
    5640                 :          0 :               gcc_assert (partial % UNITS_PER_WORD == 0);
    5641                 :          0 :               nregs = partial / UNITS_PER_WORD;
    5642                 :          0 :               use_regs (&call_fusage, REGNO (reg), nregs);
    5643                 :            :             }
    5644                 :            :           else
    5645                 :     286177 :             use_reg (&call_fusage, reg);
    5646                 :            :         }
    5647                 :            :     }
    5648                 :            : 
    5649                 :            :   /* Pass the function the address in which to return a structure value.  */
    5650                 :      86442 :   if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
    5651                 :            :     {
    5652                 :          0 :       emit_move_insn (struct_value,
    5653                 :          0 :                       force_reg (Pmode,
    5654                 :            :                                  force_operand (XEXP (mem_value, 0),
    5655                 :            :                                                 NULL_RTX)));
    5656                 :          0 :       if (REG_P (struct_value))
    5657                 :          0 :         use_reg (&call_fusage, struct_value);
    5658                 :            :     }
    5659                 :            : 
    5660                 :            :   /* Don't allow popping to be deferred, since then
    5661                 :            :      cse'ing of library calls could delete a call and leave the pop.  */
    5662                 :      86442 :   NO_DEFER_POP;
    5663                 :      76530 :   valreg = (mem_value == 0 && outmode != VOIDmode
    5664                 :     162972 :             ? hard_libcall_value (outmode, orgfun) : NULL_RTX);
    5665                 :            : 
    5666                 :            :   /* Stack must be properly aligned now.  */
    5667                 :     172884 :   gcc_assert (multiple_p (stack_pointer_delta,
    5668                 :            :                           PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT));
    5669                 :            : 
    5670                 :      86442 :   before_call = get_last_insn ();
    5671                 :            : 
    5672                 :      86442 :   if (flag_callgraph_info)
    5673                 :          0 :     record_final_call (SYMBOL_REF_DECL (orgfun), UNKNOWN_LOCATION);
    5674                 :            : 
    5675                 :            :   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
    5676                 :            :      will set inhibit_defer_pop to that value.  */
    5677                 :            :   /* The return type is needed to decide how many bytes the function pops.
    5678                 :            :      Signedness plays no role in that, so for simplicity, we pretend it's
    5679                 :            :      always signed.  We also assume that the list of arguments passed has
    5680                 :            :      no impact, so we pretend it is unknown.  */
    5681                 :            : 
    5682                 :      86442 :   emit_call_1 (fun, NULL,
    5683                 :            :                get_identifier (XSTR (orgfun, 0)),
    5684                 :            :                build_function_type (tfom, NULL_TREE),
    5685                 :            :                original_args_size.constant, args_size.constant,
    5686                 :            :                struct_value_size,
    5687                 :      86442 :                targetm.calls.function_arg (args_so_far,
    5688                 :      86442 :                                            function_arg_info::end_marker ()),
    5689                 :            :                valreg,
    5690                 :            :                old_inhibit_defer_pop + 1, call_fusage, flags, args_so_far);
    5691                 :            : 
    5692                 :      86442 :   if (flag_ipa_ra)
    5693                 :            :     {
    5694                 :      57654 :       rtx datum = orgfun;
    5695                 :      57654 :       gcc_assert (GET_CODE (datum) == SYMBOL_REF);
    5696                 :      57654 :       rtx_call_insn *last = last_call_insn ();
    5697                 :      57654 :       add_reg_note (last, REG_CALL_DECL, datum);
    5698                 :            :     }
    5699                 :            : 
    5700                 :            :   /* Right-shift returned value if necessary.  */
    5701                 :      86442 :   if (!pcc_struct_value
    5702                 :      86442 :       && TYPE_MODE (tfom) != BLKmode
    5703                 :      86442 :       && targetm.calls.return_in_msb (tfom))
    5704                 :            :     {
    5705                 :          0 :       shift_return_value (TYPE_MODE (tfom), false, valreg);
    5706                 :          0 :       valreg = gen_rtx_REG (TYPE_MODE (tfom), REGNO (valreg));
    5707                 :            :     }
    5708                 :            : 
    5709                 :      86442 :   targetm.calls.end_call_args ();
    5710                 :            : 
    5711                 :            :   /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
    5712                 :            :      that it should complain if nonvolatile values are live.  For
    5713                 :            :      functions that cannot return, inform flow that control does not
    5714                 :            :      fall through.  */
    5715                 :      86442 :   if (flags & ECF_NORETURN)
    5716                 :            :     {
    5717                 :            :       /* The barrier note must be emitted
    5718                 :            :          immediately after the CALL_INSN.  Some ports emit more than
    5719                 :            :          just a CALL_INSN above, so we must search for it here.  */
    5720                 :          0 :       rtx_insn *last = get_last_insn ();
    5721                 :          0 :       while (!CALL_P (last))
    5722                 :            :         {
    5723                 :          0 :           last = PREV_INSN (last);
    5724                 :            :           /* There was no CALL_INSN?  */
    5725                 :          0 :           gcc_assert (last != before_call);
    5726                 :            :         }
    5727                 :            : 
    5728                 :          0 :       emit_barrier_after (last);
    5729                 :            :     }
    5730                 :            : 
    5731                 :            :   /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
    5732                 :            :      and LCT_RETURNS_TWICE, cannot perform non-local gotos.  */
    5733                 :      86442 :   if (flags & ECF_NOTHROW)
    5734                 :            :     {
    5735                 :      86442 :       rtx_insn *last = get_last_insn ();
    5736                 :      99958 :       while (!CALL_P (last))
    5737                 :            :         {
    5738                 :      13516 :           last = PREV_INSN (last);
    5739                 :            :           /* There was no CALL_INSN?  */
    5740                 :      13516 :           gcc_assert (last != before_call);
    5741                 :            :         }
    5742                 :            : 
    5743                 :      86442 :       make_reg_eh_region_note_nothrow_nononlocal (last);
    5744                 :            :     }
    5745                 :            : 
    5746                 :            :   /* Now restore inhibit_defer_pop to its actual original value.  */
    5747                 :      86442 :   OK_DEFER_POP;
    5748                 :            : 
    5749                 :      86442 :   pop_temp_slots ();
    5750                 :            : 
    5751                 :            :   /* Copy the value to the right place.  */
    5752                 :      86442 :   if (outmode != VOIDmode && retval)
    5753                 :            :     {
    5754                 :      86190 :       if (mem_value)
    5755                 :            :         {
    5756                 :       9912 :           if (value == 0)
    5757                 :       9912 :             value = mem_value;
    5758                 :       9912 :           if (value != mem_value)
    5759                 :          0 :             emit_move_insn (value, mem_value);
    5760                 :            :         }
    5761                 :      76278 :       else if (GET_CODE (valreg) == PARALLEL)
    5762                 :            :         {
    5763                 :          0 :           if (value == 0)
    5764                 :          0 :             value = gen_reg_rtx (outmode);
    5765                 :          0 :           emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
    5766                 :            :         }
    5767                 :            :       else
    5768                 :            :         {
    5769                 :            :           /* Convert to the proper mode if a promotion has been active.  */
    5770                 :      76278 :           if (GET_MODE (valreg) != outmode)
    5771                 :            :             {
    5772                 :          0 :               int unsignedp = TYPE_UNSIGNED (tfom);
    5773                 :            : 
    5774                 :          0 :               gcc_assert (promote_function_mode (tfom, outmode, &unsignedp,
    5775                 :            :                                                  fndecl ? TREE_TYPE (fndecl) : fntype, 1)
    5776                 :            :                           == GET_MODE (valreg));
    5777                 :          0 :               valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0);
    5778                 :            :             }
    5779                 :            : 
    5780                 :      76278 :           if (value != 0)
    5781                 :        324 :             emit_move_insn (value, valreg);
    5782                 :            :           else
    5783                 :            :             value = valreg;
    5784                 :            :         }
    5785                 :            :     }
    5786                 :            : 
    5787                 :      86442 :   if (ACCUMULATE_OUTGOING_ARGS)
    5788                 :            :     {
    5789                 :            : #ifdef REG_PARM_STACK_SPACE
    5790                 :         10 :       if (save_area)
    5791                 :          0 :         restore_fixed_argument_area (save_area, argblock,
    5792                 :            :                                      high_to_save, low_to_save);
    5793                 :            : #endif
    5794                 :            : 
    5795                 :            :       /* If we saved any argument areas, restore them.  */
    5796                 :         24 :       for (count = 0; count < nargs; count++)
    5797                 :         14 :         if (argvec[count].save_area)
    5798                 :            :           {
    5799                 :          0 :             machine_mode save_mode = GET_MODE (argvec[count].save_area);
    5800                 :          0 :             rtx adr = plus_constant (Pmode, argblock,
    5801                 :          0 :                                      argvec[count].locate.offset.constant);
    5802                 :          0 :             rtx stack_area = gen_rtx_MEM (save_mode,
    5803                 :            :                                           memory_address (save_mode, adr));
    5804                 :            : 
    5805                 :          0 :             if (save_mode == BLKmode)
    5806                 :          0 :               emit_block_move (stack_area,
    5807                 :            :                                validize_mem
    5808                 :            :                                  (copy_rtx (argvec[count].save_area)),
    5809                 :            :                                (gen_int_mode
    5810                 :          0 :                                 (argvec[count].locate.size.constant, Pmode)),
    5811                 :            :                                BLOCK_OP_CALL_PARM);
    5812                 :            :             else
    5813                 :          0 :               emit_move_insn (stack_area, argvec[count].save_area);
    5814                 :            :           }
    5815                 :            : 
    5816                 :         10 :       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
    5817                 :         10 :       stack_usage_map = initial_stack_usage_map;
    5818                 :         10 :       stack_usage_watermark = initial_stack_usage_watermark;
    5819                 :            :     }
    5820                 :            : 
    5821                 :      86442 :   free (stack_usage_map_buf);
    5822                 :            : 
    5823                 :      86442 :   return value;
    5824                 :            : 
    5825                 :            : }
    5826                 :            : 
    5827                 :            : 
    5828                 :            : /* Store a single argument for a function call
    5829                 :            :    into the register or memory area where it must be passed.
    5830                 :            :    *ARG describes the argument value and where to pass it.
    5831                 :            : 
    5832                 :            :    ARGBLOCK is the address of the stack-block for all the arguments,
    5833                 :            :    or 0 on a machine where arguments are pushed individually.
    5834                 :            : 
    5835                 :            :    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
    5836                 :            :    so must be careful about how the stack is used.
    5837                 :            : 
    5838                 :            :    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
    5839                 :            :    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
    5840                 :            :    that we need not worry about saving and restoring the stack.
    5841                 :            : 
    5842                 :            :    FNDECL is the declaration of the function we are calling.
    5843                 :            : 
    5844                 :            :    Return nonzero if this arg should cause sibcall failure,
    5845                 :            :    zero otherwise.  */
    5846                 :            : 
    5847                 :            : static int
    5848                 :    1586310 : store_one_arg (struct arg_data *arg, rtx argblock, int flags,
    5849                 :            :                int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
    5850                 :            : {
    5851                 :    1586310 :   tree pval = arg->tree_value;
    5852                 :    1586310 :   rtx reg = 0;
    5853                 :    1586310 :   int partial = 0;
    5854                 :    1586310 :   poly_int64 used = 0;
    5855                 :    1586310 :   poly_int64 lower_bound = 0, upper_bound = 0;
    5856                 :    1586310 :   int sibcall_failure = 0;
    5857                 :            : 
    5858                 :    1586310 :   if (TREE_CODE (pval) == ERROR_MARK)
    5859                 :            :     return 1;
    5860                 :            : 
    5861                 :            :   /* Push a new temporary level for any temporaries we make for
    5862                 :            :      this argument.  */
    5863                 :    1586310 :   push_temp_slots ();
    5864                 :            : 
    5865                 :    1586310 :   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
    5866                 :            :     {
    5867                 :            :       /* If this is being stored into a pre-allocated, fixed-size, stack area,
    5868                 :            :          save any previous data at that location.  */
    5869                 :       1488 :       if (argblock && ! variable_size && arg->stack)
    5870                 :            :         {
    5871                 :       1430 :           if (ARGS_GROW_DOWNWARD)
    5872                 :            :             {
    5873                 :            :               /* stack_slot is negative, but we want to index stack_usage_map
    5874                 :            :                  with positive values.  */
    5875                 :            :               if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
    5876                 :            :                 {
    5877                 :            :                   rtx offset = XEXP (XEXP (arg->stack_slot, 0), 1);
    5878                 :            :                   upper_bound = -rtx_to_poly_int64 (offset) + 1;
    5879                 :            :                 }
    5880                 :            :               else
    5881                 :            :                 upper_bound = 0;
    5882                 :            : 
    5883                 :            :               lower_bound = upper_bound - arg->locate.size.constant;
    5884                 :            :             }
    5885                 :            :           else
    5886                 :            :             {
    5887                 :       1430 :               if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
    5888                 :            :                 {
    5889                 :        126 :                   rtx offset = XEXP (XEXP (arg->stack_slot, 0), 1);
    5890                 :        126 :                   lower_bound = rtx_to_poly_int64 (offset);
    5891                 :            :                 }
    5892                 :            :               else
    5893                 :       1430 :                 lower_bound = 0;
    5894                 :            : 
    5895                 :       1430 :               upper_bound = lower_bound + arg->locate.size.constant;
    5896                 :            :             }
    5897                 :            : 
    5898                 :       2860 :           if (stack_region_maybe_used_p (lower_bound, upper_bound,
    5899                 :            :                                          reg_parm_stack_space))
    5900                 :            :             {
    5901                 :            :               /* We need to make a save area.  */
    5902                 :          0 :               poly_uint64 size = arg->locate.size.constant * BITS_PER_UNIT;
    5903                 :          0 :               machine_mode save_mode
    5904                 :          0 :                 = int_mode_for_size (size, 1).else_blk ();
    5905                 :          0 :               rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
    5906                 :          0 :               rtx stack_area = gen_rtx_MEM (save_mode, adr);
    5907                 :            : 
    5908                 :          0 :               if (save_mode == BLKmode)
    5909                 :            :                 {
    5910                 :          0 :                   arg->save_area
    5911                 :          0 :                     = assign_temp (TREE_TYPE (arg->tree_value), 1, 1);
    5912                 :          0 :                   preserve_temp_slots (arg->save_area);
    5913                 :          0 :                   emit_block_move (validize_mem (copy_rtx (arg->save_area)),
    5914                 :            :                                    stack_area,
    5915                 :            :                                    (gen_int_mode
    5916                 :          0 :                                     (arg->locate.size.constant, Pmode)),
    5917                 :            :                                    BLOCK_OP_CALL_PARM);
    5918                 :            :                 }
    5919                 :            :               else
    5920                 :            :                 {
    5921                 :          0 :                   arg->save_area = gen_reg_rtx (save_mode);
    5922                 :          0 :                   emit_move_insn (arg->save_area, stack_area);
    5923                 :            :                 }
    5924                 :            :             }
    5925                 :            :         }
    5926                 :            :     }
    5927                 :            : 
    5928                 :            :   /* If this isn't going to be placed on both the stack and in registers,
    5929                 :            :      set up the register and number of words.  */
    5930                 :    1586310 :   if (! arg->pass_on_stack)
    5931                 :            :     {
    5932                 :    1586310 :       if (flags & ECF_SIBCALL)
    5933                 :       8982 :         reg = arg->tail_call_reg;
    5934                 :            :       else
    5935                 :    1577330 :         reg = arg->reg;
    5936                 :    1586310 :       partial = arg->partial;
    5937                 :            :     }
    5938                 :            : 
    5939                 :            :   /* Being passed entirely in a register.  We shouldn't be called in
    5940                 :            :      this case.  */
    5941                 :    1586310 :   gcc_assert (reg == 0 || partial != 0);
    5942                 :            : 
    5943                 :            :   /* If this arg needs special alignment, don't load the registers
    5944                 :            :      here.  */
    5945                 :    1586310 :   if (arg->n_aligned_regs != 0)
    5946                 :          0 :     reg = 0;
    5947                 :            : 
    5948                 :            :   /* If this is being passed partially in a register, we can't evaluate
    5949                 :            :      it directly into its stack slot.  Otherwise, we can.  */
    5950                 :    1586310 :   if (arg->value == 0)
    5951                 :            :     {
    5952                 :            :       /* stack_arg_under_construction is nonzero if a function argument is
    5953                 :            :          being evaluated directly into the outgoing argument list and
    5954                 :            :          expand_call must take special action to preserve the argument list
    5955                 :            :          if it is called recursively.
    5956                 :            : 
    5957                 :            :          For scalar function arguments stack_usage_map is sufficient to
    5958                 :            :          determine which stack slots must be saved and restored.  Scalar
    5959                 :            :          arguments in general have pass_on_stack == 0.
    5960                 :            : 
    5961                 :            :          If this argument is initialized by a function which takes the
    5962                 :            :          address of the argument (a C++ constructor or a C function
    5963                 :            :          returning a BLKmode structure), then stack_usage_map is
    5964                 :            :          insufficient and expand_call must push the stack around the
    5965                 :            :          function call.  Such arguments have pass_on_stack == 1.
    5966                 :            : 
    5967                 :            :          Note that it is always safe to set stack_arg_under_construction,
    5968                 :            :          but this generates suboptimal code if set when not needed.  */
    5969                 :            : 
    5970                 :    1586310 :       if (arg->pass_on_stack)
    5971                 :          0 :         stack_arg_under_construction++;
    5972                 :            : 
    5973                 :    3172630 :       arg->value = expand_expr (pval,
    5974                 :            :                                 (partial
    5975                 :    1586310 :                                  || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
    5976                 :            :                                 ? NULL_RTX : arg->stack,
    5977                 :            :                                 VOIDmode, EXPAND_STACK_PARM);
    5978                 :            : 
    5979                 :            :       /* If we are promoting object (or for any other reason) the mode
    5980                 :            :          doesn't agree, convert the mode.  */
    5981                 :            : 
    5982                 :    1586310 :       if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
    5983                 :          0 :         arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
    5984                 :            :                                     arg->value, arg->unsignedp);
    5985                 :            : 
    5986                 :    1586310 :       if (arg->pass_on_stack)
    5987                 :          0 :         stack_arg_under_construction--;
    5988                 :            :     }
    5989                 :            : 
    5990                 :            :   /* Check for overlap with already clobbered argument area.  */
    5991                 :    1586310 :   if ((flags & ECF_SIBCALL)
    5992                 :       8982 :       && MEM_P (arg->value)
    5993                 :    1595300 :       && mem_might_overlap_already_clobbered_arg_p (XEXP (arg->value, 0),
    5994                 :        312 :                                                     arg->locate.size.constant))
    5995                 :            :     sibcall_failure = 1;
    5996                 :            : 
    5997                 :            :   /* Don't allow anything left on stack from computation
    5998                 :            :      of argument to alloca.  */
    5999                 :    1586310 :   if (flags & ECF_MAY_BE_ALLOCA)
    6000                 :          0 :     do_pending_stack_adjust ();
    6001                 :            : 
    6002                 :    1586310 :   if (arg->value == arg->stack)
    6003                 :            :     /* If the value is already in the stack slot, we are done.  */
    6004                 :            :     ;
    6005                 :    1584950 :   else if (arg->mode != BLKmode)
    6006                 :            :     {
    6007                 :    1364190 :       unsigned int parm_align;
    6008                 :            : 
    6009                 :            :       /* Argument is a scalar, not entirely passed in registers.
    6010                 :            :          (If part is passed in registers, arg->partial says how much
    6011                 :            :          and emit_push_insn will take care of putting it there.)
    6012                 :            : 
    6013                 :            :          Push it, and if its size is less than the
    6014                 :            :          amount of space allocated to it,
    6015                 :            :          also bump stack pointer by the additional space.
    6016                 :            :          Note that in C the default argument promotions
    6017                 :            :          will prevent such mismatches.  */
    6018                 :            : 
    6019                 :    1364190 :       poly_int64 size = (TYPE_EMPTY_P (TREE_TYPE (pval))
    6020                 :    2723610 :                          ? 0 : GET_MODE_SIZE (arg->mode));
    6021                 :            : 
    6022                 :            :       /* Compute how much space the push instruction will push.
    6023                 :            :          On many machines, pushing a byte will advance the stack
    6024                 :            :          pointer by a halfword.  */
    6025                 :            : #ifdef PUSH_ROUNDING
    6026                 :    1364190 :       size = PUSH_ROUNDING (size);
    6027                 :            : #endif
    6028                 :    1364190 :       used = size;
    6029                 :            : 
    6030                 :            :       /* Compute how much space the argument should get:
    6031                 :            :          round up to a multiple of the alignment for arguments.  */
    6032                 :    1364190 :       if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
    6033                 :            :           != PAD_NONE)
    6034                 :            :         /* At the moment we don't (need to) support ABIs for which the
    6035                 :            :            padding isn't known at compile time.  In principle it should
    6036                 :            :            be easy to add though.  */
    6037                 :    2522490 :         used = force_align_up (size, PARM_BOUNDARY / BITS_PER_UNIT);
    6038                 :            : 
    6039                 :            :       /* Compute the alignment of the pushed argument.  */
    6040                 :    1364190 :       parm_align = arg->locate.boundary;
    6041                 :    1364190 :       if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
    6042                 :            :           == PAD_DOWNWARD)
    6043                 :            :         {
    6044                 :          0 :           poly_int64 pad = used - size;
    6045                 :          0 :           unsigned int pad_align = known_alignment (pad) * BITS_PER_UNIT;
    6046                 :          0 :           if (pad_align != 0)
    6047                 :          0 :             parm_align = MIN (parm_align, pad_align);
    6048                 :            :         }
    6049                 :            : 
    6050                 :            :       /* This isn't already where we want it on the stack, so put it there.
    6051                 :            :          This can either be done with push or copy insns.  */
    6052                 :    1364190 :       if (maybe_ne (used, 0)
    6053                 :    2723610 :           && !emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
    6054                 :            :                               NULL_RTX, parm_align, partial, reg, used - size,
    6055                 :    2517720 :                               argblock, ARGS_SIZE_RTX (arg->locate.offset),
    6056                 :            :                               reg_parm_stack_space,
    6057                 :    3881910 :                               ARGS_SIZE_RTX (arg->locate.alignment_pad), true))
    6058                 :            :         sibcall_failure = 1;
    6059                 :            : 
    6060                 :            :       /* Unless this is a partially-in-register argument, the argument is now
    6061                 :            :          in the stack.  */
    6062                 :    1364190 :       if (partial == 0)
    6063                 :    1364190 :         arg->value = arg->stack;
    6064                 :            :     }
    6065                 :            :   else
    6066                 :            :     {
    6067                 :            :       /* BLKmode, at least partly to be pushed.  */
    6068                 :            : 
    6069                 :     220758 :       unsigned int parm_align;
    6070                 :     220758 :       poly_int64 excess;
    6071                 :     220758 :       rtx size_rtx;
    6072                 :            : 
    6073                 :            :       /* Pushing a nonscalar.
    6074                 :            :          If part is passed in registers, PARTIAL says how much
    6075                 :            :          and emit_push_insn will take care of putting it there.  */
    6076                 :            : 
    6077                 :            :       /* Round its size up to a multiple
    6078                 :            :          of the allocation unit for arguments.  */
    6079                 :            : 
    6080                 :     220758 :       if (arg->locate.size.var != 0)
    6081                 :            :         {
    6082                 :          0 :           excess = 0;
    6083                 :          0 :           size_rtx = ARGS_SIZE_RTX (arg->locate.size);
    6084                 :            :         }
    6085                 :            :       else
    6086                 :            :         {
    6087                 :            :           /* PUSH_ROUNDING has no effect on us, because emit_push_insn
    6088                 :            :              for BLKmode is careful to avoid it.  */
    6089                 :     220758 :           excess = (arg->locate.size.constant
    6090                 :     220758 :                     - arg_int_size_in_bytes (TREE_TYPE (pval))
    6091                 :     220758 :                     + partial);
    6092                 :     220758 :           size_rtx = expand_expr (arg_size_in_bytes (TREE_TYPE (pval)),
    6093                 :     220758 :                                   NULL_RTX, TYPE_MODE (sizetype),
    6094                 :            :                                   EXPAND_NORMAL);
    6095                 :            :         }
    6096                 :            : 
    6097                 :     220758 :       parm_align = arg->locate.boundary;
    6098                 :            : 
    6099                 :            :       /* When an argument is padded down, the block is aligned to
    6100                 :            :          PARM_BOUNDARY, but the actual argument isn't.  */
    6101                 :     220758 :       if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
    6102                 :            :           == PAD_DOWNWARD)
    6103                 :            :         {
    6104                 :          0 :           if (arg->locate.size.var)
    6105                 :            :             parm_align = BITS_PER_UNIT;
    6106                 :            :           else
    6107                 :            :             {
    6108                 :          0 :               unsigned int excess_align
    6109                 :          0 :                 = known_alignment (excess) * BITS_PER_UNIT;
    6110                 :          0 :               if (excess_align != 0)
    6111                 :          0 :                 parm_align = MIN (parm_align, excess_align);
    6112                 :            :             }
    6113                 :            :         }
    6114                 :            : 
    6115                 :     220758 :       if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
    6116                 :            :         {
    6117                 :            :           /* emit_push_insn might not work properly if arg->value and
    6118                 :            :              argblock + arg->locate.offset areas overlap.  */
    6119                 :         66 :           rtx x = arg->value;
    6120                 :         66 :           poly_int64 i = 0;
    6121                 :            : 
    6122                 :         66 :           if (strip_offset (XEXP (x, 0), &i)
    6123                 :         66 :               == crtl->args.internal_arg_pointer)
    6124                 :            :             {
    6125                 :            :               /* arg.locate doesn't contain the pretend_args_size offset,
    6126                 :            :                  it's part of argblock.  Ensure we don't count it in I.  */
    6127                 :         29 :               if (STACK_GROWS_DOWNWARD)
    6128                 :         29 :                 i -= crtl->args.pretend_args_size;
    6129                 :            :               else
    6130                 :            :                 i += crtl->args.pretend_args_size;
    6131                 :            : 
    6132                 :            :               /* expand_call should ensure this.  */
    6133                 :         29 :               gcc_assert (!arg->locate.offset.var
    6134                 :            :                           && arg->locate.size.var == 0);
    6135                 :         29 :               poly_int64 size_val = rtx_to_poly_int64 (size_rtx);
    6136                 :            : 
    6137                 :         29 :               if (known_eq (arg->locate.offset.constant, i))
    6138                 :            :                 {
    6139                 :            :                   /* Even though they appear to be at the same location,
    6140                 :            :                      if part of the outgoing argument is in registers,
    6141                 :            :                      they aren't really at the same location.  Check for
    6142                 :            :                      this by making sure that the incoming size is the
    6143                 :            :                      same as the outgoing size.  */
    6144                 :         23 :                   if (maybe_ne (arg->locate.size.constant, size_val))
    6145                 :          0 :                     sibcall_failure = 1;
    6146                 :            :                 }
    6147                 :          6 :               else if (maybe_in_range_p (arg->locate.offset.constant,
    6148                 :            :                                          i, size_val))
    6149                 :            :                 sibcall_failure = 1;
    6150                 :            :               /* Use arg->locate.size.constant instead of size_rtx
    6151                 :            :                  because we only care about the part of the argument
    6152                 :            :                  on the stack.  */
    6153                 :         66 :               else if (maybe_in_range_p (i, arg->locate.offset.constant,
    6154                 :          6 :                                          arg->locate.size.constant))
    6155                 :          0 :                 sibcall_failure = 1;
    6156                 :            :             }
    6157                 :            :         }
    6158                 :            : 
    6159                 :     220758 :       if (!CONST_INT_P (size_rtx) || INTVAL (size_rtx) != 0)
    6160                 :     218913 :         emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
    6161                 :            :                         parm_align, partial, reg, excess, argblock,
    6162                 :     277016 :                         ARGS_SIZE_RTX (arg->locate.offset),
    6163                 :            :                         reg_parm_stack_space,
    6164                 :     495929 :                         ARGS_SIZE_RTX (arg->locate.alignment_pad), false);
    6165                 :            : 
    6166                 :            :       /* Unless this is a partially-in-register argument, the argument is now
    6167                 :            :          in the stack.
    6168                 :            : 
    6169                 :            :          ??? Unlike the case above, in which we want the actual
    6170                 :            :          address of the data, so that we can load it directly into a
    6171                 :            :          register, here we want the address of the stack slot, so that
    6172                 :            :          it's properly aligned for word-by-word copying or something
    6173                 :            :          like that.  It's not clear that this is always correct.  */
    6174                 :     220758 :       if (partial == 0)
    6175                 :     220758 :         arg->value = arg->stack_slot;
    6176                 :            :     }
    6177                 :            : 
    6178                 :    1586310 :   if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
    6179                 :            :     {
    6180                 :          0 :       tree type = TREE_TYPE (arg->tree_value);
    6181                 :          0 :       arg->parallel_value
    6182                 :          0 :         = emit_group_load_into_temps (arg->reg, arg->value, type,
    6183                 :          0 :                                       int_size_in_bytes (type));
    6184                 :            :     }
    6185                 :            : 
    6186                 :            :   /* Mark all slots this store used.  */
    6187                 :    1586310 :   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
    6188                 :    1587800 :       && argblock && ! variable_size && arg->stack)
    6189                 :       1430 :     mark_stack_region_used (lower_bound, upper_bound);
    6190                 :            : 
    6191                 :            :   /* Once we have pushed something, pops can't safely
    6192                 :            :      be deferred during the rest of the arguments.  */
    6193                 :    1586310 :   NO_DEFER_POP;
    6194                 :            : 
    6195                 :            :   /* Free any temporary slots made in processing this argument.  */
    6196                 :    1586310 :   pop_temp_slots ();
    6197                 :            : 
    6198                 :    1586310 :   return sibcall_failure;
    6199                 :            : }
    6200                 :            : 
    6201                 :            : /* Nonzero if we do not know how to pass ARG solely in registers.  */
    6202                 :            : 
    6203                 :            : bool
    6204                 :          0 : must_pass_in_stack_var_size (const function_arg_info &arg)
    6205                 :            : {
    6206                 :          0 :   if (!arg.type)
    6207                 :            :     return false;
    6208                 :            : 
    6209                 :            :   /* If the type has variable size...  */
    6210                 :          0 :   if (!poly_int_tree_p (TYPE_SIZE (arg.type)))
    6211                 :            :     return true;
    6212                 :            : 
    6213                 :            :   /* If the type is marked as addressable (it is required
    6214                 :            :      to be constructed into the stack)...  */
    6215                 :          0 :   if (TREE_ADDRESSABLE (arg.type))
    6216                 :          0 :     return true;
    6217                 :            : 
    6218                 :            :   return false;
    6219                 :            : }
    6220                 :            : 
    6221                 :            : /* Another version of the TARGET_MUST_PASS_IN_STACK hook.  This one
    6222                 :            :    takes trailing padding of a structure into account.  */
    6223                 :            : /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING.  */
    6224                 :            : 
    6225                 :            : bool
    6226                 :  169862000 : must_pass_in_stack_var_size_or_pad (const function_arg_info &arg)
    6227                 :            : {
    6228                 :  169862000 :   if (!arg.type)
    6229                 :            :     return false;
    6230                 :            : 
    6231                 :            :   /* If the type has variable size...  */
    6232                 :  169340000 :   if (TREE_CODE (TYPE_SIZE (arg.type)) != INTEGER_CST)
    6233                 :            :     return true;
    6234                 :            : 
    6235                 :            :   /* If the type is marked as addressable (it is required
    6236                 :            :      to be constructed into the stack)...  */
    6237                 :  169340000 :   if (TREE_ADDRESSABLE (arg.type))
    6238                 :            :     return true;
    6239                 :            : 
    6240                 :  169340000 :   if (TYPE_EMPTY_P (arg.type))
    6241                 :            :     return false;
    6242                 :            : 
    6243                 :            :   /* If the padding and mode of the type is such that a copy into
    6244                 :            :      a register would put it into the wrong part of the register.  */
    6245                 :  169000000 :   if (arg.mode == BLKmode
    6246                 :    1865660 :       && int_size_in_bytes (arg.type) % (PARM_BOUNDARY / BITS_PER_UNIT)
    6247                 :  169167000 :       && (targetm.calls.function_arg_padding (arg.mode, arg.type)
    6248                 :            :           == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
    6249                 :          0 :     return true;
    6250                 :            : 
    6251                 :            :   return false;
    6252                 :            : }
    6253                 :            : 
    6254                 :            : /* Return true if TYPE must be passed on the stack when passed to
    6255                 :            :    the "..." arguments of a function.  */
    6256                 :            : 
    6257                 :            : bool
    6258                 :          0 : must_pass_va_arg_in_stack (tree type)
    6259                 :            : {
    6260                 :          0 :   function_arg_info arg (type, /*named=*/false);
    6261                 :          0 :   return targetm.calls.must_pass_in_stack (arg);
    6262                 :            : }
    6263                 :            : 
    6264                 :            : /* Tell the garbage collector about GTY markers in this source file.  */
    6265                 :            : #include "gt-calls.h"

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.