LCOV - code coverage report
Current view: top level - gcc - function.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 2200 2667 82.5 %
Date: 2020-04-04 11:58:09 Functions: 129 152 84.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Expands front end tree to back end RTL for GCC.
       2                 :            :    Copyright (C) 1987-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                 :            : /* This file handles the generation of rtl code from tree structure
      21                 :            :    at the level of the function as a whole.
      22                 :            :    It creates the rtl expressions for parameters and auto variables
      23                 :            :    and has full responsibility for allocating stack slots.
      24                 :            : 
      25                 :            :    `expand_function_start' is called at the beginning of a function,
      26                 :            :    before the function body is parsed, and `expand_function_end' is
      27                 :            :    called after parsing the body.
      28                 :            : 
      29                 :            :    Call `assign_stack_local' to allocate a stack slot for a local variable.
      30                 :            :    This is usually done during the RTL generation for the function body,
      31                 :            :    but it can also be done in the reload pass when a pseudo-register does
      32                 :            :    not get a hard register.  */
      33                 :            : 
      34                 :            : #include "config.h"
      35                 :            : #include "system.h"
      36                 :            : #include "coretypes.h"
      37                 :            : #include "backend.h"
      38                 :            : #include "target.h"
      39                 :            : #include "rtl.h"
      40                 :            : #include "tree.h"
      41                 :            : #include "gimple-expr.h"
      42                 :            : #include "cfghooks.h"
      43                 :            : #include "df.h"
      44                 :            : #include "memmodel.h"
      45                 :            : #include "tm_p.h"
      46                 :            : #include "stringpool.h"
      47                 :            : #include "expmed.h"
      48                 :            : #include "optabs.h"
      49                 :            : #include "regs.h"
      50                 :            : #include "emit-rtl.h"
      51                 :            : #include "recog.h"
      52                 :            : #include "rtl-error.h"
      53                 :            : #include "alias.h"
      54                 :            : #include "fold-const.h"
      55                 :            : #include "stor-layout.h"
      56                 :            : #include "varasm.h"
      57                 :            : #include "except.h"
      58                 :            : #include "dojump.h"
      59                 :            : #include "explow.h"
      60                 :            : #include "calls.h"
      61                 :            : #include "expr.h"
      62                 :            : #include "optabs-tree.h"
      63                 :            : #include "output.h"
      64                 :            : #include "langhooks.h"
      65                 :            : #include "common/common-target.h"
      66                 :            : #include "gimplify.h"
      67                 :            : #include "tree-pass.h"
      68                 :            : #include "cfgrtl.h"
      69                 :            : #include "cfganal.h"
      70                 :            : #include "cfgbuild.h"
      71                 :            : #include "cfgcleanup.h"
      72                 :            : #include "cfgexpand.h"
      73                 :            : #include "shrink-wrap.h"
      74                 :            : #include "toplev.h"
      75                 :            : #include "rtl-iter.h"
      76                 :            : #include "tree-dfa.h"
      77                 :            : #include "tree-ssa.h"
      78                 :            : #include "stringpool.h"
      79                 :            : #include "attribs.h"
      80                 :            : #include "gimple.h"
      81                 :            : #include "options.h"
      82                 :            : #include "function-abi.h"
      83                 :            : 
      84                 :            : /* So we can assign to cfun in this file.  */
      85                 :            : #undef cfun
      86                 :            : 
      87                 :            : #ifndef STACK_ALIGNMENT_NEEDED
      88                 :            : #define STACK_ALIGNMENT_NEEDED 1
      89                 :            : #endif
      90                 :            : 
      91                 :            : #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
      92                 :            : 
      93                 :            : /* Round a value to the lowest integer less than it that is a multiple of
      94                 :            :    the required alignment.  Avoid using division in case the value is
      95                 :            :    negative.  Assume the alignment is a power of two.  */
      96                 :            : #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
      97                 :            : 
      98                 :            : /* Similar, but round to the next highest integer that meets the
      99                 :            :    alignment.  */
     100                 :            : #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
     101                 :            : 
     102                 :            : /* Nonzero once virtual register instantiation has been done.
     103                 :            :    assign_stack_local uses frame_pointer_rtx when this is nonzero.
     104                 :            :    calls.c:emit_library_call_value_1 uses it to set up
     105                 :            :    post-instantiation libcalls.  */
     106                 :            : int virtuals_instantiated;
     107                 :            : 
     108                 :            : /* Assign unique numbers to labels generated for profiling, debugging, etc.  */
     109                 :            : static GTY(()) int funcdef_no;
     110                 :            : 
     111                 :            : /* These variables hold pointers to functions to create and destroy
     112                 :            :    target specific, per-function data structures.  */
     113                 :            : struct machine_function * (*init_machine_status) (void);
     114                 :            : 
     115                 :            : /* The currently compiled function.  */
     116                 :            : struct function *cfun = 0;
     117                 :            : 
     118                 :            : /* These hashes record the prologue and epilogue insns.  */
     119                 :            : 
     120                 :            : struct insn_cache_hasher : ggc_cache_ptr_hash<rtx_def>
     121                 :            : {
     122                 :  886227000 :   static hashval_t hash (rtx x) { return htab_hash_pointer (x); }
     123                 :  575842000 :   static bool equal (rtx a, rtx b) { return a == b; }
     124                 :            : };
     125                 :            : 
     126                 :            : static GTY((cache))
     127                 :            :   hash_table<insn_cache_hasher> *prologue_insn_hash;
     128                 :            : static GTY((cache))
     129                 :            :   hash_table<insn_cache_hasher> *epilogue_insn_hash;
     130                 :            : 
     131                 :            : 
     132                 :            : hash_table<used_type_hasher> *types_used_by_vars_hash = NULL;
     133                 :            : vec<tree, va_gc> *types_used_by_cur_var_decl;
     134                 :            : 
     135                 :            : /* Forward declarations.  */
     136                 :            : 
     137                 :            : static class temp_slot *find_temp_slot_from_address (rtx);
     138                 :            : static void pad_to_arg_alignment (struct args_size *, int, struct args_size *);
     139                 :            : static void pad_below (struct args_size *, machine_mode, tree);
     140                 :            : static void reorder_blocks_1 (rtx_insn *, tree, vec<tree> *);
     141                 :            : static int all_blocks (tree, tree *);
     142                 :            : static tree *get_block_vector (tree, int *);
     143                 :            : extern tree debug_find_var_in_block_tree (tree, tree);
     144                 :            : /* We always define `record_insns' even if it's not used so that we
     145                 :            :    can always export `prologue_epilogue_contains'.  */
     146                 :            : static void record_insns (rtx_insn *, rtx, hash_table<insn_cache_hasher> **)
     147                 :            :      ATTRIBUTE_UNUSED;
     148                 :            : static bool contains (const rtx_insn *, hash_table<insn_cache_hasher> *);
     149                 :            : static void prepare_function_start (void);
     150                 :            : static void do_clobber_return_reg (rtx, void *);
     151                 :            : static void do_use_return_reg (rtx, void *);
     152                 :            : 
     153                 :            : 
     154                 :            : /* Stack of nested functions.  */
     155                 :            : /* Keep track of the cfun stack.  */
     156                 :            : 
     157                 :            : static vec<function *> function_context_stack;
     158                 :            : 
     159                 :            : /* Save the current context for compilation of a nested function.
     160                 :            :    This is called from language-specific code.  */
     161                 :            : 
     162                 :            : void
     163                 :   14103700 : push_function_context (void)
     164                 :            : {
     165                 :   14103700 :   if (cfun == 0)
     166                 :          9 :     allocate_struct_function (NULL, false);
     167                 :            : 
     168                 :   14103700 :   function_context_stack.safe_push (cfun);
     169                 :   14103700 :   set_cfun (NULL);
     170                 :   14103700 : }
     171                 :            : 
     172                 :            : /* Restore the last saved context, at the end of a nested function.
     173                 :            :    This function is called from language-specific code.  */
     174                 :            : 
     175                 :            : void
     176                 :   14103600 : pop_function_context (void)
     177                 :            : {
     178                 :   14103600 :   struct function *p = function_context_stack.pop ();
     179                 :   14103600 :   set_cfun (p);
     180                 :   14103600 :   current_function_decl = p->decl;
     181                 :            : 
     182                 :            :   /* Reset variables that have known state during rtx generation.  */
     183                 :   14103600 :   virtuals_instantiated = 0;
     184                 :   14103600 :   generating_concat_p = 1;
     185                 :   14103600 : }
     186                 :            : 
     187                 :            : /* Clear out all parts of the state in F that can safely be discarded
     188                 :            :    after the function has been parsed, but not compiled, to let
     189                 :            :    garbage collection reclaim the memory.  */
     190                 :            : 
     191                 :            : void
     192                 :    1096240 : free_after_parsing (struct function *f)
     193                 :            : {
     194                 :    1096240 :   f->language = 0;
     195                 :    1096240 : }
     196                 :            : 
     197                 :            : /* Clear out all parts of the state in F that can safely be discarded
     198                 :            :    after the function has been compiled, to let garbage collection
     199                 :            :    reclaim the memory.  */
     200                 :            : 
     201                 :            : void
     202                 :    1101480 : free_after_compilation (struct function *f)
     203                 :            : {
     204                 :    1101480 :   prologue_insn_hash = NULL;
     205                 :    1101480 :   epilogue_insn_hash = NULL;
     206                 :            : 
     207                 :    1101480 :   free (crtl->emit.regno_pointer_align);
     208                 :            : 
     209                 :    1101480 :   memset (crtl, 0, sizeof (struct rtl_data));
     210                 :    1101480 :   f->eh = NULL;
     211                 :    1101480 :   f->machine = NULL;
     212                 :    1101480 :   f->cfg = NULL;
     213                 :    1101480 :   f->curr_properties &= ~PROP_cfg;
     214                 :            : 
     215                 :    1101480 :   regno_reg_rtx = NULL;
     216                 :    1101480 : }
     217                 :            : 
     218                 :            : /* Return size needed for stack frame based on slots so far allocated.
     219                 :            :    This size counts from zero.  It is not rounded to PREFERRED_STACK_BOUNDARY;
     220                 :            :    the caller may have to do that.  */
     221                 :            : 
     222                 :            : poly_int64
     223                 :  123846000 : get_frame_size (void)
     224                 :            : {
     225                 :  123846000 :   if (FRAME_GROWS_DOWNWARD)
     226                 :  123846000 :     return -frame_offset;
     227                 :            :   else
     228                 :            :     return frame_offset;
     229                 :            : }
     230                 :            : 
     231                 :            : /* Issue an error message and return TRUE if frame OFFSET overflows in
     232                 :            :    the signed target pointer arithmetics for function FUNC.  Otherwise
     233                 :            :    return FALSE.  */
     234                 :            : 
     235                 :            : bool
     236                 :    2469950 : frame_offset_overflow (poly_int64 offset, tree func)
     237                 :            : {
     238                 :    2469950 :   poly_uint64 size = FRAME_GROWS_DOWNWARD ? -offset : offset;
     239                 :    2469950 :   unsigned HOST_WIDE_INT limit
     240                 :    2973790 :     = ((HOST_WIDE_INT_1U << (GET_MODE_BITSIZE (Pmode) - 1))
     241                 :            :        /* Leave room for the fixed part of the frame.  */
     242                 :    2469950 :        - 64 * UNITS_PER_WORD);
     243                 :            : 
     244                 :    4939900 :   if (!coeffs_in_range_p (size, 0U, limit))
     245                 :            :     {
     246                 :          0 :       unsigned HOST_WIDE_INT hwisize;
     247                 :          0 :       if (size.is_constant (&hwisize))
     248                 :          0 :         error_at (DECL_SOURCE_LOCATION (func),
     249                 :            :                   "total size of local objects %wu exceeds maximum %wu",
     250                 :            :                   hwisize, limit);
     251                 :            :       else
     252                 :            :         error_at (DECL_SOURCE_LOCATION (func),
     253                 :            :                   "total size of local objects exceeds maximum %wu",
     254                 :            :                   limit);
     255                 :          0 :       return true;
     256                 :            :     }
     257                 :            : 
     258                 :            :   return false;
     259                 :            : }
     260                 :            : 
     261                 :            : /* Return the minimum spill slot alignment for a register of mode MODE.  */
     262                 :            : 
     263                 :            : unsigned int
     264                 :     788942 : spill_slot_alignment (machine_mode mode ATTRIBUTE_UNUSED)
     265                 :            : {
     266                 :     788942 :   return STACK_SLOT_ALIGNMENT (NULL_TREE, mode, GET_MODE_ALIGNMENT (mode));
     267                 :            : }
     268                 :            : 
     269                 :            : /* Return stack slot alignment in bits for TYPE and MODE.  */
     270                 :            : 
     271                 :            : static unsigned int
     272                 :      88733 : get_stack_local_alignment (tree type, machine_mode mode)
     273                 :            : {
     274                 :      88733 :   unsigned int alignment;
     275                 :            : 
     276                 :      88733 :   if (mode == BLKmode)
     277                 :       3241 :     alignment = BIGGEST_ALIGNMENT;
     278                 :            :   else
     279                 :      85492 :     alignment = GET_MODE_ALIGNMENT (mode);
     280                 :            : 
     281                 :            :   /* Allow the frond-end to (possibly) increase the alignment of this
     282                 :            :      stack slot.  */
     283                 :      88733 :   if (! type)
     284                 :      15323 :     type = lang_hooks.types.type_for_mode (mode, 0);
     285                 :            : 
     286                 :      88733 :   return STACK_SLOT_ALIGNMENT (type, mode, alignment);
     287                 :            : }
     288                 :            : 
     289                 :            : /* Determine whether it is possible to fit a stack slot of size SIZE and
     290                 :            :    alignment ALIGNMENT into an area in the stack frame that starts at
     291                 :            :    frame offset START and has a length of LENGTH.  If so, store the frame
     292                 :            :    offset to be used for the stack slot in *POFFSET and return true;
     293                 :            :    return false otherwise.  This function will extend the frame size when
     294                 :            :    given a start/length pair that lies at the end of the frame.  */
     295                 :            : 
     296                 :            : static bool
     297                 :    1413000 : try_fit_stack_local (poly_int64 start, poly_int64 length,
     298                 :            :                      poly_int64 size, unsigned int alignment,
     299                 :            :                      poly_int64_pod *poffset)
     300                 :            : {
     301                 :    1413000 :   poly_int64 this_frame_offset;
     302                 :    1413000 :   int frame_off, frame_alignment, frame_phase;
     303                 :            : 
     304                 :            :   /* Calculate how many bytes the start of local variables is off from
     305                 :            :      stack alignment.  */
     306                 :    1413000 :   frame_alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
     307                 :    1413000 :   frame_off = targetm.starting_frame_offset () % frame_alignment;
     308                 :    1413000 :   frame_phase = frame_off ? frame_alignment - frame_off : 0;
     309                 :            : 
     310                 :            :   /* Round the frame offset to the specified alignment.  */
     311                 :            : 
     312                 :    1413000 :   if (FRAME_GROWS_DOWNWARD)
     313                 :    1413000 :     this_frame_offset
     314                 :    1413000 :       = (aligned_lower_bound (start + length - size - frame_phase, alignment)
     315                 :    1413000 :          + frame_phase);
     316                 :            :   else
     317                 :            :     this_frame_offset
     318                 :            :       = aligned_upper_bound (start - frame_phase, alignment) + frame_phase;
     319                 :            : 
     320                 :            :   /* See if it fits.  If this space is at the edge of the frame,
     321                 :            :      consider extending the frame to make it fit.  Our caller relies on
     322                 :            :      this when allocating a new slot.  */
     323                 :    1413000 :   if (maybe_lt (this_frame_offset, start))
     324                 :            :     {
     325                 :     325713 :       if (known_eq (frame_offset, start))
     326                 :     204897 :         frame_offset = this_frame_offset;
     327                 :            :       else
     328                 :            :         return false;
     329                 :            :     }
     330                 :    1087280 :   else if (maybe_gt (this_frame_offset + size, start + length))
     331                 :            :     {
     332                 :          0 :       if (known_eq (frame_offset, start + length))
     333                 :          0 :         frame_offset = this_frame_offset + size;
     334                 :            :       else
     335                 :            :         return false;
     336                 :            :     }
     337                 :            : 
     338                 :    1292180 :   *poffset = this_frame_offset;
     339                 :    1292180 :   return true;
     340                 :            : }
     341                 :            : 
     342                 :            : /* Create a new frame_space structure describing free space in the stack
     343                 :            :    frame beginning at START and ending at END, and chain it into the
     344                 :            :    function's frame_space_list.  */
     345                 :            : 
     346                 :            : static void
     347                 :     223243 : add_frame_space (poly_int64 start, poly_int64 end)
     348                 :            : {
     349                 :     223243 :   class frame_space *space = ggc_alloc<frame_space> ();
     350                 :     223243 :   space->next = crtl->frame_space_list;
     351                 :     223243 :   crtl->frame_space_list = space;
     352                 :     223243 :   space->start = start;
     353                 :     223243 :   space->length = end - start;
     354                 :     223243 : }
     355                 :            : 
     356                 :            : /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
     357                 :            :    with machine mode MODE.
     358                 :            : 
     359                 :            :    ALIGN controls the amount of alignment for the address of the slot:
     360                 :            :    0 means according to MODE,
     361                 :            :    -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
     362                 :            :    -2 means use BITS_PER_UNIT,
     363                 :            :    positive specifies alignment boundary in bits.
     364                 :            : 
     365                 :            :    KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce
     366                 :            :    alignment and ASLK_RECORD_PAD bit set if we should remember
     367                 :            :    extra space we allocated for alignment purposes.  When we are
     368                 :            :    called from assign_stack_temp_for_type, it is not set so we don't
     369                 :            :    track the same stack slot in two independent lists.
     370                 :            : 
     371                 :            :    We do not round to stack_boundary here.  */
     372                 :            : 
     373                 :            : rtx
     374                 :    1292180 : assign_stack_local_1 (machine_mode mode, poly_int64 size,
     375                 :            :                       int align, int kind)
     376                 :            : {
     377                 :    1292180 :   rtx x, addr;
     378                 :    1292180 :   poly_int64 bigend_correction = 0;
     379                 :    1292180 :   poly_int64 slot_offset = 0, old_frame_offset;
     380                 :    1292180 :   unsigned int alignment, alignment_in_bits;
     381                 :            : 
     382                 :    1292180 :   if (align == 0)
     383                 :            :     {
     384                 :       6610 :       alignment = get_stack_local_alignment (NULL, mode);
     385                 :       6610 :       alignment /= BITS_PER_UNIT;
     386                 :            :     }
     387                 :    1285570 :   else if (align == -1)
     388                 :            :     {
     389                 :        381 :       alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
     390                 :        381 :       size = aligned_upper_bound (size, alignment);
     391                 :            :     }
     392                 :    1285190 :   else if (align == -2)
     393                 :            :     alignment = 1; /* BITS_PER_UNIT / BITS_PER_UNIT */
     394                 :            :   else
     395                 :    1285190 :     alignment = align / BITS_PER_UNIT;
     396                 :            : 
     397                 :    1292180 :   alignment_in_bits = alignment * BITS_PER_UNIT;
     398                 :            : 
     399                 :            :   /* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT.  */
     400                 :    1292180 :   if (alignment_in_bits > MAX_SUPPORTED_STACK_ALIGNMENT)
     401                 :            :     {
     402                 :          0 :       alignment_in_bits = MAX_SUPPORTED_STACK_ALIGNMENT;
     403                 :          0 :       alignment = MAX_SUPPORTED_STACK_ALIGNMENT / BITS_PER_UNIT;
     404                 :            :     }
     405                 :            : 
     406                 :    1292180 :   if (SUPPORTS_STACK_ALIGNMENT)
     407                 :            :     {
     408                 :    1292180 :       if (crtl->stack_alignment_estimated < alignment_in_bits)
     409                 :            :         {
     410                 :       2115 :           if (!crtl->stack_realign_processed)
     411                 :       2098 :             crtl->stack_alignment_estimated = alignment_in_bits;
     412                 :            :           else
     413                 :            :             {
     414                 :            :               /* If stack is realigned and stack alignment value
     415                 :            :                  hasn't been finalized, it is OK not to increase
     416                 :            :                  stack_alignment_estimated.  The bigger alignment
     417                 :            :                  requirement is recorded in stack_alignment_needed
     418                 :            :                  below.  */
     419                 :         17 :               gcc_assert (!crtl->stack_realign_finalized);
     420                 :         17 :               if (!crtl->stack_realign_needed)
     421                 :            :                 {
     422                 :            :                   /* It is OK to reduce the alignment as long as the
     423                 :            :                      requested size is 0 or the estimated stack
     424                 :            :                      alignment >= mode alignment.  */
     425                 :         17 :                   gcc_assert ((kind & ASLK_REDUCE_ALIGN)
     426                 :            :                               || known_eq (size, 0)
     427                 :            :                               || (crtl->stack_alignment_estimated
     428                 :            :                                   >= GET_MODE_ALIGNMENT (mode)));
     429                 :         17 :                   alignment_in_bits = crtl->stack_alignment_estimated;
     430                 :         17 :                   alignment = alignment_in_bits / BITS_PER_UNIT;
     431                 :            :                 }
     432                 :            :             }
     433                 :            :         }
     434                 :            :     }
     435                 :            : 
     436                 :    1292180 :   if (crtl->stack_alignment_needed < alignment_in_bits)
     437                 :      24553 :     crtl->stack_alignment_needed = alignment_in_bits;
     438                 :    1292180 :   if (crtl->max_used_stack_slot_alignment < alignment_in_bits)
     439                 :     293952 :     crtl->max_used_stack_slot_alignment = alignment_in_bits;
     440                 :            : 
     441                 :    1292180 :   if (mode != BLKmode || maybe_ne (size, 0))
     442                 :            :     {
     443                 :     812007 :       if (kind & ASLK_RECORD_PAD)
     444                 :            :         {
     445                 :            :           class frame_space **psp;
     446                 :            : 
     447                 :     898182 :           for (psp = &crtl->frame_space_list; *psp; psp = &(*psp)->next)
     448                 :            :             {
     449                 :     160798 :               class frame_space *space = *psp;
     450                 :     160798 :               if (!try_fit_stack_local (space->start, space->length, size,
     451                 :            :                                         alignment, &slot_offset))
     452                 :     120816 :                 continue;
     453                 :      39982 :               *psp = space->next;
     454                 :      39982 :               if (known_gt (slot_offset, space->start))
     455                 :      17516 :                 add_frame_space (space->start, slot_offset);
     456                 :      39982 :               if (known_lt (slot_offset + size, space->start + space->length))
     457                 :       4833 :                 add_frame_space (slot_offset + size,
     458                 :            :                                  space->start + space->length);
     459                 :      39982 :               goto found_space;
     460                 :            :             }
     461                 :            :         }
     462                 :            :     }
     463                 :            :   else if (!STACK_ALIGNMENT_NEEDED)
     464                 :            :     {
     465                 :            :       slot_offset = frame_offset;
     466                 :            :       goto found_space;
     467                 :            :     }
     468                 :            : 
     469                 :    1252200 :   old_frame_offset = frame_offset;
     470                 :            : 
     471                 :            :   if (FRAME_GROWS_DOWNWARD)
     472                 :            :     {
     473                 :    1252200 :       frame_offset -= size;
     474                 :    1252200 :       try_fit_stack_local (frame_offset, size, size, alignment, &slot_offset);
     475                 :            : 
     476                 :    1252200 :       if (kind & ASLK_RECORD_PAD)
     477                 :            :         {
     478                 :    1217560 :           if (known_gt (slot_offset, frame_offset))
     479                 :          0 :             add_frame_space (frame_offset, slot_offset);
     480                 :    1217560 :           if (known_lt (slot_offset + size, old_frame_offset))
     481                 :     200894 :             add_frame_space (slot_offset + size, old_frame_offset);
     482                 :            :         }
     483                 :            :     }
     484                 :            :   else
     485                 :            :     {
     486                 :            :       frame_offset += size;
     487                 :            :       try_fit_stack_local (old_frame_offset, size, size, alignment, &slot_offset);
     488                 :            : 
     489                 :            :       if (kind & ASLK_RECORD_PAD)
     490                 :            :         {
     491                 :            :           if (known_gt (slot_offset, old_frame_offset))
     492                 :            :             add_frame_space (old_frame_offset, slot_offset);
     493                 :            :           if (known_lt (slot_offset + size, frame_offset))
     494                 :            :             add_frame_space (slot_offset + size, frame_offset);
     495                 :            :         }
     496                 :            :     }
     497                 :            : 
     498                 :    1292180 :  found_space:
     499                 :            :   /* On a big-endian machine, if we are allocating more space than we will use,
     500                 :            :      use the least significant bytes of those that are allocated.  */
     501                 :    1292180 :   if (mode != BLKmode)
     502                 :            :     {
     503                 :            :       /* The slot size can sometimes be smaller than the mode size;
     504                 :            :          e.g. the rs6000 port allocates slots with a vector mode
     505                 :            :          that have the size of only one element.  However, the slot
     506                 :            :          size must always be ordered wrt to the mode size, in the
     507                 :            :          same way as for a subreg.  */
     508                 :     336547 :       gcc_checking_assert (ordered_p (GET_MODE_SIZE (mode), size));
     509                 :            :       if (BYTES_BIG_ENDIAN && maybe_lt (GET_MODE_SIZE (mode), size))
     510                 :            :         bigend_correction = size - GET_MODE_SIZE (mode);
     511                 :            :     }
     512                 :            : 
     513                 :            :   /* If we have already instantiated virtual registers, return the actual
     514                 :            :      address relative to the frame pointer.  */
     515                 :    1292180 :   if (virtuals_instantiated)
     516                 :    1201770 :     addr = plus_constant (Pmode, frame_pointer_rtx,
     517                 :            :                           trunc_int_for_mode
     518                 :     953132 :                           (slot_offset + bigend_correction
     519                 :    1201770 :                            + targetm.starting_frame_offset (), Pmode));
     520                 :            :   else
     521                 :     361439 :     addr = plus_constant (Pmode, virtual_stack_vars_rtx,
     522                 :            :                           trunc_int_for_mode
     523                 :            :                           (slot_offset + bigend_correction,
     524                 :     361439 :                            Pmode));
     525                 :            : 
     526                 :    1292180 :   x = gen_rtx_MEM (mode, addr);
     527                 :    1292180 :   set_mem_align (x, alignment_in_bits);
     528                 :    1292180 :   MEM_NOTRAP_P (x) = 1;
     529                 :            : 
     530                 :    1292180 :   vec_safe_push (stack_slot_list, x);
     531                 :            : 
     532                 :    1292180 :   if (frame_offset_overflow (frame_offset, current_function_decl))
     533                 :          0 :     frame_offset = 0;
     534                 :            : 
     535                 :    1292180 :   return x;
     536                 :            : }
     537                 :            : 
     538                 :            : /* Wrap up assign_stack_local_1 with last parameter as false.  */
     539                 :            : 
     540                 :            : rtx
     541                 :    1257540 : assign_stack_local (machine_mode mode, poly_int64 size, int align)
     542                 :            : {
     543                 :    1257540 :   return assign_stack_local_1 (mode, size, align, ASLK_RECORD_PAD);
     544                 :            : }
     545                 :            : 
     546                 :            : /* In order to evaluate some expressions, such as function calls returning
     547                 :            :    structures in memory, we need to temporarily allocate stack locations.
     548                 :            :    We record each allocated temporary in the following structure.
     549                 :            : 
     550                 :            :    Associated with each temporary slot is a nesting level.  When we pop up
     551                 :            :    one level, all temporaries associated with the previous level are freed.
     552                 :            :    Normally, all temporaries are freed after the execution of the statement
     553                 :            :    in which they were created.  However, if we are inside a ({...}) grouping,
     554                 :            :    the result may be in a temporary and hence must be preserved.  If the
     555                 :            :    result could be in a temporary, we preserve it if we can determine which
     556                 :            :    one it is in.  If we cannot determine which temporary may contain the
     557                 :            :    result, all temporaries are preserved.  A temporary is preserved by
     558                 :            :    pretending it was allocated at the previous nesting level.  */
     559                 :            : 
     560                 :            : class GTY(()) temp_slot {
     561                 :            : public:
     562                 :            :   /* Points to next temporary slot.  */
     563                 :            :   class temp_slot *next;
     564                 :            :   /* Points to previous temporary slot.  */
     565                 :            :   class temp_slot *prev;
     566                 :            :   /* The rtx to used to reference the slot.  */
     567                 :            :   rtx slot;
     568                 :            :   /* The size, in units, of the slot.  */
     569                 :            :   poly_int64 size;
     570                 :            :   /* The type of the object in the slot, or zero if it doesn't correspond
     571                 :            :      to a type.  We use this to determine whether a slot can be reused.
     572                 :            :      It can be reused if objects of the type of the new slot will always
     573                 :            :      conflict with objects of the type of the old slot.  */
     574                 :            :   tree type;
     575                 :            :   /* The alignment (in bits) of the slot.  */
     576                 :            :   unsigned int align;
     577                 :            :   /* Nonzero if this temporary is currently in use.  */
     578                 :            :   char in_use;
     579                 :            :   /* Nesting level at which this slot is being used.  */
     580                 :            :   int level;
     581                 :            :   /* The offset of the slot from the frame_pointer, including extra space
     582                 :            :      for alignment.  This info is for combine_temp_slots.  */
     583                 :            :   poly_int64 base_offset;
     584                 :            :   /* The size of the slot, including extra space for alignment.  This
     585                 :            :      info is for combine_temp_slots.  */
     586                 :            :   poly_int64 full_size;
     587                 :            : };
     588                 :            : 
     589                 :            : /* Entry for the below hash table.  */
     590                 :            : struct GTY((for_user)) temp_slot_address_entry {
     591                 :            :   hashval_t hash;
     592                 :            :   rtx address;
     593                 :            :   class temp_slot *temp_slot;
     594                 :            : };
     595                 :            : 
     596                 :            : struct temp_address_hasher : ggc_ptr_hash<temp_slot_address_entry>
     597                 :            : {
     598                 :            :   static hashval_t hash (temp_slot_address_entry *);
     599                 :            :   static bool equal (temp_slot_address_entry *, temp_slot_address_entry *);
     600                 :            : };
     601                 :            : 
     602                 :            : /* A table of addresses that represent a stack slot.  The table is a mapping
     603                 :            :    from address RTXen to a temp slot.  */
     604                 :            : static GTY(()) hash_table<temp_address_hasher> *temp_slot_address_table;
     605                 :            : static size_t n_temp_slots_in_use;
     606                 :            : 
     607                 :            : /* Removes temporary slot TEMP from LIST.  */
     608                 :            : 
     609                 :            : static void
     610                 :     130542 : cut_slot_from_list (class temp_slot *temp, class temp_slot **list)
     611                 :            : {
     612                 :          0 :   if (temp->next)
     613                 :      20634 :     temp->next->prev = temp->prev;
     614                 :     130542 :   if (temp->prev)
     615                 :       4809 :     temp->prev->next = temp->next;
     616                 :            :   else
     617                 :     125733 :     *list = temp->next;
     618                 :            : 
     619                 :     130542 :   temp->prev = temp->next = NULL;
     620                 :        267 : }
     621                 :            : 
     622                 :            : /* Inserts temporary slot TEMP to LIST.  */
     623                 :            : 
     624                 :            : static void
     625                 :     165102 : insert_slot_to_list (class temp_slot *temp, class temp_slot **list)
     626                 :            : {
     627                 :     165102 :   temp->next = *list;
     628                 :          0 :   if (*list)
     629                 :      32763 :     (*list)->prev = temp;
     630                 :     165102 :   temp->prev = NULL;
     631                 :     165102 :   *list = temp;
     632                 :          0 : }
     633                 :            : 
     634                 :            : /* Returns the list of used temp slots at LEVEL.  */
     635                 :            : 
     636                 :            : static class temp_slot **
     637                 :   42520700 : temp_slots_at_level (int level)
     638                 :            : {
     639                 :   84129200 :   if (level >= (int) vec_safe_length (used_temp_slots))
     640                 :    1235950 :     vec_safe_grow_cleared (used_temp_slots, level + 1);
     641                 :            : 
     642                 :   42520700 :   return &(*used_temp_slots)[level];
     643                 :            : }
     644                 :            : 
     645                 :            : /* Returns the maximal temporary slot level.  */
     646                 :            : 
     647                 :            : static int
     648                 :     646060 : max_slot_level (void)
     649                 :            : {
     650                 :          0 :   if (!used_temp_slots)
     651                 :            :     return -1;
     652                 :            : 
     653                 :     606562 :   return used_temp_slots->length () - 1;
     654                 :            : }
     655                 :            : 
     656                 :            : /* Moves temporary slot TEMP to LEVEL.  */
     657                 :            : 
     658                 :            : static void
     659                 :       1240 : move_slot_to_level (class temp_slot *temp, int level)
     660                 :            : {
     661                 :       1240 :   cut_slot_from_list (temp, temp_slots_at_level (temp->level));
     662                 :       1240 :   insert_slot_to_list (temp, temp_slots_at_level (level));
     663                 :       1240 :   temp->level = level;
     664                 :       1240 : }
     665                 :            : 
     666                 :            : /* Make temporary slot TEMP available.  */
     667                 :            : 
     668                 :            : static void
     669                 :      81553 : make_slot_available (class temp_slot *temp)
     670                 :            : {
     671                 :      81553 :   cut_slot_from_list (temp, temp_slots_at_level (temp->level));
     672                 :      81553 :   insert_slot_to_list (temp, &avail_temp_slots);
     673                 :      81553 :   temp->in_use = 0;
     674                 :      81553 :   temp->level = -1;
     675                 :      81553 :   n_temp_slots_in_use--;
     676                 :      81553 : }
     677                 :            : 
     678                 :            : /* Compute the hash value for an address -> temp slot mapping.
     679                 :            :    The value is cached on the mapping entry.  */
     680                 :            : static hashval_t
     681                 :    4256770 : temp_slot_address_compute_hash (struct temp_slot_address_entry *t)
     682                 :            : {
     683                 :    4256770 :   int do_not_record = 0;
     684                 :          0 :   return hash_rtx (t->address, GET_MODE (t->address),
     685                 :          0 :                    &do_not_record, NULL, false);
     686                 :            : }
     687                 :            : 
     688                 :            : /* Return the hash value for an address -> temp slot mapping.  */
     689                 :            : hashval_t
     690                 :      25163 : temp_address_hasher::hash (temp_slot_address_entry *t)
     691                 :            : {
     692                 :      25163 :   return t->hash;
     693                 :            : }
     694                 :            : 
     695                 :            : /* Compare two address -> temp slot mapping entries.  */
     696                 :            : bool
     697                 :      28503 : temp_address_hasher::equal (temp_slot_address_entry *t1,
     698                 :            :                             temp_slot_address_entry *t2)
     699                 :            : {
     700                 :      28503 :   return exp_equiv_p (t1->address, t2->address, 0, true);
     701                 :            : }
     702                 :            : 
     703                 :            : /* Add ADDRESS as an alias of TEMP_SLOT to the addess -> temp slot mapping.  */
     704                 :            : static void
     705                 :      83633 : insert_temp_slot_address (rtx address, class temp_slot *temp_slot)
     706                 :            : {
     707                 :      83633 :   struct temp_slot_address_entry *t = ggc_alloc<temp_slot_address_entry> ();
     708                 :      83633 :   t->address = copy_rtx (address);
     709                 :      83633 :   t->temp_slot = temp_slot;
     710                 :      83633 :   t->hash = temp_slot_address_compute_hash (t);
     711                 :      83633 :   *temp_slot_address_table->find_slot_with_hash (t, t->hash, INSERT) = t;
     712                 :      83633 : }
     713                 :            : 
     714                 :            : /* Remove an address -> temp slot mapping entry if the temp slot is
     715                 :            :    not in use anymore.  Callback for remove_unused_temp_slot_addresses.  */
     716                 :            : int
     717                 :       4803 : remove_unused_temp_slot_addresses_1 (temp_slot_address_entry **slot, void *)
     718                 :            : {
     719                 :       4803 :   const struct temp_slot_address_entry *t = *slot;
     720                 :       4803 :   if (! t->temp_slot->in_use)
     721                 :       1842 :     temp_slot_address_table->clear_slot (slot);
     722                 :       4803 :   return 1;
     723                 :            : }
     724                 :            : 
     725                 :            : /* Remove all mappings of addresses to unused temp slots.  */
     726                 :            : static void
     727                 :      72610 : remove_unused_temp_slot_addresses (void)
     728                 :            : {
     729                 :            :   /* Use quicker clearing if there aren't any active temp slots.  */
     730                 :      72610 :   if (n_temp_slots_in_use)
     731                 :        974 :     temp_slot_address_table->traverse
     732                 :        974 :       <void *, remove_unused_temp_slot_addresses_1> (NULL);
     733                 :            :   else
     734                 :      71636 :     temp_slot_address_table->empty ();
     735                 :      72610 : }
     736                 :            : 
     737                 :            : /* Find the temp slot corresponding to the object at address X.  */
     738                 :            : 
     739                 :            : static class temp_slot *
     740                 :    4173130 : find_temp_slot_from_address (rtx x)
     741                 :            : {
     742                 :    4173130 :   class temp_slot *p;
     743                 :    4173130 :   struct temp_slot_address_entry tmp, *t;
     744                 :            : 
     745                 :            :   /* First try the easy way:
     746                 :            :      See if X exists in the address -> temp slot mapping.  */
     747                 :    4173130 :   tmp.address = x;
     748                 :    4173130 :   tmp.temp_slot = NULL;
     749                 :    4173130 :   tmp.hash = temp_slot_address_compute_hash (&tmp);
     750                 :    4173130 :   t = temp_slot_address_table->find_with_hash (&tmp, tmp.hash);
     751                 :    4173130 :   if (t)
     752                 :       2748 :     return t->temp_slot;
     753                 :            : 
     754                 :            :   /* If we have a sum involving a register, see if it points to a temp
     755                 :            :      slot.  */
     756                 :     613685 :   if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 0))
     757                 :    4640840 :       && (p = find_temp_slot_from_address (XEXP (x, 0))) != 0)
     758                 :            :     return p;
     759                 :     613685 :   else if (GET_CODE (x) == PLUS && REG_P (XEXP (x, 1))
     760                 :    4244080 :            && (p = find_temp_slot_from_address (XEXP (x, 1))) != 0)
     761                 :            :     return p;
     762                 :            : 
     763                 :            :   /* Last resort: Address is a virtual stack var address.  */
     764                 :    4170390 :   poly_int64 offset;
     765                 :    4170390 :   if (strip_offset (x, &offset) == virtual_stack_vars_rtx)
     766                 :            :     {
     767                 :     646060 :       int i;
     768                 :    2870930 :       for (i = max_slot_level (); i >= 0; i--)
     769                 :    1591660 :         for (p = *temp_slots_at_level (i); p; p = p->next)
     770                 :      25692 :           if (known_in_range_p (offset, p->base_offset, p->full_size))
     771                 :          2 :             return p;
     772                 :            :     }
     773                 :            : 
     774                 :            :   return NULL;
     775                 :            : }
     776                 :            : 
     777                 :            : /* Allocate a temporary stack slot and record it for possible later
     778                 :            :    reuse.
     779                 :            : 
     780                 :            :    MODE is the machine mode to be given to the returned rtx.
     781                 :            : 
     782                 :            :    SIZE is the size in units of the space required.  We do no rounding here
     783                 :            :    since assign_stack_local will do any required rounding.
     784                 :            : 
     785                 :            :    TYPE is the type that will be used for the stack slot.  */
     786                 :            : 
     787                 :            : rtx
     788                 :      82123 : assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type)
     789                 :            : {
     790                 :      82123 :   unsigned int align;
     791                 :      82123 :   class temp_slot *p, *best_p = 0, *selected = NULL, **pp;
     792                 :      82123 :   rtx slot;
     793                 :            : 
     794                 :      82123 :   gcc_assert (known_size_p (size));
     795                 :            : 
     796                 :      82123 :   align = get_stack_local_alignment (type, mode);
     797                 :            : 
     798                 :            :   /* Try to find an available, already-allocated temporary of the proper
     799                 :            :      mode which meets the size and alignment requirements.  Choose the
     800                 :            :      smallest one with the closest alignment.
     801                 :            : 
     802                 :            :      If assign_stack_temp is called outside of the tree->rtl expansion,
     803                 :            :      we cannot reuse the stack slots (that may still refer to
     804                 :            :      VIRTUAL_STACK_VARS_REGNUM).  */
     805                 :      82123 :   if (!virtuals_instantiated)
     806                 :            :     {
     807                 :     317385 :       for (p = avail_temp_slots; p; p = p->next)
     808                 :            :         {
     809                 :     280388 :           if (p->align >= align
     810                 :     265352 :               && known_ge (p->size, size)
     811                 :     264542 :               && GET_MODE (p->slot) == mode
     812                 :     243120 :               && objects_must_conflict_p (p->type, type)
     813                 :     327872 :               && (best_p == 0
     814                 :          2 :                   || (known_eq (best_p->size, p->size)
     815                 :          2 :                       ? best_p->align > p->align
     816                 :          2 :                       : known_ge (best_p->size, p->size))))
     817                 :            :             {
     818                 :      47484 :               if (p->align == align && known_eq (p->size, size))
     819                 :            :                 {
     820                 :      45126 :                   selected = p;
     821                 :      45126 :                   cut_slot_from_list (selected, &avail_temp_slots);
     822                 :      45126 :                   best_p = 0;
     823                 :      45126 :                   break;
     824                 :            :                 }
     825                 :            :               best_p = p;
     826                 :            :             }
     827                 :            :         }
     828                 :            :     }
     829                 :            : 
     830                 :            :   /* Make our best, if any, the one to use.  */
     831                 :      82123 :   if (best_p)
     832                 :            :     {
     833                 :       2356 :       selected = best_p;
     834                 :       2356 :       cut_slot_from_list (selected, &avail_temp_slots);
     835                 :            : 
     836                 :            :       /* If there are enough aligned bytes left over, make them into a new
     837                 :            :          temp_slot so that the extra bytes don't get wasted.  Do this only
     838                 :            :          for BLKmode slots, so that we can be sure of the alignment.  */
     839                 :       2356 :       if (GET_MODE (best_p->slot) == BLKmode)
     840                 :            :         {
     841                 :        527 :           int alignment = best_p->align / BITS_PER_UNIT;
     842                 :        527 :           poly_int64 rounded_size = aligned_upper_bound (size, alignment);
     843                 :            : 
     844                 :        527 :           if (known_ge (best_p->size - rounded_size, alignment))
     845                 :            :             {
     846                 :        186 :               p = ggc_alloc<temp_slot> ();
     847                 :        186 :               p->in_use = 0;
     848                 :        186 :               p->size = best_p->size - rounded_size;
     849                 :        186 :               p->base_offset = best_p->base_offset + rounded_size;
     850                 :        186 :               p->full_size = best_p->full_size - rounded_size;
     851                 :        186 :               p->slot = adjust_address_nv (best_p->slot, BLKmode, rounded_size);
     852                 :        186 :               p->align = best_p->align;
     853                 :        186 :               p->type = best_p->type;
     854                 :        186 :               insert_slot_to_list (p, &avail_temp_slots);
     855                 :            : 
     856                 :        186 :               vec_safe_push (stack_slot_list, p->slot);
     857                 :            : 
     858                 :        186 :               best_p->size = rounded_size;
     859                 :        186 :               best_p->full_size = rounded_size;
     860                 :            :             }
     861                 :            :         }
     862                 :            :     }
     863                 :            : 
     864                 :            :   /* If we still didn't find one, make a new temporary.  */
     865                 :      82123 :   if (selected == 0)
     866                 :            :     {
     867                 :      34641 :       poly_int64 frame_offset_old = frame_offset;
     868                 :            : 
     869                 :      34641 :       p = ggc_alloc<temp_slot> ();
     870                 :            : 
     871                 :            :       /* We are passing an explicit alignment request to assign_stack_local.
     872                 :            :          One side effect of that is assign_stack_local will not round SIZE
     873                 :            :          to ensure the frame offset remains suitably aligned.
     874                 :            : 
     875                 :            :          So for requests which depended on the rounding of SIZE, we go ahead
     876                 :            :          and round it now.  We also make sure ALIGNMENT is at least
     877                 :            :          BIGGEST_ALIGNMENT.  */
     878                 :      36908 :       gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT);
     879                 :      34641 :       p->slot = assign_stack_local_1 (mode,
     880                 :            :                                       (mode == BLKmode
     881                 :            :                                        ? aligned_upper_bound (size,
     882                 :            :                                                               (int) align
     883                 :      34641 :                                                               / BITS_PER_UNIT)
     884                 :            :                                        : size),
     885                 :            :                                       align, 0);
     886                 :            : 
     887                 :      34641 :       p->align = align;
     888                 :            : 
     889                 :            :       /* The following slot size computation is necessary because we don't
     890                 :            :          know the actual size of the temporary slot until assign_stack_local
     891                 :            :          has performed all the frame alignment and size rounding for the
     892                 :            :          requested temporary.  Note that extra space added for alignment
     893                 :            :          can be either above or below this stack slot depending on which
     894                 :            :          way the frame grows.  We include the extra space if and only if it
     895                 :            :          is above this slot.  */
     896                 :      34641 :       if (FRAME_GROWS_DOWNWARD)
     897                 :      34641 :         p->size = frame_offset_old - frame_offset;
     898                 :            :       else
     899                 :            :         p->size = size;
     900                 :            : 
     901                 :            :       /* Now define the fields used by combine_temp_slots.  */
     902                 :      34641 :       if (FRAME_GROWS_DOWNWARD)
     903                 :            :         {
     904                 :      34641 :           p->base_offset = frame_offset;
     905                 :      34641 :           p->full_size = frame_offset_old - frame_offset;
     906                 :            :         }
     907                 :            :       else
     908                 :            :         {
     909                 :            :           p->base_offset = frame_offset_old;
     910                 :            :           p->full_size = frame_offset - frame_offset_old;
     911                 :            :         }
     912                 :            : 
     913                 :      34641 :       selected = p;
     914                 :            :     }
     915                 :            : 
     916                 :      82123 :   p = selected;
     917                 :      82123 :   p->in_use = 1;
     918                 :      82123 :   p->type = type;
     919                 :      82123 :   p->level = temp_slot_level;
     920                 :      82123 :   n_temp_slots_in_use++;
     921                 :            : 
     922                 :      82123 :   pp = temp_slots_at_level (p->level);
     923                 :      82123 :   insert_slot_to_list (p, pp);
     924                 :      82123 :   insert_temp_slot_address (XEXP (p->slot, 0), p);
     925                 :            : 
     926                 :            :   /* Create a new MEM rtx to avoid clobbering MEM flags of old slots.  */
     927                 :      82123 :   slot = gen_rtx_MEM (mode, XEXP (p->slot, 0));
     928                 :      82123 :   vec_safe_push (stack_slot_list, slot);
     929                 :            : 
     930                 :            :   /* If we know the alias set for the memory that will be used, use
     931                 :            :      it.  If there's no TYPE, then we don't know anything about the
     932                 :            :      alias set for the memory.  */
     933                 :      82123 :   set_mem_alias_set (slot, type ? get_alias_set (type) : 0);
     934                 :      82123 :   set_mem_align (slot, align);
     935                 :            : 
     936                 :            :   /* If a type is specified, set the relevant flags.  */
     937                 :      82123 :   if (type != 0)
     938                 :      73410 :     MEM_VOLATILE_P (slot) = TYPE_VOLATILE (type);
     939                 :      82123 :   MEM_NOTRAP_P (slot) = 1;
     940                 :            : 
     941                 :      82123 :   return slot;
     942                 :            : }
     943                 :            : 
     944                 :            : /* Allocate a temporary stack slot and record it for possible later
     945                 :            :    reuse.  First two arguments are same as in preceding function.  */
     946                 :            : 
     947                 :            : rtx
     948                 :       8713 : assign_stack_temp (machine_mode mode, poly_int64 size)
     949                 :            : {
     950                 :       8713 :   return assign_stack_temp_for_type (mode, size, NULL_TREE);
     951                 :            : }
     952                 :            : 
     953                 :            : /* Assign a temporary.
     954                 :            :    If TYPE_OR_DECL is a decl, then we are doing it on behalf of the decl
     955                 :            :    and so that should be used in error messages.  In either case, we
     956                 :            :    allocate of the given type.
     957                 :            :    MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
     958                 :            :    it is 0 if a register is OK.
     959                 :            :    DONT_PROMOTE is 1 if we should not promote values in register
     960                 :            :    to wider modes.  */
     961                 :            : 
     962                 :            : rtx
     963                 :     599955 : assign_temp (tree type_or_decl, int memory_required,
     964                 :            :              int dont_promote ATTRIBUTE_UNUSED)
     965                 :            : {
     966                 :     599955 :   tree type, decl;
     967                 :     599955 :   machine_mode mode;
     968                 :            : #ifdef PROMOTE_MODE
     969                 :     599955 :   int unsignedp;
     970                 :            : #endif
     971                 :            : 
     972                 :     599955 :   if (DECL_P (type_or_decl))
     973                 :          0 :     decl = type_or_decl, type = TREE_TYPE (decl);
     974                 :            :   else
     975                 :            :     decl = NULL, type = type_or_decl;
     976                 :            : 
     977                 :     599955 :   mode = TYPE_MODE (type);
     978                 :            : #ifdef PROMOTE_MODE
     979                 :     599955 :   unsignedp = TYPE_UNSIGNED (type);
     980                 :            : #endif
     981                 :            : 
     982                 :            :   /* Allocating temporaries of TREE_ADDRESSABLE type must be done in the front
     983                 :            :      end.  See also create_tmp_var for the gimplification-time check.  */
     984                 :    1199910 :   gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
     985                 :            : 
     986                 :     599955 :   if (mode == BLKmode || memory_required)
     987                 :            :     {
     988                 :      67188 :       poly_int64 size;
     989                 :      67188 :       rtx tmp;
     990                 :            : 
     991                 :            :       /* Unfortunately, we don't yet know how to allocate variable-sized
     992                 :            :          temporaries.  However, sometimes we can find a fixed upper limit on
     993                 :            :          the size, so try that instead.  */
     994                 :      67188 :       if (!poly_int_tree_p (TYPE_SIZE_UNIT (type), &size))
     995                 :          0 :         size = max_int_size_in_bytes (type);
     996                 :            : 
     997                 :            :       /* Zero sized arrays are a GNU C extension.  Set size to 1 to avoid
     998                 :            :          problems with allocating the stack space.  */
     999                 :      67188 :       if (known_eq (size, 0))
    1000                 :          0 :         size = 1;
    1001                 :            : 
    1002                 :            :       /* The size of the temporary may be too large to fit into an integer.  */
    1003                 :            :       /* ??? Not sure this should happen except for user silliness, so limit
    1004                 :            :          this to things that aren't compiler-generated temporaries.  The
    1005                 :            :          rest of the time we'll die in assign_stack_temp_for_type.  */
    1006                 :      67188 :       if (decl
    1007                 :          0 :           && !known_size_p (size)
    1008                 :      67188 :           && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST)
    1009                 :            :         {
    1010                 :          0 :           error ("size of variable %q+D is too large", decl);
    1011                 :          0 :           size = 1;
    1012                 :            :         }
    1013                 :            : 
    1014                 :      67188 :       tmp = assign_stack_temp_for_type (mode, size, type);
    1015                 :      67188 :       return tmp;
    1016                 :            :     }
    1017                 :            : 
    1018                 :            : #ifdef PROMOTE_MODE
    1019                 :     532767 :   if (! dont_promote)
    1020                 :          0 :     mode = promote_mode (type, mode, &unsignedp);
    1021                 :            : #endif
    1022                 :            : 
    1023                 :     532767 :   return gen_reg_rtx (mode);
    1024                 :            : }
    1025                 :            : 
    1026                 :            : /* Combine temporary stack slots which are adjacent on the stack.
    1027                 :            : 
    1028                 :            :    This allows for better use of already allocated stack space.  This is only
    1029                 :            :    done for BLKmode slots because we can be sure that we won't have alignment
    1030                 :            :    problems in this case.  */
    1031                 :            : 
    1032                 :            : static void
    1033                 :      72610 : combine_temp_slots (void)
    1034                 :            : {
    1035                 :      72610 :   class temp_slot *p, *q, *next, *next_q;
    1036                 :      72610 :   int num_slots;
    1037                 :            : 
    1038                 :            :   /* We can't combine slots, because the information about which slot
    1039                 :            :      is in which alias set will be lost.  */
    1040                 :      72610 :   if (flag_strict_aliasing)
    1041                 :            :     return;
    1042                 :            : 
    1043                 :            :   /* If there are a lot of temp slots, don't do anything unless
    1044                 :            :      high levels of optimization.  */
    1045                 :      13555 :   if (! flag_expensive_optimizations)
    1046                 :      26833 :     for (p = avail_temp_slots, num_slots = 0; p; p = p->next, num_slots++)
    1047                 :      22148 :       if (num_slots > 100 || (num_slots > 10 && optimize == 0))
    1048                 :            :         return;
    1049                 :            : 
    1050                 :      13061 :   for (p = avail_temp_slots; p; p = next)
    1051                 :            :     {
    1052                 :      24461 :       int delete_p = 0;
    1053                 :            : 
    1054                 :      24461 :       next = p->next;
    1055                 :            : 
    1056                 :      24461 :       if (GET_MODE (p->slot) != BLKmode)
    1057                 :      22184 :         continue;
    1058                 :            : 
    1059                 :       3306 :       for (q = p->next; q; q = next_q)
    1060                 :            :         {
    1061                 :       1043 :           int delete_q = 0;
    1062                 :            : 
    1063                 :       1043 :           next_q = q->next;
    1064                 :            : 
    1065                 :       1043 :           if (GET_MODE (q->slot) != BLKmode)
    1066                 :        722 :             continue;
    1067                 :            : 
    1068                 :        321 :           if (known_eq (p->base_offset + p->full_size, q->base_offset))
    1069                 :            :             {
    1070                 :            :               /* Q comes after P; combine Q into P.  */
    1071                 :        253 :               p->size += q->size;
    1072                 :       3559 :               p->full_size += q->full_size;
    1073                 :            :               delete_q = 1;
    1074                 :            :             }
    1075                 :         68 :           else if (known_eq (q->base_offset + q->full_size, p->base_offset))
    1076                 :            :             {
    1077                 :            :               /* P comes after Q; combine P into Q.  */
    1078                 :         14 :               q->size += p->size;
    1079                 :         14 :               q->full_size += p->full_size;
    1080                 :            :               delete_p = 1;
    1081                 :            :               break;
    1082                 :            :             }
    1083                 :        253 :           if (delete_q)
    1084                 :       3559 :             cut_slot_from_list (q, &avail_temp_slots);
    1085                 :            :         }
    1086                 :            : 
    1087                 :            :       /* Either delete P or advance past it.  */
    1088                 :       2277 :       if (delete_p)
    1089                 :      37536 :         cut_slot_from_list (p, &avail_temp_slots);
    1090                 :            :     }
    1091                 :            : }
    1092                 :            : 
    1093                 :            : /* Indicate that NEW_RTX is an alternate way of referring to the temp
    1094                 :            :    slot that previously was known by OLD_RTX.  */
    1095                 :            : 
    1096                 :            : void
    1097                 :   10552700 : update_temp_slot_address (rtx old_rtx, rtx new_rtx)
    1098                 :            : {
    1099                 :   10820800 :   class temp_slot *p;
    1100                 :            : 
    1101                 :   10820800 :   if (rtx_equal_p (old_rtx, new_rtx))
    1102                 :            :     return;
    1103                 :            : 
    1104                 :    2295870 :   p = find_temp_slot_from_address (old_rtx);
    1105                 :            : 
    1106                 :            :   /* If we didn't find one, see if both OLD_RTX is a PLUS.  If so, and
    1107                 :            :      NEW_RTX is a register, see if one operand of the PLUS is a
    1108                 :            :      temporary location.  If so, NEW_RTX points into it.  Otherwise,
    1109                 :            :      if both OLD_RTX and NEW_RTX are a PLUS and if there is a register
    1110                 :            :      in common between them.  If so, try a recursive call on those
    1111                 :            :      values.  */
    1112                 :    2295870 :   if (p == 0)
    1113                 :            :     {
    1114                 :    2294360 :       if (GET_CODE (old_rtx) != PLUS)
    1115                 :            :         return;
    1116                 :            : 
    1117                 :     299881 :       if (REG_P (new_rtx))
    1118                 :            :         {
    1119                 :     111280 :           update_temp_slot_address (XEXP (old_rtx, 0), new_rtx);
    1120                 :     111280 :           update_temp_slot_address (XEXP (old_rtx, 1), new_rtx);
    1121                 :     111280 :           return;
    1122                 :            :         }
    1123                 :     188601 :       else if (GET_CODE (new_rtx) != PLUS)
    1124                 :            :         return;
    1125                 :            : 
    1126                 :     188601 :       if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 0)))
    1127                 :      67452 :         update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 1));
    1128                 :     121149 :       else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 0)))
    1129                 :          0 :         update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 1));
    1130                 :     121149 :       else if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 1)))
    1131                 :      20123 :         update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 0));
    1132                 :     101026 :       else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 1)))
    1133                 :      69208 :         update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 0));
    1134                 :            : 
    1135                 :      31818 :       return;
    1136                 :            :     }
    1137                 :            : 
    1138                 :            :   /* Otherwise add an alias for the temp's address.  */
    1139                 :       1510 :   insert_temp_slot_address (new_rtx, p);
    1140                 :            : }
    1141                 :            : 
    1142                 :            : /* If X could be a reference to a temporary slot, mark that slot as
    1143                 :            :    belonging to the to one level higher than the current level.  If X
    1144                 :            :    matched one of our slots, just mark that one.  Otherwise, we can't
    1145                 :            :    easily predict which it is, so upgrade all of them.
    1146                 :            : 
    1147                 :            :    This is called when an ({...}) construct occurs and a statement
    1148                 :            :    returns a value in memory.  */
    1149                 :            : 
    1150                 :            : void
    1151                 :   14890300 : preserve_temp_slots (rtx x)
    1152                 :            : {
    1153                 :   14890300 :   class temp_slot *p = 0, *next;
    1154                 :            : 
    1155                 :   14890300 :   if (x == 0)
    1156                 :            :     return;
    1157                 :            : 
    1158                 :            :   /* If X is a register that is being used as a pointer, see if we have
    1159                 :            :      a temporary slot we know it points to.  */
    1160                 :    6439620 :   if (REG_P (x) && REG_POINTER (x))
    1161                 :     988611 :     p = find_temp_slot_from_address (x);
    1162                 :            : 
    1163                 :            :   /* If X is not in memory or is at a constant address, it cannot be in
    1164                 :            :      a temporary slot.  */
    1165                 :    6439620 :   if (p == 0 && (!MEM_P (x) || CONSTANT_P (XEXP (x, 0))))
    1166                 :            :     return;
    1167                 :            : 
    1168                 :            :   /* First see if we can find a match.  */
    1169                 :     344512 :   if (p == 0)
    1170                 :     344512 :     p = find_temp_slot_from_address (XEXP (x, 0));
    1171                 :            : 
    1172                 :     344512 :   if (p != 0)
    1173                 :            :     {
    1174                 :       1240 :       if (p->level == temp_slot_level)
    1175                 :       1240 :         move_slot_to_level (p, temp_slot_level - 1);
    1176                 :       1240 :       return;
    1177                 :            :     }
    1178                 :            : 
    1179                 :            :   /* Otherwise, preserve all non-kept slots at this level.  */
    1180                 :     343272 :   for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
    1181                 :            :     {
    1182                 :          0 :       next = p->next;
    1183                 :          0 :       move_slot_to_level (p, temp_slot_level - 1);
    1184                 :            :     }
    1185                 :            : }
    1186                 :            : 
    1187                 :            : /* Free all temporaries used so far.  This is normally called at the
    1188                 :            :    end of generating code for a statement.  */
    1189                 :            : 
    1190                 :            : void
    1191                 :   40432400 : free_temp_slots (void)
    1192                 :            : {
    1193                 :   40432400 :   class temp_slot *p, *next;
    1194                 :   40432400 :   bool some_available = false;
    1195                 :            : 
    1196                 :   40514000 :   for (p = *temp_slots_at_level (temp_slot_level); p; p = next)
    1197                 :            :     {
    1198                 :      81553 :       next = p->next;
    1199                 :      81553 :       make_slot_available (p);
    1200                 :      81553 :       some_available = true;
    1201                 :            :     }
    1202                 :            : 
    1203                 :   40432400 :   if (some_available)
    1204                 :            :     {
    1205                 :      72610 :       remove_unused_temp_slot_addresses ();
    1206                 :      72610 :       combine_temp_slots ();
    1207                 :            :     }
    1208                 :   40432400 : }
    1209                 :            : 
    1210                 :            : /* Push deeper into the nesting level for stack temporaries.  */
    1211                 :            : 
    1212                 :            : void
    1213                 :   19965200 : push_temp_slots (void)
    1214                 :            : {
    1215                 :   19965200 :   temp_slot_level++;
    1216                 :   19965200 : }
    1217                 :            : 
    1218                 :            : /* Pop a temporary nesting level.  All slots in use in the current level
    1219                 :            :    are freed.  */
    1220                 :            : 
    1221                 :            : void
    1222                 :   19965200 : pop_temp_slots (void)
    1223                 :            : {
    1224                 :   19965200 :   free_temp_slots ();
    1225                 :   19965200 :   temp_slot_level--;
    1226                 :   19965200 : }
    1227                 :            : 
    1228                 :            : /* Initialize temporary slots.  */
    1229                 :            : 
    1230                 :            : void
    1231                 :    2045960 : init_temp_slots (void)
    1232                 :            : {
    1233                 :            :   /* We have not allocated any temporaries yet.  */
    1234                 :    2045960 :   avail_temp_slots = 0;
    1235                 :    2045960 :   vec_alloc (used_temp_slots, 0);
    1236                 :    2045960 :   temp_slot_level = 0;
    1237                 :    2045960 :   n_temp_slots_in_use = 0;
    1238                 :            : 
    1239                 :            :   /* Set up the table to map addresses to temp slots.  */
    1240                 :    2045960 :   if (! temp_slot_address_table)
    1241                 :     148816 :     temp_slot_address_table = hash_table<temp_address_hasher>::create_ggc (32);
    1242                 :            :   else
    1243                 :    1897140 :     temp_slot_address_table->empty ();
    1244                 :    2045960 : }
    1245                 :            : 
    1246                 :            : /* Functions and data structures to keep track of the values hard regs
    1247                 :            :    had at the start of the function.  */
    1248                 :            : 
    1249                 :            : /* Private type used by get_hard_reg_initial_reg, get_hard_reg_initial_val,
    1250                 :            :    and has_hard_reg_initial_val..  */
    1251                 :            : struct GTY(()) initial_value_pair {
    1252                 :            :   rtx hard_reg;
    1253                 :            :   rtx pseudo;
    1254                 :            : };
    1255                 :            : /* ???  This could be a VEC but there is currently no way to define an
    1256                 :            :    opaque VEC type.  This could be worked around by defining struct
    1257                 :            :    initial_value_pair in function.h.  */
    1258                 :            : struct GTY(()) initial_value_struct {
    1259                 :            :   int num_entries;
    1260                 :            :   int max_entries;
    1261                 :            :   initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
    1262                 :            : };
    1263                 :            : 
    1264                 :            : /* If a pseudo represents an initial hard reg (or expression), return
    1265                 :            :    it, else return NULL_RTX.  */
    1266                 :            : 
    1267                 :            : rtx
    1268                 :          0 : get_hard_reg_initial_reg (rtx reg)
    1269                 :            : {
    1270                 :          0 :   struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
    1271                 :          0 :   int i;
    1272                 :            : 
    1273                 :          0 :   if (ivs == 0)
    1274                 :            :     return NULL_RTX;
    1275                 :            : 
    1276                 :          0 :   for (i = 0; i < ivs->num_entries; i++)
    1277                 :          0 :     if (rtx_equal_p (ivs->entries[i].pseudo, reg))
    1278                 :          0 :       return ivs->entries[i].hard_reg;
    1279                 :            : 
    1280                 :            :   return NULL_RTX;
    1281                 :            : }
    1282                 :            : 
    1283                 :            : /* Make sure that there's a pseudo register of mode MODE that stores the
    1284                 :            :    initial value of hard register REGNO.  Return an rtx for such a pseudo.  */
    1285                 :            : 
    1286                 :            : rtx
    1287                 :          0 : get_hard_reg_initial_val (machine_mode mode, unsigned int regno)
    1288                 :            : {
    1289                 :          0 :   struct initial_value_struct *ivs;
    1290                 :          0 :   rtx rv;
    1291                 :            : 
    1292                 :          0 :   rv = has_hard_reg_initial_val (mode, regno);
    1293                 :          0 :   if (rv)
    1294                 :            :     return rv;
    1295                 :            : 
    1296                 :          0 :   ivs = crtl->hard_reg_initial_vals;
    1297                 :          0 :   if (ivs == 0)
    1298                 :            :     {
    1299                 :          0 :       ivs = ggc_alloc<initial_value_struct> ();
    1300                 :          0 :       ivs->num_entries = 0;
    1301                 :          0 :       ivs->max_entries = 5;
    1302                 :          0 :       ivs->entries = ggc_vec_alloc<initial_value_pair> (5);
    1303                 :          0 :       crtl->hard_reg_initial_vals = ivs;
    1304                 :            :     }
    1305                 :            : 
    1306                 :          0 :   if (ivs->num_entries >= ivs->max_entries)
    1307                 :            :     {
    1308                 :          0 :       ivs->max_entries += 5;
    1309                 :          0 :       ivs->entries = GGC_RESIZEVEC (initial_value_pair, ivs->entries,
    1310                 :            :                                     ivs->max_entries);
    1311                 :            :     }
    1312                 :            : 
    1313                 :          0 :   ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
    1314                 :          0 :   ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode);
    1315                 :            : 
    1316                 :          0 :   return ivs->entries[ivs->num_entries++].pseudo;
    1317                 :            : }
    1318                 :            : 
    1319                 :            : /* See if get_hard_reg_initial_val has been used to create a pseudo
    1320                 :            :    for the initial value of hard register REGNO in mode MODE.  Return
    1321                 :            :    the associated pseudo if so, otherwise return NULL.  */
    1322                 :            : 
    1323                 :            : rtx
    1324                 :          0 : has_hard_reg_initial_val (machine_mode mode, unsigned int regno)
    1325                 :            : {
    1326                 :          0 :   struct initial_value_struct *ivs;
    1327                 :          0 :   int i;
    1328                 :            : 
    1329                 :          0 :   ivs = crtl->hard_reg_initial_vals;
    1330                 :          0 :   if (ivs != 0)
    1331                 :          0 :     for (i = 0; i < ivs->num_entries; i++)
    1332                 :          0 :       if (GET_MODE (ivs->entries[i].hard_reg) == mode
    1333                 :          0 :           && REGNO (ivs->entries[i].hard_reg) == regno)
    1334                 :          0 :         return ivs->entries[i].pseudo;
    1335                 :            : 
    1336                 :            :   return NULL_RTX;
    1337                 :            : }
    1338                 :            : 
    1339                 :            : unsigned int
    1340                 :     944512 : emit_initial_value_sets (void)
    1341                 :            : {
    1342                 :     944512 :   struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
    1343                 :     944512 :   int i;
    1344                 :     944512 :   rtx_insn *seq;
    1345                 :            : 
    1346                 :     944512 :   if (ivs == 0)
    1347                 :            :     return 0;
    1348                 :            : 
    1349                 :          0 :   start_sequence ();
    1350                 :          0 :   for (i = 0; i < ivs->num_entries; i++)
    1351                 :          0 :     emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
    1352                 :          0 :   seq = get_insns ();
    1353                 :          0 :   end_sequence ();
    1354                 :            : 
    1355                 :          0 :   emit_insn_at_entry (seq);
    1356                 :          0 :   return 0;
    1357                 :            : }
    1358                 :            : 
    1359                 :            : /* Return the hardreg-pseudoreg initial values pair entry I and
    1360                 :            :    TRUE if I is a valid entry, or FALSE if I is not a valid entry.  */
    1361                 :            : bool
    1362                 :          0 : initial_value_entry (int i, rtx *hreg, rtx *preg)
    1363                 :            : {
    1364                 :          0 :   struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
    1365                 :          0 :   if (!ivs || i >= ivs->num_entries)
    1366                 :            :     return false;
    1367                 :            : 
    1368                 :          0 :   *hreg = ivs->entries[i].hard_reg;
    1369                 :          0 :   *preg = ivs->entries[i].pseudo;
    1370                 :          0 :   return true;
    1371                 :            : }
    1372                 :            : 
    1373                 :            : /* These routines are responsible for converting virtual register references
    1374                 :            :    to the actual hard register references once RTL generation is complete.
    1375                 :            : 
    1376                 :            :    The following four variables are used for communication between the
    1377                 :            :    routines.  They contain the offsets of the virtual registers from their
    1378                 :            :    respective hard registers.  */
    1379                 :            : 
    1380                 :            : static poly_int64 in_arg_offset;
    1381                 :            : static poly_int64 var_offset;
    1382                 :            : static poly_int64 dynamic_offset;
    1383                 :            : static poly_int64 out_arg_offset;
    1384                 :            : static poly_int64 cfa_offset;
    1385                 :            : 
    1386                 :            : /* In most machines, the stack pointer register is equivalent to the bottom
    1387                 :            :    of the stack.  */
    1388                 :            : 
    1389                 :            : #ifndef STACK_POINTER_OFFSET
    1390                 :            : #define STACK_POINTER_OFFSET    0
    1391                 :            : #endif
    1392                 :            : 
    1393                 :            : #if defined (REG_PARM_STACK_SPACE) && !defined (INCOMING_REG_PARM_STACK_SPACE)
    1394                 :            : #define INCOMING_REG_PARM_STACK_SPACE REG_PARM_STACK_SPACE
    1395                 :            : #endif
    1396                 :            : 
    1397                 :            : /* If not defined, pick an appropriate default for the offset of dynamically
    1398                 :            :    allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
    1399                 :            :    INCOMING_REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE.  */
    1400                 :            : 
    1401                 :            : #ifndef STACK_DYNAMIC_OFFSET
    1402                 :            : 
    1403                 :            : /* The bottom of the stack points to the actual arguments.  If
    1404                 :            :    REG_PARM_STACK_SPACE is defined, this includes the space for the register
    1405                 :            :    parameters.  However, if OUTGOING_REG_PARM_STACK space is not defined,
    1406                 :            :    stack space for register parameters is not pushed by the caller, but
    1407                 :            :    rather part of the fixed stack areas and hence not included in
    1408                 :            :    `crtl->outgoing_args_size'.  Nevertheless, we must allow
    1409                 :            :    for it when allocating stack dynamic objects.  */
    1410                 :            : 
    1411                 :            : #ifdef INCOMING_REG_PARM_STACK_SPACE
    1412                 :            : #define STACK_DYNAMIC_OFFSET(FNDECL)    \
    1413                 :            : ((ACCUMULATE_OUTGOING_ARGS                                                    \
    1414                 :            :   ? (crtl->outgoing_args_size                                      \
    1415                 :            :      + (OUTGOING_REG_PARM_STACK_SPACE ((!(FNDECL) ? NULL_TREE : TREE_TYPE (FNDECL))) ? 0 \
    1416                 :            :                                                : INCOMING_REG_PARM_STACK_SPACE (FNDECL))) \
    1417                 :            :   : 0) + (STACK_POINTER_OFFSET))
    1418                 :            : #else
    1419                 :            : #define STACK_DYNAMIC_OFFSET(FNDECL)    \
    1420                 :            :   ((ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : poly_int64 (0)) \
    1421                 :            :  + (STACK_POINTER_OFFSET))
    1422                 :            : #endif
    1423                 :            : #endif
    1424                 :            : 
    1425                 :            : 
    1426                 :            : /* Given a piece of RTX and a pointer to a HOST_WIDE_INT, if the RTX
    1427                 :            :    is a virtual register, return the equivalent hard register and set the
    1428                 :            :    offset indirectly through the pointer.  Otherwise, return 0.  */
    1429                 :            : 
    1430                 :            : static rtx
    1431                 :  223744000 : instantiate_new_reg (rtx x, poly_int64_pod *poffset)
    1432                 :            : {
    1433                 :  223744000 :   rtx new_rtx;
    1434                 :  223744000 :   poly_int64 offset;
    1435                 :            : 
    1436                 :  223744000 :   if (x == virtual_incoming_args_rtx)
    1437                 :            :     {
    1438                 :    2748650 :       if (stack_realign_drap)
    1439                 :            :         {
    1440                 :            :           /* Replace virtual_incoming_args_rtx with internal arg
    1441                 :            :              pointer if DRAP is used to realign stack.  */
    1442                 :      16502 :           new_rtx = crtl->args.internal_arg_pointer;
    1443                 :      16502 :           offset = 0;
    1444                 :            :         }
    1445                 :            :       else
    1446                 :    2732140 :         new_rtx = arg_pointer_rtx, offset = in_arg_offset;
    1447                 :            :     }
    1448                 :  220996000 :   else if (x == virtual_stack_vars_rtx)
    1449                 :   12013400 :     new_rtx = frame_pointer_rtx, offset = var_offset;
    1450                 :  208982000 :   else if (x == virtual_stack_dynamic_rtx)
    1451                 :      20581 :     new_rtx = stack_pointer_rtx, offset = dynamic_offset;
    1452                 :  208962000 :   else if (x == virtual_outgoing_args_rtx)
    1453                 :      42507 :     new_rtx = stack_pointer_rtx, offset = out_arg_offset;
    1454                 :  208919000 :   else if (x == virtual_cfa_rtx)
    1455                 :            :     {
    1456                 :            : #ifdef FRAME_POINTER_CFA_OFFSET
    1457                 :            :       new_rtx = frame_pointer_rtx;
    1458                 :            : #else
    1459                 :       1816 :       new_rtx = arg_pointer_rtx;
    1460                 :            : #endif
    1461                 :       1816 :       offset = cfa_offset;
    1462                 :            :     }
    1463                 :  208917000 :   else if (x == virtual_preferred_stack_boundary_rtx)
    1464                 :            :     {
    1465                 :      47768 :       new_rtx = GEN_INT (crtl->preferred_stack_boundary / BITS_PER_UNIT);
    1466                 :      47768 :       offset = 0;
    1467                 :            :     }
    1468                 :            :   else
    1469                 :            :     return NULL_RTX;
    1470                 :            : 
    1471                 :   14874700 :   *poffset = offset;
    1472                 :   14874700 :   return new_rtx;
    1473                 :            : }
    1474                 :            : 
    1475                 :            : /* A subroutine of instantiate_virtual_regs.  Instantiate any virtual
    1476                 :            :    registers present inside of *LOC.  The expression is simplified,
    1477                 :            :    as much as possible, but is not to be considered "valid" in any sense
    1478                 :            :    implied by the target.  Return true if any change is made.  */
    1479                 :            : 
    1480                 :            : static bool
    1481                 :  130698000 : instantiate_virtual_regs_in_rtx (rtx *loc)
    1482                 :            : {
    1483                 :  130698000 :   if (!*loc)
    1484                 :            :     return false;
    1485                 :   60555600 :   bool changed = false;
    1486                 :   60555600 :   subrtx_ptr_iterator::array_type array;
    1487                 :  219350000 :   FOR_EACH_SUBRTX_PTR (iter, array, loc, NONCONST)
    1488                 :            :     {
    1489                 :  158794000 :       rtx *loc = *iter;
    1490                 :  158794000 :       if (rtx x = *loc)
    1491                 :            :         {
    1492                 :  143223000 :           rtx new_rtx;
    1493                 :  143223000 :           poly_int64 offset;
    1494                 :  143223000 :           switch (GET_CODE (x))
    1495                 :            :             {
    1496                 :   21044100 :             case REG:
    1497                 :   21044100 :               new_rtx = instantiate_new_reg (x, &offset);
    1498                 :   21044100 :               if (new_rtx)
    1499                 :            :                 {
    1500                 :     416427 :                   *loc = plus_constant (GET_MODE (x), new_rtx, offset);
    1501                 :     416427 :                   changed = true;
    1502                 :            :                 }
    1503                 :   21044100 :               iter.skip_subrtxes ();
    1504                 :            :               break;
    1505                 :            : 
    1506                 :   17904700 :             case PLUS:
    1507                 :   17904700 :               new_rtx = instantiate_new_reg (XEXP (x, 0), &offset);
    1508                 :   17904700 :               if (new_rtx)
    1509                 :            :                 {
    1510                 :   12690900 :                   XEXP (x, 0) = new_rtx;
    1511                 :   12690900 :                   *loc = plus_constant (GET_MODE (x), x, offset, true);
    1512                 :   12690900 :                   changed = true;
    1513                 :   12690900 :                   iter.skip_subrtxes ();
    1514                 :            :                   break;
    1515                 :            :                 }
    1516                 :            : 
    1517                 :            :               /* FIXME -- from old code */
    1518                 :            :               /* If we have (plus (subreg (virtual-reg)) (const_int)), we know
    1519                 :            :                  we can commute the PLUS and SUBREG because pointers into the
    1520                 :            :                  frame are well-behaved.  */
    1521                 :            :               break;
    1522                 :            : 
    1523                 :            :             default:
    1524                 :            :               break;
    1525                 :            :             }
    1526                 :            :         }
    1527                 :            :     }
    1528                 :   60555600 :   return changed;
    1529                 :            : }
    1530                 :            : 
    1531                 :            : /* A subroutine of instantiate_virtual_regs_in_insn.  Return true if X
    1532                 :            :    matches the predicate for insn CODE operand OPERAND.  */
    1533                 :            : 
    1534                 :            : static int
    1535                 :   20397700 : safe_insn_predicate (int code, int operand, rtx x)
    1536                 :            : {
    1537                 :   20392200 :   return code < 0 || insn_operand_matches ((enum insn_code) code, operand, x);
    1538                 :            : }
    1539                 :            : 
    1540                 :            : /* A subroutine of instantiate_virtual_regs.  Instantiate any virtual
    1541                 :            :    registers present inside of insn.  The result will be a valid insn.  */
    1542                 :            : 
    1543                 :            : static void
    1544                 :   58125400 : instantiate_virtual_regs_in_insn (rtx_insn *insn)
    1545                 :            : {
    1546                 :   58125400 :   poly_int64 offset;
    1547                 :   58125400 :   int insn_code, i;
    1548                 :   58125400 :   bool any_change = false;
    1549                 :   58125400 :   rtx set, new_rtx, x;
    1550                 :   58125400 :   rtx_insn *seq;
    1551                 :            : 
    1552                 :            :   /* There are some special cases to be handled first.  */
    1553                 :   58125400 :   set = single_set (insn);
    1554                 :   58125400 :   if (set)
    1555                 :            :     {
    1556                 :            :       /* We're allowed to assign to a virtual register.  This is interpreted
    1557                 :            :          to mean that the underlying register gets assigned the inverse
    1558                 :            :          transformation.  This is used, for example, in the handling of
    1559                 :            :          non-local gotos.  */
    1560                 :   55121200 :       new_rtx = instantiate_new_reg (SET_DEST (set), &offset);
    1561                 :   55121200 :       if (new_rtx)
    1562                 :            :         {
    1563                 :          0 :           start_sequence ();
    1564                 :            : 
    1565                 :          0 :           instantiate_virtual_regs_in_rtx (&SET_SRC (set));
    1566                 :          0 :           x = simplify_gen_binary (PLUS, GET_MODE (new_rtx), SET_SRC (set),
    1567                 :          0 :                                    gen_int_mode (-offset, GET_MODE (new_rtx)));
    1568                 :          0 :           x = force_operand (x, new_rtx);
    1569                 :          0 :           if (x != new_rtx)
    1570                 :          0 :             emit_move_insn (new_rtx, x);
    1571                 :            : 
    1572                 :          0 :           seq = get_insns ();
    1573                 :          0 :           end_sequence ();
    1574                 :            : 
    1575                 :          0 :           emit_insn_before (seq, insn);
    1576                 :          0 :           delete_insn (insn);
    1577                 :      13431 :           return;
    1578                 :            :         }
    1579                 :            : 
    1580                 :            :       /* Handle a straight copy from a virtual register by generating a
    1581                 :            :          new add insn.  The difference between this and falling through
    1582                 :            :          to the generic case is avoiding a new pseudo and eliminating a
    1583                 :            :          move insn in the initial rtl stream.  */
    1584                 :   55121200 :       new_rtx = instantiate_new_reg (SET_SRC (set), &offset);
    1585                 :   55121200 :       if (new_rtx
    1586                 :      47961 :           && maybe_ne (offset, 0)
    1587                 :       3841 :           && REG_P (SET_DEST (set))
    1588                 :   55125000 :           && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
    1589                 :            :         {
    1590                 :       3841 :           start_sequence ();
    1591                 :            : 
    1592                 :       3841 :           x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS, new_rtx,
    1593                 :            :                                    gen_int_mode (offset,
    1594                 :       3841 :                                                  GET_MODE (SET_DEST (set))),
    1595                 :            :                                    SET_DEST (set), 1, OPTAB_LIB_WIDEN);
    1596                 :       3841 :           if (x != SET_DEST (set))
    1597                 :          0 :             emit_move_insn (SET_DEST (set), x);
    1598                 :            : 
    1599                 :       3841 :           seq = get_insns ();
    1600                 :       3841 :           end_sequence ();
    1601                 :            : 
    1602                 :       3841 :           emit_insn_before (seq, insn);
    1603                 :       3841 :           delete_insn (insn);
    1604                 :       3841 :           return;
    1605                 :            :         }
    1606                 :            : 
    1607                 :   55117400 :       extract_insn (insn);
    1608                 :   55117400 :       insn_code = INSN_CODE (insn);
    1609                 :            : 
    1610                 :            :       /* Handle a plus involving a virtual register by determining if the
    1611                 :            :          operands remain valid if they're modified in place.  */
    1612                 :   55117400 :       poly_int64 delta;
    1613                 :   55117400 :       if (GET_CODE (SET_SRC (set)) == PLUS
    1614                 :    6117220 :           && recog_data.n_operands >= 3
    1615                 :    6061110 :           && recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0)
    1616                 :    6060960 :           && recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1)
    1617                 :    6060960 :           && poly_int_rtx_p (recog_data.operand[2], &delta)
    1618                 :   60179900 :           && (new_rtx = instantiate_new_reg (recog_data.operand[1], &offset)))
    1619                 :            :         {
    1620                 :    1635240 :           offset += delta;
    1621                 :            : 
    1622                 :            :           /* If the sum is zero, then replace with a plain move.  */
    1623                 :    1635240 :           if (known_eq (offset, 0)
    1624                 :       9590 :               && REG_P (SET_DEST (set))
    1625                 :    1644830 :               && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
    1626                 :            :             {
    1627                 :       9590 :               start_sequence ();
    1628                 :       9590 :               emit_move_insn (SET_DEST (set), new_rtx);
    1629                 :       9590 :               seq = get_insns ();
    1630                 :       9590 :               end_sequence ();
    1631                 :            : 
    1632                 :       9590 :               emit_insn_before (seq, insn);
    1633                 :       9590 :               delete_insn (insn);
    1634                 :       9590 :               return;
    1635                 :            :             }
    1636                 :            : 
    1637                 :    1625650 :           x = gen_int_mode (offset, recog_data.operand_mode[2]);
    1638                 :            : 
    1639                 :            :           /* Using validate_change and apply_change_group here leaves
    1640                 :            :              recog_data in an invalid state.  Since we know exactly what
    1641                 :            :              we want to check, do those two by hand.  */
    1642                 :    3239360 :           if (safe_insn_predicate (insn_code, 1, new_rtx)
    1643                 :   59725600 :               && safe_insn_predicate (insn_code, 2, x))
    1644                 :            :             {
    1645                 :    1613710 :               *recog_data.operand_loc[1] = recog_data.operand[1] = new_rtx;
    1646                 :    1613710 :               *recog_data.operand_loc[2] = recog_data.operand[2] = x;
    1647                 :    1613710 :               any_change = true;
    1648                 :            : 
    1649                 :            :               /* Fall through into the regular operand fixup loop in
    1650                 :            :                  order to take care of operands other than 1 and 2.  */
    1651                 :            :             }
    1652                 :            :         }
    1653                 :            :     }
    1654                 :            :   else
    1655                 :            :     {
    1656                 :    3004160 :       extract_insn (insn);
    1657                 :    3004160 :       insn_code = INSN_CODE (insn);
    1658                 :            :     }
    1659                 :            : 
    1660                 :            :   /* In the general case, we expect virtual registers to appear only in
    1661                 :            :      operands, and then only as either bare registers or inside memories.  */
    1662                 :  183358000 :   for (i = 0; i < recog_data.n_operands; ++i)
    1663                 :            :     {
    1664                 :  125246000 :       x = recog_data.operand[i];
    1665                 :  125246000 :       switch (GET_CODE (x))
    1666                 :            :         {
    1667                 :   19665800 :         case MEM:
    1668                 :   19665800 :           {
    1669                 :   19665800 :             rtx addr = XEXP (x, 0);
    1670                 :            : 
    1671                 :   19665800 :             if (!instantiate_virtual_regs_in_rtx (&addr))
    1672                 :   11128700 :               continue;
    1673                 :            : 
    1674                 :    8537040 :             start_sequence ();
    1675                 :    8537040 :             x = replace_equiv_address (x, addr, true);
    1676                 :            :             /* It may happen that the address with the virtual reg
    1677                 :            :                was valid (e.g. based on the virtual stack reg, which might
    1678                 :            :                be acceptable to the predicates with all offsets), whereas
    1679                 :            :                the address now isn't anymore, for instance when the address
    1680                 :            :                is still offsetted, but the base reg isn't virtual-stack-reg
    1681                 :            :                anymore.  Below we would do a force_reg on the whole operand,
    1682                 :            :                but this insn might actually only accept memory.  Hence,
    1683                 :            :                before doing that last resort, try to reload the address into
    1684                 :            :                a register, so this operand stays a MEM.  */
    1685                 :    8537040 :             if (!safe_insn_predicate (insn_code, i, x))
    1686                 :            :               {
    1687                 :          0 :                 addr = force_reg (GET_MODE (addr), addr);
    1688                 :          0 :                 x = replace_equiv_address (x, addr, true);
    1689                 :            :               }
    1690                 :    8537040 :             seq = get_insns ();
    1691                 :    8537040 :             end_sequence ();
    1692                 :    8537040 :             if (seq)
    1693                 :          0 :               emit_insn_before (seq, insn);
    1694                 :            :           }
    1695                 :    8537040 :           break;
    1696                 :            : 
    1697                 :   67278200 :         case REG:
    1698                 :   67278200 :           new_rtx = instantiate_new_reg (x, &offset);
    1699                 :   67278200 :           if (new_rtx == NULL)
    1700                 :   67193900 :             continue;
    1701                 :      84255 :           if (known_eq (offset, 0))
    1702                 :            :             x = new_rtx;
    1703                 :            :           else
    1704                 :            :             {
    1705                 :          0 :               start_sequence ();
    1706                 :            : 
    1707                 :            :               /* Careful, special mode predicates may have stuff in
    1708                 :            :                  insn_data[insn_code].operand[i].mode that isn't useful
    1709                 :            :                  to us for computing a new value.  */
    1710                 :            :               /* ??? Recognize address_operand and/or "p" constraints
    1711                 :            :                  to see if (plus new offset) is a valid before we put
    1712                 :            :                  this through expand_simple_binop.  */
    1713                 :          0 :               x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx,
    1714                 :          0 :                                        gen_int_mode (offset, GET_MODE (x)),
    1715                 :            :                                        NULL_RTX, 1, OPTAB_LIB_WIDEN);
    1716                 :          0 :               seq = get_insns ();
    1717                 :          0 :               end_sequence ();
    1718                 :          0 :               emit_insn_before (seq, insn);
    1719                 :            :             }
    1720                 :            :           break;
    1721                 :            : 
    1722                 :    2212330 :         case SUBREG:
    1723                 :    2212330 :           new_rtx = instantiate_new_reg (SUBREG_REG (x), &offset);
    1724                 :    2212330 :           if (new_rtx == NULL)
    1725                 :    2212330 :             continue;
    1726                 :          2 :           if (maybe_ne (offset, 0))
    1727                 :            :             {
    1728                 :          0 :               start_sequence ();
    1729                 :          0 :               new_rtx = expand_simple_binop
    1730                 :          0 :                 (GET_MODE (new_rtx), PLUS, new_rtx,
    1731                 :          0 :                  gen_int_mode (offset, GET_MODE (new_rtx)),
    1732                 :            :                  NULL_RTX, 1, OPTAB_LIB_WIDEN);
    1733                 :          0 :               seq = get_insns ();
    1734                 :          0 :               end_sequence ();
    1735                 :          0 :               emit_insn_before (seq, insn);
    1736                 :            :             }
    1737                 :          4 :           x = simplify_gen_subreg (recog_data.operand_mode[i], new_rtx,
    1738                 :          2 :                                    GET_MODE (new_rtx), SUBREG_BYTE (x));
    1739                 :          2 :           gcc_assert (x);
    1740                 :            :           break;
    1741                 :            : 
    1742                 :   36090100 :         default:
    1743                 :   36090100 :           continue;
    1744                 :            :         }
    1745                 :            : 
    1746                 :            :       /* At this point, X contains the new value for the operand.
    1747                 :            :          Validate the new value vs the insn predicate.  Note that
    1748                 :            :          asm insns will have insn_code -1 here.  */
    1749                 :    8621300 :       if (!safe_insn_predicate (insn_code, i, x))
    1750                 :            :         {
    1751                 :      23884 :           start_sequence ();
    1752                 :      23884 :           if (REG_P (x))
    1753                 :            :             {
    1754                 :          0 :               gcc_assert (REGNO (x) <= LAST_VIRTUAL_REGISTER);
    1755                 :          0 :               x = copy_to_reg (x);
    1756                 :            :             }
    1757                 :            :           else
    1758                 :      23884 :             x = force_reg (insn_data[insn_code].operand[i].mode, x);
    1759                 :      23884 :           seq = get_insns ();
    1760                 :      23884 :           end_sequence ();
    1761                 :      23884 :           if (seq)
    1762                 :      23884 :             emit_insn_before (seq, insn);
    1763                 :            :         }
    1764                 :            : 
    1765                 :    8621300 :       *recog_data.operand_loc[i] = recog_data.operand[i] = x;
    1766                 :    8621300 :       any_change = true;
    1767                 :            :     }
    1768                 :            : 
    1769                 :   58111900 :   if (any_change)
    1770                 :            :     {
    1771                 :            :       /* Propagate operand changes into the duplicates.  */
    1772                 :   10176700 :       for (i = 0; i < recog_data.n_dups; ++i)
    1773                 :      52026 :         *recog_data.dup_loc[i]
    1774                 :      52026 :           = copy_rtx (recog_data.operand[(unsigned)recog_data.dup_num[i]]);
    1775                 :            : 
    1776                 :            :       /* Force re-recognition of the instruction for validation.  */
    1777                 :   10124700 :       INSN_CODE (insn) = -1;
    1778                 :            :     }
    1779                 :            : 
    1780                 :   58111900 :   if (asm_noperands (PATTERN (insn)) >= 0)
    1781                 :            :     {
    1782                 :      88031 :       if (!check_asm_operands (PATTERN (insn)))
    1783                 :            :         {
    1784                 :         20 :           error_for_asm (insn, "impossible constraint in %<asm%>");
    1785                 :            :           /* For asm goto, instead of fixing up all the edges
    1786                 :            :              just clear the template and clear input operands
    1787                 :            :              (asm goto doesn't have any output operands).  */
    1788                 :         20 :           if (JUMP_P (insn))
    1789                 :            :             {
    1790                 :         12 :               rtx asm_op = extract_asm_operands (PATTERN (insn));
    1791                 :         12 :               ASM_OPERANDS_TEMPLATE (asm_op) = ggc_strdup ("");
    1792                 :         12 :               ASM_OPERANDS_INPUT_VEC (asm_op) = rtvec_alloc (0);
    1793                 :         12 :               ASM_OPERANDS_INPUT_CONSTRAINT_VEC (asm_op) = rtvec_alloc (0);
    1794                 :            :             }
    1795                 :            :           else
    1796                 :          8 :             delete_insn (insn);
    1797                 :            :         }
    1798                 :            :     }
    1799                 :            :   else
    1800                 :            :     {
    1801                 :   68146600 :       if (recog_memoized (insn) < 0)
    1802                 :          0 :         fatal_insn_not_found (insn);
    1803                 :            :     }
    1804                 :            : }
    1805                 :            : 
    1806                 :            : /* Subroutine of instantiate_decls.  Given RTL representing a decl,
    1807                 :            :    do any instantiation required.  */
    1808                 :            : 
    1809                 :            : void
    1810                 :    5865910 : instantiate_decl_rtl (rtx x)
    1811                 :            : {
    1812                 :    5869600 :   rtx addr;
    1813                 :            : 
    1814                 :    5869600 :   if (x == 0)
    1815                 :            :     return;
    1816                 :            : 
    1817                 :            :   /* If this is a CONCAT, recurse for the pieces.  */
    1818                 :    5869600 :   if (GET_CODE (x) == CONCAT)
    1819                 :            :     {
    1820                 :       3697 :       instantiate_decl_rtl (XEXP (x, 0));
    1821                 :       3697 :       instantiate_decl_rtl (XEXP (x, 1));
    1822                 :       3697 :       return;
    1823                 :            :     }
    1824                 :            : 
    1825                 :            :   /* If this is not a MEM, no need to do anything.  Similarly if the
    1826                 :            :      address is a constant or a register that is not a virtual register.  */
    1827                 :    5865910 :   if (!MEM_P (x))
    1828                 :            :     return;
    1829                 :            : 
    1830                 :    2079070 :   addr = XEXP (x, 0);
    1831                 :    2079070 :   if (CONSTANT_P (addr)
    1832                 :    2079070 :       || (REG_P (addr)
    1833                 :     195171 :           && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
    1834                 :     172080 :               || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
    1835                 :            :     return;
    1836                 :            : 
    1837                 :    1918790 :   instantiate_virtual_regs_in_rtx (&XEXP (x, 0));
    1838                 :            : }
    1839                 :            : 
    1840                 :            : /* Helper for instantiate_decls called via walk_tree: Process all decls
    1841                 :            :    in the given DECL_VALUE_EXPR.  */
    1842                 :            : 
    1843                 :            : static tree
    1844                 :     380311 : instantiate_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
    1845                 :            : {
    1846                 :     380311 :   tree t = *tp;
    1847                 :     380311 :   if (! EXPR_P (t))
    1848                 :            :     {
    1849                 :     222449 :       *walk_subtrees = 0;
    1850                 :     222449 :       if (DECL_P (t))
    1851                 :            :         {
    1852                 :     173848 :           if (DECL_RTL_SET_P (t))
    1853                 :      99984 :             instantiate_decl_rtl (DECL_RTL (t));
    1854                 :      77911 :           if (TREE_CODE (t) == PARM_DECL && DECL_NAMELESS (t)
    1855                 :     249061 :               && DECL_INCOMING_RTL (t))
    1856                 :      75213 :             instantiate_decl_rtl (DECL_INCOMING_RTL (t));
    1857                 :     125233 :           if ((VAR_P (t) || TREE_CODE (t) == RESULT_DECL)
    1858                 :     226438 :               && DECL_HAS_VALUE_EXPR_P (t))
    1859                 :            :             {
    1860                 :       4060 :               tree v = DECL_VALUE_EXPR (t);
    1861                 :       4060 :               walk_tree (&v, instantiate_expr, NULL, NULL);
    1862                 :            :             }
    1863                 :            :         }
    1864                 :            :     }
    1865                 :     380311 :   return NULL;
    1866                 :            : }
    1867                 :            : 
    1868                 :            : /* Subroutine of instantiate_decls: Process all decls in the given
    1869                 :            :    BLOCK node and all its subblocks.  */
    1870                 :            : 
    1871                 :            : static void
    1872                 :    9188560 : instantiate_decls_1 (tree let)
    1873                 :            : {
    1874                 :    9188560 :   tree t;
    1875                 :            : 
    1876                 :   18307900 :   for (t = BLOCK_VARS (let); t; t = DECL_CHAIN (t))
    1877                 :            :     {
    1878                 :    9119330 :       if (DECL_RTL_SET_P (t))
    1879                 :    1243580 :         instantiate_decl_rtl (DECL_RTL (t));
    1880                 :    9119330 :       if (VAR_P (t) && DECL_HAS_VALUE_EXPR_P (t))
    1881                 :            :         {
    1882                 :      78941 :           tree v = DECL_VALUE_EXPR (t);
    1883                 :      78941 :           walk_tree (&v, instantiate_expr, NULL, NULL);
    1884                 :            :         }
    1885                 :            :     }
    1886                 :            : 
    1887                 :            :   /* Process all subblocks.  */
    1888                 :   17433000 :   for (t = BLOCK_SUBBLOCKS (let); t; t = BLOCK_CHAIN (t))
    1889                 :    8244470 :     instantiate_decls_1 (t);
    1890                 :    9188560 : }
    1891                 :            : 
    1892                 :            : /* Scan all decls in FNDECL (both variables and parameters) and instantiate
    1893                 :            :    all virtual registers in their DECL_RTL's.  */
    1894                 :            : 
    1895                 :            : static void
    1896                 :     944091 : instantiate_decls (tree fndecl)
    1897                 :            : {
    1898                 :     944091 :   tree decl;
    1899                 :     944091 :   unsigned ix;
    1900                 :            : 
    1901                 :            :   /* Process all parameters of the function.  */
    1902                 :    2908460 :   for (decl = DECL_ARGUMENTS (fndecl); decl; decl = DECL_CHAIN (decl))
    1903                 :            :     {
    1904                 :    1964370 :       instantiate_decl_rtl (DECL_RTL (decl));
    1905                 :    1964370 :       instantiate_decl_rtl (DECL_INCOMING_RTL (decl));
    1906                 :    3928730 :       if (DECL_HAS_VALUE_EXPR_P (decl))
    1907                 :            :         {
    1908                 :         65 :           tree v = DECL_VALUE_EXPR (decl);
    1909                 :         65 :           walk_tree (&v, instantiate_expr, NULL, NULL);
    1910                 :            :         }
    1911                 :            :     }
    1912                 :            : 
    1913                 :     944091 :   if ((decl = DECL_RESULT (fndecl))
    1914                 :     944091 :       && TREE_CODE (decl) == RESULT_DECL)
    1915                 :            :     {
    1916                 :     944091 :       if (DECL_RTL_SET_P (decl))
    1917                 :     500160 :         instantiate_decl_rtl (DECL_RTL (decl));
    1918                 :    1888180 :       if (DECL_HAS_VALUE_EXPR_P (decl))
    1919                 :            :         {
    1920                 :      50830 :           tree v = DECL_VALUE_EXPR (decl);
    1921                 :      50830 :           walk_tree (&v, instantiate_expr, NULL, NULL);
    1922                 :            :         }
    1923                 :            :     }
    1924                 :            : 
    1925                 :            :   /* Process the saved static chain if it exists.  */
    1926                 :     944091 :   decl = DECL_STRUCT_FUNCTION (fndecl)->static_chain_decl;
    1927                 :     958382 :   if (decl && DECL_HAS_VALUE_EXPR_P (decl))
    1928                 :       2073 :     instantiate_decl_rtl (DECL_RTL (DECL_VALUE_EXPR (decl)));
    1929                 :            : 
    1930                 :            :   /* Now process all variables defined in the function or its subblocks.  */
    1931                 :     944091 :   if (DECL_INITIAL (fndecl))
    1932                 :     944091 :     instantiate_decls_1 (DECL_INITIAL (fndecl));
    1933                 :            : 
    1934                 :    1763560 :   FOR_EACH_LOCAL_DECL (cfun, ix, decl)
    1935                 :      40179 :     if (DECL_RTL_SET_P (decl))
    1936                 :      11198 :       instantiate_decl_rtl (DECL_RTL (decl));
    1937                 :     944091 :   vec_free (cfun->local_decls);
    1938                 :     944091 : }
    1939                 :            : 
    1940                 :            : /* Pass through the INSNS of function FNDECL and convert virtual register
    1941                 :            :    references to hard register references.  */
    1942                 :            : 
    1943                 :            : static unsigned int
    1944                 :     944091 : instantiate_virtual_regs (void)
    1945                 :            : {
    1946                 :     944091 :   rtx_insn *insn;
    1947                 :            : 
    1948                 :            :   /* Compute the offsets to use for this function.  */
    1949                 :     944091 :   in_arg_offset = FIRST_PARM_OFFSET (current_function_decl);
    1950                 :     944091 :   var_offset = targetm.starting_frame_offset ();
    1951                 :     944091 :   dynamic_offset = STACK_DYNAMIC_OFFSET (current_function_decl);
    1952                 :     944091 :   out_arg_offset = STACK_POINTER_OFFSET;
    1953                 :            : #ifdef FRAME_POINTER_CFA_OFFSET
    1954                 :            :   cfa_offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
    1955                 :            : #else
    1956                 :     944091 :   cfa_offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
    1957                 :            : #endif
    1958                 :            : 
    1959                 :            :   /* Initialize recognition, indicating that volatile is OK.  */
    1960                 :     944091 :   init_recog ();
    1961                 :            : 
    1962                 :            :   /* Scan through all the insns, instantiating every virtual register still
    1963                 :            :      present.  */
    1964                 :  214571000 :   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
    1965                 :  106814000 :     if (INSN_P (insn))
    1966                 :            :       {
    1967                 :            :         /* These patterns in the instruction stream can never be recognized.
    1968                 :            :            Fortunately, they shouldn't contain virtual registers either.  */
    1969                 :   88402900 :         if (GET_CODE (PATTERN (insn)) == USE
    1970                 :   87920200 :             || GET_CODE (PATTERN (insn)) == CLOBBER
    1971                 :   87819800 :             || GET_CODE (PATTERN (insn)) == ASM_INPUT
    1972                 :  176221000 :             || DEBUG_MARKER_INSN_P (insn))
    1973                 :    6760020 :           continue;
    1974                 :   81642900 :         else if (DEBUG_BIND_INSN_P (insn))
    1975                 :   23517500 :           instantiate_virtual_regs_in_rtx (INSN_VAR_LOCATION_PTR (insn));
    1976                 :            :         else
    1977                 :   58125400 :           instantiate_virtual_regs_in_insn (insn);
    1978                 :            : 
    1979                 :   81642900 :         if (insn->deleted ())
    1980                 :      13439 :           continue;
    1981                 :            : 
    1982                 :   81629500 :         instantiate_virtual_regs_in_rtx (&REG_NOTES (insn));
    1983                 :            : 
    1984                 :            :         /* Instantiate any virtual registers in CALL_INSN_FUNCTION_USAGE.  */
    1985                 :   81629500 :         if (CALL_P (insn))
    1986                 :    3966220 :           instantiate_virtual_regs_in_rtx (&CALL_INSN_FUNCTION_USAGE (insn));
    1987                 :            :       }
    1988                 :            : 
    1989                 :            :   /* Instantiate the virtual registers in the DECLs for debugging purposes.  */
    1990                 :     944091 :   instantiate_decls (current_function_decl);
    1991                 :            : 
    1992                 :     944091 :   targetm.instantiate_decls ();
    1993                 :            : 
    1994                 :            :   /* Indicate that, from now on, assign_stack_local should use
    1995                 :            :      frame_pointer_rtx.  */
    1996                 :     944091 :   virtuals_instantiated = 1;
    1997                 :            : 
    1998                 :     944091 :   return 0;
    1999                 :            : }
    2000                 :            : 
    2001                 :            : namespace {
    2002                 :            : 
    2003                 :            : const pass_data pass_data_instantiate_virtual_regs =
    2004                 :            : {
    2005                 :            :   RTL_PASS, /* type */
    2006                 :            :   "vregs", /* name */
    2007                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    2008                 :            :   TV_NONE, /* tv_id */
    2009                 :            :   0, /* properties_required */
    2010                 :            :   0, /* properties_provided */
    2011                 :            :   0, /* properties_destroyed */
    2012                 :            :   0, /* todo_flags_start */
    2013                 :            :   0, /* todo_flags_finish */
    2014                 :            : };
    2015                 :            : 
    2016                 :            : class pass_instantiate_virtual_regs : public rtl_opt_pass
    2017                 :            : {
    2018                 :            : public:
    2019                 :     200773 :   pass_instantiate_virtual_regs (gcc::context *ctxt)
    2020                 :     401546 :     : rtl_opt_pass (pass_data_instantiate_virtual_regs, ctxt)
    2021                 :            :   {}
    2022                 :            : 
    2023                 :            :   /* opt_pass methods: */
    2024                 :     944091 :   virtual unsigned int execute (function *)
    2025                 :            :     {
    2026                 :     944091 :       return instantiate_virtual_regs ();
    2027                 :            :     }
    2028                 :            : 
    2029                 :            : }; // class pass_instantiate_virtual_regs
    2030                 :            : 
    2031                 :            : } // anon namespace
    2032                 :            : 
    2033                 :            : rtl_opt_pass *
    2034                 :     200773 : make_pass_instantiate_virtual_regs (gcc::context *ctxt)
    2035                 :            : {
    2036                 :     200773 :   return new pass_instantiate_virtual_regs (ctxt);
    2037                 :            : }
    2038                 :            : 
    2039                 :            : 
    2040                 :            : /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
    2041                 :            :    This means a type for which function calls must pass an address to the
    2042                 :            :    function or get an address back from the function.
    2043                 :            :    EXP may be a type node or an expression (whose type is tested).  */
    2044                 :            : 
    2045                 :            : int
    2046                 :   59591000 : aggregate_value_p (const_tree exp, const_tree fntype)
    2047                 :            : {
    2048                 :  116952000 :   const_tree type = (TYPE_P (exp)) ? exp : TREE_TYPE (exp);
    2049                 :   59602500 :   int i, regno, nregs;
    2050                 :   59602500 :   rtx reg;
    2051                 :            : 
    2052                 :   59602500 :   if (fntype)
    2053                 :   59296100 :     switch (TREE_CODE (fntype))
    2054                 :            :       {
    2055                 :    7491830 :       case CALL_EXPR:
    2056                 :    7491830 :         {
    2057                 :    7491830 :           tree fndecl = get_callee_fndecl (fntype);
    2058                 :    7491830 :           if (fndecl)
    2059                 :    6924430 :             fntype = TREE_TYPE (fndecl);
    2060                 :     567400 :           else if (CALL_EXPR_FN (fntype))
    2061                 :     297717 :             fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype)));
    2062                 :            :           else
    2063                 :            :             /* For internal functions, assume nothing needs to be
    2064                 :            :                returned in memory.  */
    2065                 :            :             return 0;
    2066                 :            :         }
    2067                 :            :         break;
    2068                 :   46552900 :       case FUNCTION_DECL:
    2069                 :   46552900 :         fntype = TREE_TYPE (fntype);
    2070                 :   46552900 :         break;
    2071                 :            :       case FUNCTION_TYPE:
    2072                 :            :       case METHOD_TYPE:
    2073                 :            :         break;
    2074                 :      12429 :       case IDENTIFIER_NODE:
    2075                 :      12429 :         fntype = NULL_TREE;
    2076                 :      12429 :         break;
    2077                 :          0 :       default:
    2078                 :            :         /* We don't expect other tree types here.  */
    2079                 :          0 :         gcc_unreachable ();
    2080                 :            :       }
    2081                 :            : 
    2082                 :   59332900 :   if (VOID_TYPE_P (type))
    2083                 :            :     return 0;
    2084                 :            : 
    2085                 :            :   /* If a record should be passed the same as its first (and only) member
    2086                 :            :      don't pass it as an aggregate.  */
    2087                 :   44799700 :   if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
    2088                 :      11577 :     return aggregate_value_p (first_field (type), fntype);
    2089                 :            : 
    2090                 :            :   /* If the front end has decided that this needs to be passed by
    2091                 :            :      reference, do so.  */
    2092                 :   44788100 :   if ((TREE_CODE (exp) == PARM_DECL || TREE_CODE (exp) == RESULT_DECL)
    2093                 :   78713900 :       && DECL_BY_REFERENCE (exp))
    2094                 :            :     return 1;
    2095                 :            : 
    2096                 :            :   /* Function types that are TREE_ADDRESSABLE force return in memory.  */
    2097                 :   44694400 :   if (fntype && TREE_ADDRESSABLE (fntype))
    2098                 :            :     return 1;
    2099                 :            : 
    2100                 :            :   /* Types that are TREE_ADDRESSABLE must be constructed in memory,
    2101                 :            :      and thus can't be returned in registers.  */
    2102                 :   44694400 :   if (TREE_ADDRESSABLE (type))
    2103                 :            :     return 1;
    2104                 :            : 
    2105                 :   44393000 :   if (TYPE_EMPTY_P (type))
    2106                 :            :     return 0;
    2107                 :            : 
    2108                 :   44196600 :   if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
    2109                 :            :     return 1;
    2110                 :            : 
    2111                 :   43591000 :   if (targetm.calls.return_in_memory (type, fntype))
    2112                 :            :     return 1;
    2113                 :            : 
    2114                 :            :   /* Make sure we have suitable call-clobbered regs to return
    2115                 :            :      the value in; if not, we must return it in memory.  */
    2116                 :   41850700 :   reg = hard_function_value (type, 0, fntype, 0);
    2117                 :            : 
    2118                 :            :   /* If we have something other than a REG (e.g. a PARALLEL), then assume
    2119                 :            :      it is OK.  */
    2120                 :   41850700 :   if (!REG_P (reg))
    2121                 :            :     return 0;
    2122                 :            : 
    2123                 :            :   /* Use the default ABI if the type of the function isn't known.
    2124                 :            :      The scheme for handling interoperability between different ABIs
    2125                 :            :      requires us to be able to tell when we're calling a function with
    2126                 :            :      a nondefault ABI.  */
    2127                 :   41743900 :   const predefined_function_abi &abi = (fntype
    2128                 :   41743900 :                                         ? fntype_abi (fntype)
    2129                 :     280180 :                                         : default_function_abi);
    2130                 :   41743900 :   regno = REGNO (reg);
    2131                 :   41743900 :   nregs = hard_regno_nregs (regno, TYPE_MODE (type));
    2132                 :   84303500 :   for (i = 0; i < nregs; i++)
    2133                 :   42559700 :     if (!fixed_regs[regno + i] && !abi.clobbers_full_reg_p (regno + i))
    2134                 :            :       return 1;
    2135                 :            : 
    2136                 :            :   return 0;
    2137                 :            : }
    2138                 :            : 
    2139                 :            : /* Return true if we should assign DECL a pseudo register; false if it
    2140                 :            :    should live on the local stack.  */
    2141                 :            : 
    2142                 :            : bool
    2143                 :   99068500 : use_register_for_decl (const_tree decl)
    2144                 :            : {
    2145                 :   99068500 :   if (TREE_CODE (decl) == SSA_NAME)
    2146                 :            :     {
    2147                 :            :       /* We often try to use the SSA_NAME, instead of its underlying
    2148                 :            :          decl, to get type information and guide decisions, to avoid
    2149                 :            :          differences of behavior between anonymous and named
    2150                 :            :          variables, but in this one case we have to go for the actual
    2151                 :            :          variable if there is one.  The main reason is that, at least
    2152                 :            :          at -O0, we want to place user variables on the stack, but we
    2153                 :            :          don't mind using pseudos for anonymous or ignored temps.
    2154                 :            :          Should we take the SSA_NAME, we'd conclude all SSA_NAMEs
    2155                 :            :          should go in pseudos, whereas their corresponding variables
    2156                 :            :          might have to go on the stack.  So, disregarding the decl
    2157                 :            :          here would negatively impact debug info at -O0, enable
    2158                 :            :          coalescing between SSA_NAMEs that ought to get different
    2159                 :            :          stack/pseudo assignments, and get the incoming argument
    2160                 :            :          processing thoroughly confused by PARM_DECLs expected to live
    2161                 :            :          in stack slots but assigned to pseudos.  */
    2162                 :   86329600 :       if (!SSA_NAME_VAR (decl))
    2163                 :   60018300 :         return TYPE_MODE (TREE_TYPE (decl)) != BLKmode
    2164                 :   60025400 :           && !(flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl)));
    2165                 :            : 
    2166                 :   39050300 :       decl = SSA_NAME_VAR (decl);
    2167                 :            :     }
    2168                 :            : 
    2169                 :            :   /* Honor volatile.  */
    2170                 :   39050300 :   if (TREE_SIDE_EFFECTS (decl))
    2171                 :            :     return false;
    2172                 :            : 
    2173                 :            :   /* Honor addressability.  */
    2174                 :   38930200 :   if (TREE_ADDRESSABLE (decl))
    2175                 :            :     return false;
    2176                 :            : 
    2177                 :            :   /* RESULT_DECLs are a bit special in that they're assigned without
    2178                 :            :      regard to use_register_for_decl, but we generally only store in
    2179                 :            :      them.  If we coalesce their SSA NAMEs, we'd better return a
    2180                 :            :      result that matches the assignment in expand_function_start.  */
    2181                 :   36071200 :   if (TREE_CODE (decl) == RESULT_DECL)
    2182                 :            :     {
    2183                 :            :       /* If it's not an aggregate, we're going to use a REG or a
    2184                 :            :          PARALLEL containing a REG.  */
    2185                 :    1911970 :       if (!aggregate_value_p (decl, current_function_decl))
    2186                 :            :         return true;
    2187                 :            : 
    2188                 :            :       /* If expand_function_start determines the return value, we'll
    2189                 :            :          use MEM if it's not by reference.  */
    2190                 :      22502 :       if (cfun->returns_pcc_struct
    2191                 :      22502 :           || (targetm.calls.struct_value_rtx
    2192                 :      22502 :               (TREE_TYPE (current_function_decl), 1)))
    2193                 :          0 :         return DECL_BY_REFERENCE (decl);
    2194                 :            : 
    2195                 :            :       /* Otherwise, we're taking an extra all.function_result_decl
    2196                 :            :          argument.  It's set up in assign_parms_augmented_arg_list,
    2197                 :            :          under the (negated) conditions above, and then it's used to
    2198                 :            :          set up the RESULT_DECL rtl in assign_params, after looping
    2199                 :            :          over all parameters.  Now, if the RESULT_DECL is not by
    2200                 :            :          reference, we'll use a MEM either way.  */
    2201                 :      45004 :       if (!DECL_BY_REFERENCE (decl))
    2202                 :            :         return false;
    2203                 :            : 
    2204                 :            :       /* Otherwise, if RESULT_DECL is DECL_BY_REFERENCE, it will take
    2205                 :            :          the function_result_decl's assignment.  Since it's a pointer,
    2206                 :            :          we can short-circuit a number of the tests below, and we must
    2207                 :            :          duplicat e them because we don't have the
    2208                 :            :          function_result_decl to test.  */
    2209                 :      22502 :       if (!targetm.calls.allocate_stack_slots_for_args ())
    2210                 :            :         return true;
    2211                 :            :       /* We don't set DECL_IGNORED_P for the function_result_decl.  */
    2212                 :      22502 :       if (optimize)
    2213                 :            :         return true;
    2214                 :            :       /* We don't set DECL_REGISTER for the function_result_decl.  */
    2215                 :       3002 :       return false;
    2216                 :            :     }
    2217                 :            : 
    2218                 :            :   /* Only register-like things go in registers.  */
    2219                 :   34159200 :   if (DECL_MODE (decl) == BLKmode)
    2220                 :            :     return false;
    2221                 :            : 
    2222                 :            :   /* If -ffloat-store specified, don't put explicit float variables
    2223                 :            :      into registers.  */
    2224                 :            :   /* ??? This should be checked after DECL_ARTIFICIAL, but tree-ssa
    2225                 :            :      propagates values across these stores, and it probably shouldn't.  */
    2226                 :   32683800 :   if (flag_float_store && FLOAT_TYPE_P (TREE_TYPE (decl)))
    2227                 :            :     return false;
    2228                 :            : 
    2229                 :   32678400 :   if (!targetm.calls.allocate_stack_slots_for_args ())
    2230                 :            :     return true;
    2231                 :            : 
    2232                 :            :   /* If we're not interested in tracking debugging information for
    2233                 :            :      this decl, then we can certainly put it in a register.  */
    2234                 :   32678100 :   if (DECL_IGNORED_P (decl))
    2235                 :            :     return true;
    2236                 :            : 
    2237                 :   22000500 :   if (optimize)
    2238                 :            :     return true;
    2239                 :            : 
    2240                 :    3642670 :   if (!DECL_REGISTER (decl))
    2241                 :            :     return false;
    2242                 :            : 
    2243                 :            :   /* When not optimizing, disregard register keyword for types that
    2244                 :            :      could have methods, otherwise the methods won't be callable from
    2245                 :            :      the debugger.  */
    2246                 :      14182 :   if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (decl)))
    2247                 :          2 :     return false;
    2248                 :            : 
    2249                 :            :   return true;
    2250                 :            : }
    2251                 :            : 
    2252                 :            : /* Structures to communicate between the subroutines of assign_parms.
    2253                 :            :    The first holds data persistent across all parameters, the second
    2254                 :            :    is cleared out for each parameter.  */
    2255                 :            : 
    2256                 :            : struct assign_parm_data_all
    2257                 :            : {
    2258                 :            :   /* When INIT_CUMULATIVE_ARGS gets revamped, allocating CUMULATIVE_ARGS
    2259                 :            :      should become a job of the target or otherwise encapsulated.  */
    2260                 :            :   CUMULATIVE_ARGS args_so_far_v;
    2261                 :            :   cumulative_args_t args_so_far;
    2262                 :            :   struct args_size stack_args_size;
    2263                 :            :   tree function_result_decl;
    2264                 :            :   tree orig_fnargs;
    2265                 :            :   rtx_insn *first_conversion_insn;
    2266                 :            :   rtx_insn *last_conversion_insn;
    2267                 :            :   HOST_WIDE_INT pretend_args_size;
    2268                 :            :   HOST_WIDE_INT extra_pretend_bytes;
    2269                 :            :   int reg_parm_stack_space;
    2270                 :            : };
    2271                 :            : 
    2272                 :   11583300 : struct assign_parm_data_one
    2273                 :            : {
    2274                 :            :   tree nominal_type;
    2275                 :            :   function_arg_info arg;
    2276                 :            :   rtx entry_parm;
    2277                 :            :   rtx stack_parm;
    2278                 :            :   machine_mode nominal_mode;
    2279                 :            :   machine_mode passed_mode;
    2280                 :            :   struct locate_and_pad_arg_data locate;
    2281                 :            :   int partial;
    2282                 :            : };
    2283                 :            : 
    2284                 :            : /* A subroutine of assign_parms.  Initialize ALL.  */
    2285                 :            : 
    2286                 :            : static void
    2287                 :    2807800 : assign_parms_initialize_all (struct assign_parm_data_all *all)
    2288                 :            : {
    2289                 :    2807800 :   tree fntype ATTRIBUTE_UNUSED;
    2290                 :            : 
    2291                 :    2807800 :   memset (all, 0, sizeof (*all));
    2292                 :            : 
    2293                 :    2807800 :   fntype = TREE_TYPE (current_function_decl);
    2294                 :            : 
    2295                 :            : #ifdef INIT_CUMULATIVE_INCOMING_ARGS
    2296                 :            :   INIT_CUMULATIVE_INCOMING_ARGS (all->args_so_far_v, fntype, NULL_RTX);
    2297                 :            : #else
    2298                 :    2807800 :   INIT_CUMULATIVE_ARGS (all->args_so_far_v, fntype, NULL_RTX,
    2299                 :            :                         current_function_decl, -1);
    2300                 :            : #endif
    2301                 :    2807800 :   all->args_so_far = pack_cumulative_args (&all->args_so_far_v);
    2302                 :            : 
    2303                 :            : #ifdef INCOMING_REG_PARM_STACK_SPACE
    2304                 :    2807800 :   all->reg_parm_stack_space
    2305                 :    2807800 :     = INCOMING_REG_PARM_STACK_SPACE (current_function_decl);
    2306                 :            : #endif
    2307                 :    2807800 : }
    2308                 :            : 
    2309                 :            : /* If ARGS contains entries with complex types, split the entry into two
    2310                 :            :    entries of the component type.  Return a new list of substitutions are
    2311                 :            :    needed, else the old list.  */
    2312                 :            : 
    2313                 :            : static void
    2314                 :          0 : split_complex_args (vec<tree> *args)
    2315                 :            : {
    2316                 :          0 :   unsigned i;
    2317                 :          0 :   tree p;
    2318                 :            : 
    2319                 :          0 :   FOR_EACH_VEC_ELT (*args, i, p)
    2320                 :            :     {
    2321                 :          0 :       tree type = TREE_TYPE (p);
    2322                 :          0 :       if (TREE_CODE (type) == COMPLEX_TYPE
    2323                 :          0 :           && targetm.calls.split_complex_arg (type))
    2324                 :            :         {
    2325                 :          0 :           tree decl;
    2326                 :          0 :           tree subtype = TREE_TYPE (type);
    2327                 :          0 :           bool addressable = TREE_ADDRESSABLE (p);
    2328                 :            : 
    2329                 :            :           /* Rewrite the PARM_DECL's type with its component.  */
    2330                 :          0 :           p = copy_node (p);
    2331                 :          0 :           TREE_TYPE (p) = subtype;
    2332                 :          0 :           DECL_ARG_TYPE (p) = TREE_TYPE (DECL_ARG_TYPE (p));
    2333                 :          0 :           SET_DECL_MODE (p, VOIDmode);
    2334                 :          0 :           DECL_SIZE (p) = NULL;
    2335                 :          0 :           DECL_SIZE_UNIT (p) = NULL;
    2336                 :            :           /* If this arg must go in memory, put it in a pseudo here.
    2337                 :            :              We can't allow it to go in memory as per normal parms,
    2338                 :            :              because the usual place might not have the imag part
    2339                 :            :              adjacent to the real part.  */
    2340                 :          0 :           DECL_ARTIFICIAL (p) = addressable;
    2341                 :          0 :           DECL_IGNORED_P (p) = addressable;
    2342                 :          0 :           TREE_ADDRESSABLE (p) = 0;
    2343                 :          0 :           layout_decl (p, 0);
    2344                 :          0 :           (*args)[i] = p;
    2345                 :            : 
    2346                 :            :           /* Build a second synthetic decl.  */
    2347                 :          0 :           decl = build_decl (EXPR_LOCATION (p),
    2348                 :            :                              PARM_DECL, NULL_TREE, subtype);
    2349                 :          0 :           DECL_ARG_TYPE (decl) = DECL_ARG_TYPE (p);
    2350                 :          0 :           DECL_ARTIFICIAL (decl) = addressable;
    2351                 :          0 :           DECL_IGNORED_P (decl) = addressable;
    2352                 :          0 :           layout_decl (decl, 0);
    2353                 :          0 :           args->safe_insert (++i, decl);
    2354                 :            :         }
    2355                 :            :     }
    2356                 :          0 : }
    2357                 :            : 
    2358                 :            : /* A subroutine of assign_parms.  Adjust the parameter list to incorporate
    2359                 :            :    the hidden struct return argument, and (abi willing) complex args.
    2360                 :            :    Return the new parameter list.  */
    2361                 :            : 
    2362                 :            : static vec<tree> 
    2363                 :    2807800 : assign_parms_augmented_arg_list (struct assign_parm_data_all *all)
    2364                 :            : {
    2365                 :    2807800 :   tree fndecl = current_function_decl;
    2366                 :    2807800 :   tree fntype = TREE_TYPE (fndecl);
    2367                 :    2807800 :   vec<tree> fnargs = vNULL;
    2368                 :    2807800 :   tree arg;
    2369                 :            : 
    2370                 :    8470590 :   for (arg = DECL_ARGUMENTS (fndecl); arg; arg = DECL_CHAIN (arg))
    2371                 :    5662800 :     fnargs.safe_push (arg);
    2372                 :            : 
    2373                 :    2807800 :   all->orig_fnargs = DECL_ARGUMENTS (fndecl);
    2374                 :            : 
    2375                 :            :   /* If struct value address is treated as the first argument, make it so.  */
    2376                 :    2807800 :   if (aggregate_value_p (DECL_RESULT (fndecl), fndecl)
    2377                 :     128867 :       && ! cfun->returns_pcc_struct
    2378                 :    2936660 :       && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0)
    2379                 :            :     {
    2380                 :     128867 :       tree type = build_pointer_type (TREE_TYPE (fntype));
    2381                 :     128867 :       tree decl;
    2382                 :            : 
    2383                 :     128867 :       decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
    2384                 :            :                          PARM_DECL, get_identifier (".result_ptr"), type);
    2385                 :     128867 :       DECL_ARG_TYPE (decl) = type;
    2386                 :     128867 :       DECL_ARTIFICIAL (decl) = 1;
    2387                 :     128867 :       DECL_NAMELESS (decl) = 1;
    2388                 :     128867 :       TREE_CONSTANT (decl) = 1;
    2389                 :            :       /* We don't set DECL_IGNORED_P or DECL_REGISTER here.  If this
    2390                 :            :          changes, the end of the RESULT_DECL handling block in
    2391                 :            :          use_register_for_decl must be adjusted to match.  */
    2392                 :            : 
    2393                 :     128867 :       DECL_CHAIN (decl) = all->orig_fnargs;
    2394                 :     128867 :       all->orig_fnargs = decl;
    2395                 :     128867 :       fnargs.safe_insert (0, decl);
    2396                 :            : 
    2397                 :     128867 :       all->function_result_decl = decl;
    2398                 :            :     }
    2399                 :            : 
    2400                 :            :   /* If the target wants to split complex arguments into scalars, do so.  */
    2401                 :    2807800 :   if (targetm.calls.split_complex_arg)
    2402                 :          0 :     split_complex_args (&fnargs);
    2403                 :            : 
    2404                 :    2807800 :   return fnargs;
    2405                 :            : }
    2406                 :            : 
    2407                 :            : /* A subroutine of assign_parms.  Examine PARM and pull out type and mode
    2408                 :            :    data for the parameter.  Incorporate ABI specifics such as pass-by-
    2409                 :            :    reference and type promotion.  */
    2410                 :            : 
    2411                 :            : static void
    2412                 :    5791660 : assign_parm_find_data_types (struct assign_parm_data_all *all, tree parm,
    2413                 :            :                              struct assign_parm_data_one *data)
    2414                 :            : {
    2415                 :    5791660 :   int unsignedp;
    2416                 :            : 
    2417                 :    5791660 :   *data = assign_parm_data_one ();
    2418                 :            : 
    2419                 :            :   /* NAMED_ARG is a misnomer.  We really mean 'non-variadic'. */
    2420                 :    5791660 :   if (!cfun->stdarg)
    2421                 :    5723680 :     data->arg.named = 1;  /* No variadic parms.  */
    2422                 :      67979 :   else if (DECL_CHAIN (parm))
    2423                 :      35906 :     data->arg.named = 1;  /* Not the last non-variadic parm. */
    2424                 :      32073 :   else if (targetm.calls.strict_argument_naming (all->args_so_far))
    2425                 :      32073 :     data->arg.named = 1;  /* Only variadic ones are unnamed.  */
    2426                 :            :   else
    2427                 :          0 :     data->arg.named = 0;  /* Treat as variadic.  */
    2428                 :            : 
    2429                 :    5791660 :   data->nominal_type = TREE_TYPE (parm);
    2430                 :    5791660 :   data->arg.type = DECL_ARG_TYPE (parm);
    2431                 :            : 
    2432                 :            :   /* Look out for errors propagating this far.  Also, if the parameter's
    2433                 :            :      type is void then its value doesn't matter.  */
    2434                 :    5791660 :   if (TREE_TYPE (parm) == error_mark_node
    2435                 :            :       /* This can happen after weird syntax errors
    2436                 :            :          or if an enum type is defined among the parms.  */
    2437                 :    5791570 :       || TREE_CODE (parm) != PARM_DECL
    2438                 :    5791570 :       || data->arg.type == NULL
    2439                 :   11583200 :       || VOID_TYPE_P (data->nominal_type))
    2440                 :            :     {
    2441                 :         93 :       data->nominal_type = data->arg.type = void_type_node;
    2442                 :         93 :       data->nominal_mode = data->passed_mode = data->arg.mode = VOIDmode;
    2443                 :         93 :       return;
    2444                 :            :     }
    2445                 :            : 
    2446                 :            :   /* Find mode of arg as it is passed, and mode of arg as it should be
    2447                 :            :      during execution of this function.  */
    2448                 :    5791570 :   data->passed_mode = data->arg.mode = TYPE_MODE (data->arg.type);
    2449                 :    5791570 :   data->nominal_mode = TYPE_MODE (data->nominal_type);
    2450                 :            : 
    2451                 :            :   /* If the parm is to be passed as a transparent union or record, use the
    2452                 :            :      type of the first field for the tests below.  We have already verified
    2453                 :            :      that the modes are the same.  */
    2454                 :    5791570 :   if (RECORD_OR_UNION_TYPE_P (data->arg.type)
    2455                 :    5791570 :       && TYPE_TRANSPARENT_AGGR (data->arg.type))
    2456                 :       1448 :     data->arg.type = TREE_TYPE (first_field (data->arg.type));
    2457                 :            : 
    2458                 :            :   /* See if this arg was passed by invisible reference.  */
    2459                 :    5791570 :   if (apply_pass_by_reference_rules (&all->args_so_far_v, data->arg))
    2460                 :            :     {
    2461                 :        105 :       data->nominal_type = data->arg.type;
    2462                 :        105 :       data->passed_mode = data->nominal_mode = data->arg.mode;
    2463                 :            :     }
    2464                 :            : 
    2465                 :            :   /* Find mode as it is passed by the ABI.  */
    2466                 :    5791570 :   unsignedp = TYPE_UNSIGNED (data->arg.type);
    2467                 :    5791570 :   data->arg.mode
    2468                 :    5791570 :     = promote_function_mode (data->arg.type, data->arg.mode, &unsignedp,
    2469                 :    5791570 :                              TREE_TYPE (current_function_decl), 0);
    2470                 :            : }
    2471                 :            : 
    2472                 :            : /* A subroutine of assign_parms.  Invoke setup_incoming_varargs.  */
    2473                 :            : 
    2474                 :            : static void
    2475                 :      15984 : assign_parms_setup_varargs (struct assign_parm_data_all *all,
    2476                 :            :                             struct assign_parm_data_one *data, bool no_rtl)
    2477                 :            : {
    2478                 :      15984 :   int varargs_pretend_bytes = 0;
    2479                 :            : 
    2480                 :      15984 :   function_arg_info last_named_arg = data->arg;
    2481                 :      15984 :   last_named_arg.named = true;
    2482                 :          0 :   targetm.calls.setup_incoming_varargs (all->args_so_far, last_named_arg,
    2483                 :            :                                         &varargs_pretend_bytes, no_rtl);
    2484                 :            : 
    2485                 :            :   /* If the back-end has requested extra stack space, record how much is
    2486                 :            :      needed.  Do not change pretend_args_size otherwise since it may be
    2487                 :            :      nonzero from an earlier partial argument.  */
    2488                 :      15984 :   if (varargs_pretend_bytes > 0)
    2489                 :          0 :     all->pretend_args_size = varargs_pretend_bytes;
    2490                 :      15984 : }
    2491                 :            : 
    2492                 :            : /* A subroutine of assign_parms.  Set DATA->ENTRY_PARM corresponding to
    2493                 :            :    the incoming location of the current parameter.  */
    2494                 :            : 
    2495                 :            : static void
    2496                 :    2015500 : assign_parm_find_entry_rtl (struct assign_parm_data_all *all,
    2497                 :            :                             struct assign_parm_data_one *data)
    2498                 :            : {
    2499                 :    2015500 :   HOST_WIDE_INT pretend_bytes = 0;
    2500                 :    2015500 :   rtx entry_parm;
    2501                 :    2015500 :   bool in_regs;
    2502                 :            : 
    2503                 :    2015500 :   if (data->arg.mode == VOIDmode)
    2504                 :            :     {
    2505                 :          0 :       data->entry_parm = data->stack_parm = const0_rtx;
    2506                 :          0 :       return;
    2507                 :            :     }
    2508                 :            : 
    2509                 :    2015500 :   targetm.calls.warn_parameter_passing_abi (all->args_so_far,
    2510                 :            :                                             data->arg.type);
    2511                 :            : 
    2512                 :    4031000 :   entry_parm = targetm.calls.function_incoming_arg (all->args_so_far,
    2513                 :    2015500 :                                                     data->arg);
    2514                 :    2015500 :   if (entry_parm == 0)
    2515                 :     857789 :     data->arg.mode = data->passed_mode;
    2516                 :            : 
    2517                 :            :   /* Determine parm's home in the stack, in case it arrives in the stack
    2518                 :            :      or we should pretend it did.  Compute the stack position and rtx where
    2519                 :            :      the argument arrives and its size.
    2520                 :            : 
    2521                 :            :      There is one complexity here:  If this was a parameter that would
    2522                 :            :      have been passed in registers, but wasn't only because it is
    2523                 :            :      __builtin_va_alist, we want locate_and_pad_parm to treat it as if
    2524                 :            :      it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
    2525                 :            :      In this case, we call FUNCTION_ARG with NAMED set to 1 instead of 0
    2526                 :            :      as it was the previous time.  */
    2527                 :    2015500 :   in_regs = (entry_parm != 0);
    2528                 :            : #ifdef STACK_PARMS_IN_REG_PARM_AREA
    2529                 :            :   in_regs = true;
    2530                 :            : #endif
    2531                 :    2015500 :   if (!in_regs && !data->arg.named)
    2532                 :            :     {
    2533                 :          0 :       if (targetm.calls.pretend_outgoing_varargs_named (all->args_so_far))
    2534                 :            :         {
    2535                 :          0 :           rtx tem;
    2536                 :          0 :           function_arg_info named_arg = data->arg;
    2537                 :          0 :           named_arg.named = true;
    2538                 :          0 :           tem = targetm.calls.function_incoming_arg (all->args_so_far,
    2539                 :            :                                                      named_arg);
    2540                 :          0 :           in_regs = tem != NULL;
    2541                 :            :         }
    2542                 :            :     }
    2543                 :            : 
    2544                 :            :   /* If this parameter was passed both in registers and in the stack, use
    2545                 :            :      the copy on the stack.  */
    2546                 :    2015500 :   if (targetm.calls.must_pass_in_stack (data->arg))
    2547                 :            :     entry_parm = 0;
    2548                 :            : 
    2549                 :    2015500 :   if (entry_parm)
    2550                 :            :     {
    2551                 :    1157710 :       int partial;
    2552                 :            : 
    2553                 :    1157710 :       partial = targetm.calls.arg_partial_bytes (all->args_so_far, data->arg);
    2554                 :    1157710 :       data->partial = partial;
    2555                 :            : 
    2556                 :            :       /* The caller might already have allocated stack space for the
    2557                 :            :          register parameters.  */
    2558                 :    1157710 :       if (partial != 0 && all->reg_parm_stack_space == 0)
    2559                 :            :         {
    2560                 :            :           /* Part of this argument is passed in registers and part
    2561                 :            :              is passed on the stack.  Ask the prologue code to extend
    2562                 :            :              the stack part so that we can recreate the full value.
    2563                 :            : 
    2564                 :            :              PRETEND_BYTES is the size of the registers we need to store.
    2565                 :            :              CURRENT_FUNCTION_PRETEND_ARGS_SIZE is the amount of extra
    2566                 :            :              stack space that the prologue should allocate.
    2567                 :            : 
    2568                 :            :              Internally, gcc assumes that the argument pointer is aligned
    2569                 :            :              to STACK_BOUNDARY bits.  This is used both for alignment
    2570                 :            :              optimizations (see init_emit) and to locate arguments that are
    2571                 :            :              aligned to more than PARM_BOUNDARY bits.  We must preserve this
    2572                 :            :              invariant by rounding CURRENT_FUNCTION_PRETEND_ARGS_SIZE up to
    2573                 :            :              a stack boundary.  */
    2574                 :            : 
    2575                 :            :           /* We assume at most one partial arg, and it must be the first
    2576                 :            :              argument on the stack.  */
    2577                 :          0 :           gcc_assert (!all->extra_pretend_bytes && !all->pretend_args_size);
    2578                 :            : 
    2579                 :          0 :           pretend_bytes = partial;
    2580                 :          0 :           all->pretend_args_size = CEIL_ROUND (pretend_bytes, STACK_BYTES);
    2581                 :            : 
    2582                 :            :           /* We want to align relative to the actual stack pointer, so
    2583                 :            :              don't include this in the stack size until later.  */
    2584                 :          0 :           all->extra_pretend_bytes = all->pretend_args_size;
    2585                 :            :         }
    2586                 :            :     }
    2587                 :            : 
    2588                 :    2015500 :   locate_and_pad_parm (data->arg.mode, data->arg.type, in_regs,
    2589                 :            :                        all->reg_parm_stack_space,
    2590                 :            :                        entry_parm ? data->partial : 0, current_function_decl,
    2591                 :            :                        &all->stack_args_size, &data->locate);
    2592                 :            : 
    2593                 :            :   /* Update parm_stack_boundary if this parameter is passed in the
    2594                 :            :      stack.  */
    2595                 :    2015500 :   if (!in_regs && crtl->parm_stack_boundary < data->locate.boundary)
    2596                 :     128664 :     crtl->parm_stack_boundary = data->locate.boundary;
    2597                 :            : 
    2598                 :            :   /* Adjust offsets to include the pretend args.  */
    2599                 :    2015500 :   pretend_bytes = all->extra_pretend_bytes - pretend_bytes;
    2600                 :    2015500 :   data->locate.slot_offset.constant += pretend_bytes;
    2601                 :    2015500 :   data->locate.offset.constant += pretend_bytes;
    2602                 :            : 
    2603                 :    2015500 :   data->entry_parm = entry_parm;
    2604                 :            : }
    2605                 :            : 
    2606                 :            : /* A subroutine of assign_parms.  If there is actually space on the stack
    2607                 :            :    for this parm, count it in stack_args_size and return true.  */
    2608                 :            : 
    2609                 :            : static bool
    2610                 :    2015500 : assign_parm_is_stack_parm (struct assign_parm_data_all *all,
    2611                 :            :                            struct assign_parm_data_one *data)
    2612                 :            : {
    2613                 :            :   /* Trivially true if we've no incoming register.  */
    2614                 :    2015500 :   if (data->entry_parm == NULL)
    2615                 :            :     ;
    2616                 :            :   /* Also true if we're partially in registers and partially not,
    2617                 :            :      since we've arranged to drop the entire argument on the stack.  */
    2618                 :    1157710 :   else if (data->partial != 0)
    2619                 :            :     ;
    2620                 :            :   /* Also true if the target says that it's passed in both registers
    2621                 :            :      and on the stack.  */
    2622                 :    1157710 :   else if (GET_CODE (data->entry_parm) == PARALLEL
    2623                 :      35051 :            && XEXP (XVECEXP (data->entry_parm, 0, 0), 0) == NULL_RTX)
    2624                 :            :     ;
    2625                 :            :   /* Also true if the target says that there's stack allocated for
    2626                 :            :      all register parameters.  */
    2627                 :    1157710 :   else if (all->reg_parm_stack_space > 0)
    2628                 :            :     ;
    2629                 :            :   /* Otherwise, no, this parameter has no ABI defined stack slot.  */
    2630                 :            :   else
    2631                 :            :     return false;
    2632                 :            : 
    2633                 :     886055 :   all->stack_args_size.constant += data->locate.size.constant;
    2634                 :     886055 :   if (data->locate.size.var)
    2635                 :          0 :     ADD_PARM_SIZE (all->stack_args_size, data->locate.size.var);
    2636                 :            : 
    2637                 :            :   return true;
    2638                 :            : }
    2639                 :            : 
    2640                 :            : /* A subroutine of assign_parms.  Given that this parameter is allocated
    2641                 :            :    stack space by the ABI, find it.  */
    2642                 :            : 
    2643                 :            : static void
    2644                 :     886055 : assign_parm_find_stack_rtl (tree parm, struct assign_parm_data_one *data)
    2645                 :            : {
    2646                 :     886055 :   rtx offset_rtx, stack_parm;
    2647                 :     886055 :   unsigned int align, boundary;
    2648                 :            : 
    2649                 :            :   /* If we're passing this arg using a reg, make its stack home the
    2650                 :            :      aligned stack slot.  */
    2651                 :     886055 :   if (data->entry_parm)
    2652                 :      28266 :     offset_rtx = ARGS_SIZE_RTX (data->locate.slot_offset);
    2653                 :            :   else
    2654                 :    1040320 :     offset_rtx = ARGS_SIZE_RTX (data->locate.offset);
    2655                 :            : 
    2656                 :     886055 :   stack_parm = crtl->args.internal_arg_pointer;
    2657                 :     886055 :   if (offset_rtx != const0_rtx)
    2658                 :     847860 :     stack_parm = gen_rtx_PLUS (Pmode, stack_parm, offset_rtx);
    2659                 :     886055 :   stack_parm = gen_rtx_MEM (data->arg.mode, stack_parm);
    2660                 :            : 
    2661                 :     886055 :   if (!data->arg.pass_by_reference)
    2662                 :            :     {
    2663                 :     886037 :       set_mem_attributes (stack_parm, parm, 1);
    2664                 :            :       /* set_mem_attributes could set MEM_SIZE to the passed mode's size,
    2665                 :            :          while promoted mode's size is needed.  */
    2666                 :     886037 :       if (data->arg.mode != BLKmode
    2667                 :     886037 :           && data->arg.mode != DECL_MODE (parm))
    2668                 :            :         {
    2669                 :       6140 :           set_mem_size (stack_parm, GET_MODE_SIZE (data->arg.mode));
    2670                 :       3070 :           if (MEM_EXPR (stack_parm) && MEM_OFFSET_KNOWN_P (stack_parm))
    2671                 :            :             {
    2672                 :       9210 :               poly_int64 offset = subreg_lowpart_offset (DECL_MODE (parm),
    2673                 :       3070 :                                                          data->arg.mode);
    2674                 :       3070 :               if (maybe_ne (offset, 0))
    2675                 :          0 :                 set_mem_offset (stack_parm, MEM_OFFSET (stack_parm) - offset);
    2676                 :            :             }
    2677                 :            :         }
    2678                 :            :     }
    2679                 :            : 
    2680                 :     886055 :   boundary = data->locate.boundary;
    2681                 :     886055 :   align = BITS_PER_UNIT;
    2682                 :            : 
    2683                 :            :   /* If we're padding upward, we know that the alignment of the slot
    2684                 :            :      is TARGET_FUNCTION_ARG_BOUNDARY.  If we're using slot_offset, we're
    2685                 :            :      intentionally forcing upward padding.  Otherwise we have to come
    2686                 :            :      up with a guess at the alignment based on OFFSET_RTX.  */
    2687                 :     886055 :   poly_int64 offset;
    2688                 :     886055 :   if (data->locate.where_pad == PAD_NONE || data->entry_parm)
    2689                 :            :     align = boundary;
    2690                 :     857789 :   else if (data->locate.where_pad == PAD_UPWARD)
    2691                 :            :     {
    2692                 :     857789 :       align = boundary;
    2693                 :            :       /* If the argument offset is actually more aligned than the nominal
    2694                 :            :          stack slot boundary, take advantage of that excess alignment.
    2695                 :            :          Don't make any assumptions if STACK_POINTER_OFFSET is in use.  */
    2696                 :     857789 :       if (poly_int_rtx_p (offset_rtx, &offset)
    2697                 :            :           && known_eq (STACK_POINTER_OFFSET, 0))
    2698                 :            :         {
    2699                 :     857789 :           unsigned int offset_align = known_alignment (offset) * BITS_PER_UNIT;
    2700                 :     954499 :           if (offset_align == 0 || offset_align > STACK_BOUNDARY)
    2701                 :     477331 :             offset_align = STACK_BOUNDARY;
    2702                 :     857789 :           align = MAX (align, offset_align);
    2703                 :            :         }
    2704                 :            :     }
    2705                 :          0 :   else if (poly_int_rtx_p (offset_rtx, &offset))
    2706                 :            :     {
    2707                 :          0 :       align = least_bit_hwi (boundary);
    2708                 :          0 :       unsigned int offset_align = known_alignment (offset) * BITS_PER_UNIT;
    2709                 :          0 :       if (offset_align != 0)
    2710                 :          0 :         align = MIN (align, offset_align);
    2711                 :            :     }
    2712                 :     886055 :   set_mem_align (stack_parm, align);
    2713                 :            : 
    2714                 :     886055 :   if (data->entry_parm)
    2715                 :      28266 :     set_reg_attrs_for_parm (data->entry_parm, stack_parm);
    2716                 :            : 
    2717                 :     886055 :   data->stack_parm = stack_parm;
    2718                 :     886055 : }
    2719                 :            : 
    2720                 :            : /* A subroutine of assign_parms.  Adjust DATA->ENTRY_RTL such that it's
    2721                 :            :    always valid and contiguous.  */
    2722                 :            : 
    2723                 :            : static void
    2724                 :     886055 : assign_parm_adjust_entry_rtl (struct assign_parm_data_one *data)
    2725                 :            : {
    2726                 :     886055 :   rtx entry_parm = data->entry_parm;
    2727                 :     886055 :   rtx stack_parm = data->stack_parm;
    2728                 :            : 
    2729                 :            :   /* If this parm was passed part in regs and part in memory, pretend it
    2730                 :            :      arrived entirely in memory by pushing the register-part onto the stack.
    2731                 :            :      In the special case of a DImode or DFmode that is split, we could put
    2732                 :            :      it together in a pseudoreg directly, but for now that's not worth
    2733                 :            :      bothering with.  */
    2734                 :     886055 :   if (data->partial != 0)
    2735                 :            :     {
    2736                 :            :       /* Handle calls that pass values in multiple non-contiguous
    2737                 :            :          locations.  The Irix 6 ABI has examples of this.  */
    2738                 :          0 :       if (GET_CODE (entry_parm) == PARALLEL)
    2739                 :          0 :         emit_group_store (validize_mem (copy_rtx (stack_parm)), entry_parm,
    2740                 :          0 :                           data->arg.type, int_size_in_bytes (data->arg.type));
    2741                 :            :       else
    2742                 :            :         {
    2743                 :          0 :           gcc_assert (data->partial % UNITS_PER_WORD == 0);
    2744                 :          0 :           move_block_from_reg (REGNO (entry_parm),
    2745                 :            :                                validize_mem (copy_rtx (stack_parm)),
    2746                 :            :                                data->partial / UNITS_PER_WORD);
    2747                 :            :         }
    2748                 :            : 
    2749                 :            :       entry_parm = stack_parm;
    2750                 :            :     }
    2751                 :            : 
    2752                 :            :   /* If we didn't decide this parm came in a register, by default it came
    2753                 :            :      on the stack.  */
    2754                 :     886055 :   else if (entry_parm == NULL)
    2755                 :            :     entry_parm = stack_parm;
    2756                 :            : 
    2757                 :            :   /* When an argument is passed in multiple locations, we can't make use
    2758                 :            :      of this information, but we can save some copying if the whole argument
    2759                 :            :      is passed in a single register.  */
    2760                 :      28266 :   else if (GET_CODE (entry_parm) == PARALLEL
    2761                 :          0 :            && data->nominal_mode != BLKmode
    2762                 :          0 :            && data->passed_mode != BLKmode)
    2763                 :            :     {
    2764                 :          0 :       size_t i, len = XVECLEN (entry_parm, 0);
    2765                 :            : 
    2766                 :          0 :       for (i = 0; i < len; i++)
    2767                 :          0 :         if (XEXP (XVECEXP (entry_parm, 0, i), 0) != NULL_RTX
    2768                 :          0 :             && REG_P (XEXP (XVECEXP (entry_parm, 0, i), 0))
    2769                 :          0 :             && (GET_MODE (XEXP (XVECEXP (entry_parm, 0, i), 0))
    2770                 :            :                 == data->passed_mode)
    2771                 :          0 :             && INTVAL (XEXP (XVECEXP (entry_parm, 0, i), 1)) == 0)
    2772                 :            :           {
    2773                 :            :             entry_parm = XEXP (XVECEXP (entry_parm, 0, i), 0);
    2774                 :            :             break;
    2775                 :            :           }
    2776                 :            :     }
    2777                 :            : 
    2778                 :     886055 :   data->entry_parm = entry_parm;
    2779                 :     886055 : }
    2780                 :            : 
    2781                 :            : /* A subroutine of assign_parms.  Reconstitute any values which were
    2782                 :            :    passed in multiple registers and would fit in a single register.  */
    2783                 :            : 
    2784                 :            : static void
    2785                 :    1965940 : assign_parm_remove_parallels (struct assign_parm_data_one *data)
    2786                 :            : {
    2787                 :    1965940 :   rtx entry_parm = data->entry_parm;
    2788                 :            : 
    2789                 :            :   /* Convert the PARALLEL to a REG of the same mode as the parallel.
    2790                 :            :      This can be done with register operations rather than on the
    2791                 :            :      stack, even if we will store the reconstituted parameter on the
    2792                 :            :      stack later.  */
    2793                 :    1965940 :   if (GET_CODE (entry_parm) == PARALLEL && GET_MODE (entry_parm) != BLKmode)
    2794                 :            :     {
    2795                 :      32946 :       rtx parmreg = gen_reg_rtx (GET_MODE (entry_parm));
    2796                 :      32946 :       emit_group_store (parmreg, entry_parm, data->arg.type,
    2797                 :      65892 :                         GET_MODE_SIZE (GET_MODE (entry_parm)));
    2798                 :      32946 :       entry_parm = parmreg;
    2799                 :            :     }
    2800                 :            : 
    2801                 :    1965940 :   data->entry_parm = entry_parm;
    2802                 :    1965940 : }
    2803                 :            : 
    2804                 :            : /* A subroutine of assign_parms.  Adjust DATA->STACK_RTL such that it's
    2805                 :            :    always valid and properly aligned.  */
    2806                 :            : 
    2807                 :            : static void
    2808                 :    2015500 : assign_parm_adjust_stack_rtl (struct assign_parm_data_one *data)
    2809                 :            : {
    2810                 :    2015500 :   rtx stack_parm = data->stack_parm;
    2811                 :            : 
    2812                 :            :   /* If we can't trust the parm stack slot to be aligned enough for its
    2813                 :            :      ultimate type, don't use that slot after entry.  We'll make another
    2814                 :            :      stack slot, if we need one.  */
    2815                 :    2015500 :   if (stack_parm
    2816                 :    2015500 :       && ((GET_MODE_ALIGNMENT (data->nominal_mode) > MEM_ALIGN (stack_parm)
    2817                 :      20493 :            && ((optab_handler (movmisalign_optab, data->nominal_mode)
    2818                 :            :                 != CODE_FOR_nothing)
    2819                 :      40978 :                || targetm.slow_unaligned_access (data->nominal_mode,
    2820                 :      20489 :                                                  MEM_ALIGN (stack_parm))))
    2821                 :     885040 :           || (data->nominal_type
    2822                 :    1770080 :               && TYPE_ALIGN (data->nominal_type) > MEM_ALIGN (stack_parm)
    2823                 :       3534 :               && MEM_ALIGN (stack_parm) < PREFERRED_STACK_BOUNDARY)))
    2824                 :            :     stack_parm = NULL;
    2825                 :            : 
    2826                 :            :   /* If parm was passed in memory, and we need to convert it on entry,
    2827                 :            :      don't store it back in that same slot.  */
    2828                 :    2011960 :   else if (data->entry_parm == stack_parm
    2829                 :     853240 :            && data->nominal_mode != BLKmode
    2830                 :     806544 :            && data->nominal_mode != data->passed_mode)
    2831                 :            :     stack_parm = NULL;
    2832                 :            : 
    2833                 :            :   /* If stack protection is in effect for this function, don't leave any
    2834                 :            :      pointers in their passed stack slots.  */
    2835                 :    2008900 :   else if (crtl->stack_protect_guard
    2836                 :         96 :            && (flag_stack_protect == 2
    2837                 :         87 :                || data->arg.pass_by_reference
    2838                 :         87 :                || POINTER_TYPE_P (data->nominal_type)))
    2839                 :         55 :     stack_parm = NULL;
    2840                 :            : 
    2841                 :    2015500 :   data->stack_parm = stack_parm;
    2842                 :    2015500 : }
    2843                 :            : 
    2844                 :            : /* A subroutine of assign_parms.  Return true if the current parameter
    2845                 :            :    should be stored as a BLKmode in the current frame.  */
    2846                 :            : 
    2847                 :            : static bool
    2848                 :    2015500 : assign_parm_setup_block_p (struct assign_parm_data_one *data)
    2849                 :            : {
    2850                 :          0 :   if (data->nominal_mode == BLKmode)
    2851                 :            :     return true;
    2852                 :    1965940 :   if (GET_MODE (data->entry_parm) == BLKmode)
    2853                 :          0 :     return true;
    2854                 :            : 
    2855                 :            : #ifdef BLOCK_REG_PADDING
    2856                 :            :   /* Only assign_parm_setup_block knows how to deal with register arguments
    2857                 :            :      that are padded at the least significant end.  */
    2858                 :            :   if (REG_P (data->entry_parm)
    2859                 :            :       && known_lt (GET_MODE_SIZE (data->arg.mode), UNITS_PER_WORD)
    2860                 :            :       && (BLOCK_REG_PADDING (data->passed_mode, data->arg.type, 1)
    2861                 :            :           == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
    2862                 :            :     return true;
    2863                 :            : #endif
    2864                 :            : 
    2865                 :            :   return false;
    2866                 :            : }
    2867                 :            : 
    2868                 :            : /* A subroutine of assign_parms.  Arrange for the parameter to be
    2869                 :            :    present and valid in DATA->STACK_RTL.  */
    2870                 :            : 
    2871                 :            : static void
    2872                 :      49565 : assign_parm_setup_block (struct assign_parm_data_all *all,
    2873                 :            :                          tree parm, struct assign_parm_data_one *data)
    2874                 :            : {
    2875                 :      49565 :   rtx entry_parm = data->entry_parm;
    2876                 :      49565 :   rtx stack_parm = data->stack_parm;
    2877                 :      49565 :   rtx target_reg = NULL_RTX;
    2878                 :      49565 :   bool in_conversion_seq = false;
    2879                 :      49565 :   HOST_WIDE_INT size;
    2880                 :      49565 :   HOST_WIDE_INT size_stored;
    2881                 :            : 
    2882                 :      49565 :   if (GET_CODE (entry_parm) == PARALLEL)
    2883                 :       2105 :     entry_parm = emit_group_move_into_temps (entry_parm);
    2884                 :            : 
    2885                 :            :   /* If we want the parameter in a pseudo, don't use a stack slot.  */
    2886                 :      49565 :   if (is_gimple_reg (parm) && use_register_for_decl (parm))
    2887                 :            :     {
    2888                 :          0 :       tree def = ssa_default_def (cfun, parm);
    2889                 :          0 :       gcc_assert (def);
    2890                 :          0 :       machine_mode mode = promote_ssa_mode (def, NULL);
    2891                 :          0 :       rtx reg = gen_reg_rtx (mode);
    2892                 :          0 :       if (GET_CODE (reg) != CONCAT)
    2893                 :            :         stack_parm = reg;
    2894                 :            :       else
    2895                 :            :         {
    2896                 :          0 :           target_reg = reg;
    2897                 :            :           /* Avoid allocating a stack slot, if there isn't one
    2898                 :            :              preallocated by the ABI.  It might seem like we should
    2899                 :            :              always prefer a pseudo, but converting between
    2900                 :            :              floating-point and integer modes goes through the stack
    2901                 :            :              on various machines, so it's better to use the reserved
    2902                 :            :              stack slot than to risk wasting it and allocating more
    2903                 :            :              for the conversion.  */
    2904                 :          0 :           if (stack_parm == NULL_RTX)
    2905                 :            :             {
    2906                 :          0 :               int save = generating_concat_p;
    2907                 :          0 :               generating_concat_p = 0;
    2908                 :          0 :               stack_parm = gen_reg_rtx (mode);
    2909                 :          0 :               generating_concat_p = save;
    2910                 :            :             }
    2911                 :            :         }
    2912                 :          0 :       data->stack_parm = NULL;
    2913                 :            :     }
    2914                 :            : 
    2915                 :      49565 :   size = int_size_in_bytes (data->arg.type);
    2916                 :      60462 :   size_stored = CEIL_ROUND (size, UNITS_PER_WORD);
    2917                 :      49565 :   if (stack_parm == 0)
    2918                 :            :     {
    2919                 :       2871 :       HOST_WIDE_INT parm_align
    2920                 :            :         = (STRICT_ALIGNMENT
    2921                 :       2871 :            ? MAX (DECL_ALIGN (parm), BITS_PER_WORD) : DECL_ALIGN (parm));
    2922                 :            : 
    2923                 :       2871 :       SET_DECL_ALIGN (parm, parm_align);
    2924                 :       2871 :       if (DECL_ALIGN (parm) > MAX_SUPPORTED_STACK_ALIGNMENT)
    2925                 :            :         {
    2926                 :          0 :           rtx allocsize = gen_int_mode (size_stored, Pmode);
    2927                 :          0 :           get_dynamic_stack_size (&allocsize, 0, DECL_ALIGN (parm), NULL);
    2928                 :          0 :           stack_parm = assign_stack_local (BLKmode, UINTVAL (allocsize),
    2929                 :            :                                            MAX_SUPPORTED_STACK_ALIGNMENT);
    2930                 :          0 :           rtx addr = align_dynamic_address (XEXP (stack_parm, 0),
    2931                 :          0 :                                             DECL_ALIGN (parm));
    2932                 :          0 :           mark_reg_pointer (addr, DECL_ALIGN (parm));
    2933                 :          0 :           stack_parm = gen_rtx_MEM (GET_MODE (stack_parm), addr);
    2934                 :          0 :           MEM_NOTRAP_P (stack_parm) = 1;
    2935                 :            :         }
    2936                 :            :       else
    2937                 :       5742 :         stack_parm = assign_stack_local (BLKmode, size_stored,
    2938                 :       2871 :                                          DECL_ALIGN (parm));
    2939                 :       5742 :       if (known_eq (GET_MODE_SIZE (GET_MODE (entry_parm)), size))
    2940                 :         52 :         PUT_MODE (stack_parm, GET_MODE (entry_parm));
    2941                 :       2871 :       set_mem_attributes (stack_parm, parm, 1);
    2942                 :            :     }
    2943                 :            : 
    2944                 :            :   /* If a BLKmode arrives in registers, copy it to a stack slot.  Handle
    2945                 :            :      calls that pass values in multiple non-contiguous locations.  */
    2946                 :      49565 :   if (REG_P (entry_parm) || GET_CODE (entry_parm) == PARALLEL)
    2947                 :            :     {
    2948                 :       2592 :       rtx mem;
    2949                 :            : 
    2950                 :            :       /* Note that we will be storing an integral number of words.
    2951                 :            :          So we have to be careful to ensure that we allocate an
    2952                 :            :          integral number of words.  We do this above when we call
    2953                 :            :          assign_stack_local if space was not allocated in the argument
    2954                 :            :          list.  If it was, this will not work if PARM_BOUNDARY is not
    2955                 :            :          a multiple of BITS_PER_WORD.  It isn't clear how to fix this
    2956                 :            :          if it becomes a problem.  Exception is when BLKmode arrives
    2957                 :            :          with arguments not conforming to word_mode.  */
    2958                 :            : 
    2959                 :       2592 :       if (data->stack_parm == 0)
    2960                 :            :         ;
    2961                 :            :       else if (GET_CODE (entry_parm) == PARALLEL)
    2962                 :            :         ;
    2963                 :            :       else
    2964                 :       2592 :         gcc_assert (!size || !(PARM_BOUNDARY % BITS_PER_WORD));
    2965                 :            : 
    2966                 :       2592 :       mem = validize_mem (copy_rtx (stack_parm));
    2967                 :            : 
    2968                 :            :       /* Handle values in multiple non-contiguous locations.  */
    2969                 :       2592 :       if (GET_CODE (entry_parm) == PARALLEL && !MEM_P (mem))
    2970                 :          0 :         emit_group_store (mem, entry_parm, data->arg.type, size);
    2971                 :       2592 :       else if (GET_CODE (entry_parm) == PARALLEL)
    2972                 :            :         {
    2973                 :       2105 :           push_to_sequence2 (all->first_conversion_insn,
    2974                 :            :                              all->last_conversion_insn);
    2975                 :       2105 :           emit_group_store (mem, entry_parm, data->arg.type, size);
    2976                 :       2105 :           all->first_conversion_insn = get_insns ();
    2977                 :       2105 :           all->last_conversion_insn = get_last_insn ();
    2978                 :       2105 :           end_sequence ();
    2979                 :       2105 :           in_conversion_seq = true;
    2980                 :            :         }
    2981                 :            : 
    2982                 :        487 :       else if (size == 0)
    2983                 :            :         ;
    2984                 :            : 
    2985                 :            :       /* If SIZE is that of a mode no bigger than a word, just use
    2986                 :            :          that mode's store operation.  */
    2987                 :        485 :       else if (size <= UNITS_PER_WORD)
    2988                 :            :         {
    2989                 :        485 :           unsigned int bits = size * BITS_PER_UNIT;
    2990                 :        970 :           machine_mode mode = int_mode_for_size (bits, 0).else_blk ();
    2991                 :            : 
    2992                 :        485 :           if (mode != BLKmode
    2993                 :            : #ifdef BLOCK_REG_PADDING
    2994                 :            :               && (size == UNITS_PER_WORD
    2995                 :            :                   || (BLOCK_REG_PADDING (mode, data->arg.type, 1)
    2996                 :            :                       != (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
    2997                 :            : #endif
    2998                 :            :               )
    2999                 :            :             {
    3000                 :         70 :               rtx reg;
    3001                 :            : 
    3002                 :            :               /* We are really truncating a word_mode value containing
    3003                 :            :                  SIZE bytes into a value of mode MODE.  If such an
    3004                 :            :                  operation requires no actual instructions, we can refer
    3005                 :            :                  to the value directly in mode MODE, otherwise we must
    3006                 :            :                  start with the register in word_mode and explicitly
    3007                 :            :                  convert it.  */
    3008                 :         70 :               if (targetm.truly_noop_truncation (size * BITS_PER_UNIT,
    3009                 :         70 :                                                  BITS_PER_WORD))
    3010                 :         70 :                 reg = gen_rtx_REG (mode, REGNO (entry_parm));
    3011                 :            :               else
    3012                 :            :                 {
    3013                 :          0 :                   reg = gen_rtx_REG (word_mode, REGNO (entry_parm));
    3014                 :          0 :                   reg = convert_to_mode (mode, copy_to_reg (reg), 1);
    3015                 :            :                 }
    3016                 :         70 :               emit_move_insn (change_address (mem, mode, 0), reg);
    3017                 :            :             }
    3018                 :            : 
    3019                 :            : #ifdef BLOCK_REG_PADDING
    3020                 :            :           /* Storing the register in memory as a full word, as
    3021                 :            :              move_block_from_reg below would do, and then using the
    3022                 :            :              MEM in a smaller mode, has the effect of shifting right
    3023                 :            :              if BYTES_BIG_ENDIAN.  If we're bypassing memory, the
    3024                 :            :              shifting must be explicit.  */
    3025                 :            :           else if (!MEM_P (mem))
    3026                 :            :             {
    3027                 :            :               rtx x;
    3028                 :            : 
    3029                 :            :               /* If the assert below fails, we should have taken the
    3030                 :            :                  mode != BLKmode path above, unless we have downward
    3031                 :            :                  padding of smaller-than-word arguments on a machine
    3032                 :            :                  with little-endian bytes, which would likely require
    3033                 :            :                  additional changes to work correctly.  */
    3034                 :            :               gcc_checking_assert (BYTES_BIG_ENDIAN
    3035                 :            :                                    && (BLOCK_REG_PADDING (mode,
    3036                 :            :                                                           data->arg.type, 1)
    3037                 :            :                                        == PAD_UPWARD));
    3038                 :            : 
    3039                 :            :               int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
    3040                 :            : 
    3041                 :            :               x = gen_rtx_REG (word_mode, REGNO (entry_parm));
    3042                 :            :               x = expand_shift (RSHIFT_EXPR, word_mode, x, by,
    3043                 :            :                                 NULL_RTX, 1);
    3044                 :            :               x = force_reg (word_mode, x);
    3045                 :            :               x = gen_lowpart_SUBREG (GET_MODE (mem), x);
    3046                 :            : 
    3047                 :            :               emit_move_insn (mem, x);
    3048                 :            :             }
    3049                 :            : #endif
    3050                 :            : 
    3051                 :            :           /* Blocks smaller than a word on a BYTES_BIG_ENDIAN
    3052                 :            :              machine must be aligned to the left before storing
    3053                 :            :              to memory.  Note that the previous test doesn't
    3054                 :            :              handle all cases (e.g. SIZE == 3).  */
    3055                 :        415 :           else if (size != UNITS_PER_WORD
    3056                 :            : #ifdef BLOCK_REG_PADDING
    3057                 :            :                    && (BLOCK_REG_PADDING (mode, data->arg.type, 1)
    3058                 :            :                        == PAD_DOWNWARD)
    3059                 :            : #else
    3060                 :            :                    && BYTES_BIG_ENDIAN
    3061                 :            : #endif
    3062                 :            :                    )
    3063                 :            :             {
    3064                 :            :               rtx tem, x;
    3065                 :            :               int by = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
    3066                 :            :               rtx reg = gen_rtx_REG (word_mode, REGNO (entry_parm));
    3067                 :            : 
    3068                 :            :               x = expand_shift (LSHIFT_EXPR, word_mode, reg, by, NULL_RTX, 1);
    3069                 :            :               tem = change_address (mem, word_mode, 0);
    3070                 :            :               emit_move_insn (tem, x);
    3071                 :            :             }
    3072                 :            :           else
    3073                 :        830 :             move_block_from_reg (REGNO (entry_parm), mem,
    3074                 :        415 :                                  size_stored / UNITS_PER_WORD);
    3075                 :            :         }
    3076                 :          0 :       else if (!MEM_P (mem))
    3077                 :            :         {
    3078                 :          0 :           gcc_checking_assert (size > UNITS_PER_WORD);
    3079                 :            : #ifdef BLOCK_REG_PADDING
    3080                 :            :           gcc_checking_assert (BLOCK_REG_PADDING (GET_MODE (mem),
    3081                 :            :                                                   data->arg.type, 0)
    3082                 :            :                                == PAD_UPWARD);
    3083                 :            : #endif
    3084                 :          0 :           emit_move_insn (mem, entry_parm);
    3085                 :            :         }
    3086                 :            :       else
    3087                 :          0 :         move_block_from_reg (REGNO (entry_parm), mem,
    3088                 :          0 :                              size_stored / UNITS_PER_WORD);
    3089                 :            :     }
    3090                 :      46973 :   else if (data->stack_parm == 0 && !TYPE_EMPTY_P (data->arg.type))
    3091                 :            :     {
    3092                 :        195 :       push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
    3093                 :        195 :       emit_block_move (stack_parm, data->entry_parm, GEN_INT (size),
    3094                 :            :                        BLOCK_OP_NORMAL);
    3095                 :        195 :       all->first_conversion_insn = get_insns ();
    3096                 :        195 :       all->last_conversion_insn = get_last_insn ();
    3097                 :        195 :       end_sequence ();
    3098                 :        195 :       in_conversion_seq = true;
    3099                 :            :     }
    3100                 :            : 
    3101                 :      49565 :   if (target_reg)
    3102                 :            :     {
    3103                 :          0 :       if (!in_conversion_seq)
    3104                 :          0 :         emit_move_insn (target_reg, stack_parm);
    3105                 :            :       else
    3106                 :            :         {
    3107                 :          0 :           push_to_sequence2 (all->first_conversion_insn,
    3108                 :            :                              all->last_conversion_insn);
    3109                 :          0 :           emit_move_insn (target_reg, stack_parm);
    3110                 :          0 :           all->first_conversion_insn = get_insns ();
    3111                 :          0 :           all->last_conversion_insn = get_last_insn ();
    3112                 :          0 :           end_sequence ();
    3113                 :            :         }
    3114                 :            :       stack_parm = target_reg;
    3115                 :            :     }
    3116                 :            : 
    3117                 :      49565 :   data->stack_parm = stack_parm;
    3118                 :      49565 :   set_parm_rtl (parm, stack_parm);
    3119                 :      49565 : }
    3120                 :            : 
    3121                 :            : /* A subroutine of assign_parms.  Allocate a pseudo to hold the current
    3122                 :            :    parameter.  Get it there.  Perform all ABI specified conversions.  */
    3123                 :            : 
    3124                 :            : static void
    3125                 :    1545740 : assign_parm_setup_reg (struct assign_parm_data_all *all, tree parm,
    3126                 :            :                        struct assign_parm_data_one *data)
    3127                 :            : {
    3128                 :    1545740 :   rtx parmreg, validated_mem;
    3129                 :    1545740 :   rtx equiv_stack_parm;
    3130                 :    1545740 :   machine_mode promoted_nominal_mode;
    3131                 :    1545740 :   int unsignedp = TYPE_UNSIGNED (TREE_TYPE (parm));
    3132                 :    1545740 :   bool did_conversion = false;
    3133                 :    1545740 :   bool need_conversion, moved;
    3134                 :    1545740 :   enum insn_code icode;
    3135                 :    1545740 :   rtx rtl;
    3136                 :            : 
    3137                 :            :   /* Store the parm in a pseudoregister during the function, but we may
    3138                 :            :      need to do it in a wider mode.  Using 2 here makes the result
    3139                 :            :      consistent with promote_decl_mode and thus expand_expr_real_1.  */
    3140                 :    1545740 :   promoted_nominal_mode
    3141                 :    3091480 :     = promote_function_mode (data->nominal_type, data->nominal_mode, &unsignedp,
    3142                 :    1545740 :                              TREE_TYPE (current_function_decl), 2);
    3143                 :            : 
    3144                 :    1545740 :   parmreg = gen_reg_rtx (promoted_nominal_mode);
    3145                 :    1545740 :   if (!DECL_ARTIFICIAL (parm))
    3146                 :    1389800 :     mark_user_reg (parmreg);
    3147                 :            : 
    3148                 :            :   /* If this was an item that we received a pointer to,
    3149                 :            :      set rtl appropriately.  */
    3150                 :    1545740 :   if (data->arg.pass_by_reference)
    3151                 :            :     {
    3152                 :         51 :       rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data->arg.type)), parmreg);
    3153                 :         51 :       set_mem_attributes (rtl, parm, 1);
    3154                 :            :     }
    3155                 :            :   else
    3156                 :            :     rtl = parmreg;
    3157                 :            : 
    3158                 :    1545740 :   assign_parm_remove_parallels (data);
    3159                 :            : 
    3160                 :            :   /* Copy the value into the register, thus bridging between
    3161                 :            :      assign_parm_find_data_types and expand_expr_real_1.  */
    3162                 :            : 
    3163                 :    1545740 :   equiv_stack_parm = data->stack_parm;
    3164                 :    1545740 :   validated_mem = validize_mem (copy_rtx (data->entry_parm));
    3165                 :            : 
    3166                 :    3147670 :   need_conversion = (data->nominal_mode != data->passed_mode
    3167                 :    1545740 :                      || promoted_nominal_mode != data->arg.mode);
    3168                 :      56193 :   moved = false;
    3169                 :            : 
    3170                 :            :   if (need_conversion
    3171                 :      56193 :       && GET_MODE_CLASS (data->nominal_mode) == MODE_INT
    3172                 :      55697 :       && data->nominal_mode == data->passed_mode
    3173                 :          0 :       && data->nominal_mode == GET_MODE (data->entry_parm))
    3174                 :            :     {
    3175                 :            :       /* ENTRY_PARM has been converted to PROMOTED_MODE, its
    3176                 :            :          mode, by the caller.  We now have to convert it to
    3177                 :            :          NOMINAL_MODE, if different.  However, PARMREG may be in
    3178                 :            :          a different mode than NOMINAL_MODE if it is being stored
    3179                 :            :          promoted.
    3180                 :            : 
    3181                 :            :          If ENTRY_PARM is a hard register, it might be in a register
    3182                 :            :          not valid for operating in its mode (e.g., an odd-numbered
    3183                 :            :          register for a DFmode).  In that case, moves are the only
    3184                 :            :          thing valid, so we can't do a convert from there.  This
    3185                 :            :          occurs when the calling sequence allow such misaligned
    3186                 :            :          usages.
    3187                 :            : 
    3188                 :            :          In addition, the conversion may involve a call, which could
    3189                 :            :          clobber parameters which haven't been copied to pseudo
    3190                 :            :          registers yet.
    3191                 :            : 
    3192                 :            :          First, we try to emit an insn which performs the necessary
    3193                 :            :          conversion.  We verify that this insn does not clobber any
    3194                 :            :          hard registers.  */
    3195                 :            : 
    3196                 :          0 :       rtx op0, op1;
    3197                 :            : 
    3198                 :          0 :       icode = can_extend_p (promoted_nominal_mode, data->passed_mode,
    3199                 :            :                             unsignedp);
    3200                 :            : 
    3201                 :          0 :       op0 = parmreg;
    3202                 :          0 :       op1 = validated_mem;
    3203                 :          0 :       if (icode != CODE_FOR_nothing
    3204                 :          0 :           && insn_operand_matches (icode, 0, op0)
    3205                 :          0 :           && insn_operand_matches (icode, 1, op1))
    3206                 :            :         {
    3207                 :          0 :           enum rtx_code code = unsignedp ? ZERO_EXTEND : SIGN_EXTEND;
    3208                 :          0 :           rtx_insn *insn, *insns;
    3209                 :          0 :           rtx t = op1;
    3210                 :          0 :           HARD_REG_SET hardregs;
    3211                 :            : 
    3212                 :          0 :           start_sequence ();
    3213                 :            :           /* If op1 is a hard register that is likely spilled, first
    3214                 :            :              force it into a pseudo, otherwise combiner might extend
    3215                 :            :              its lifetime too much.  */
    3216                 :          0 :           if (GET_CODE (t) == SUBREG)
    3217                 :          0 :             t = SUBREG_REG (t);
    3218                 :          0 :           if (REG_P (t)
    3219                 :          0 :               && HARD_REGISTER_P (t)
    3220                 :          0 :               && ! TEST_HARD_REG_BIT (fixed_reg_set, REGNO (t))
    3221                 :          0 :               && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (t))))
    3222                 :            :             {
    3223                 :          0 :               t = gen_reg_rtx (GET_MODE (op1));
    3224                 :          0 :               emit_move_insn (t, op1);
    3225                 :            :             }
    3226                 :            :           else
    3227                 :            :             t = op1;
    3228                 :          0 :           rtx_insn *pat = gen_extend_insn (op0, t, promoted_nominal_mode,
    3229                 :            :                                            data->passed_mode, unsignedp);
    3230                 :          0 :           emit_insn (pat);
    3231                 :          0 :           insns = get_insns ();
    3232                 :            : 
    3233                 :          0 :           moved = true;
    3234                 :          0 :           CLEAR_HARD_REG_SET (hardregs);
    3235                 :          0 :           for (insn = insns; insn && moved; insn = NEXT_INSN (insn))
    3236                 :            :             {
    3237                 :          0 :               if (INSN_P (insn))
    3238                 :          0 :                 note_stores (insn, record_hard_reg_sets, &hardregs);
    3239                 :          0 :               if (!hard_reg_set_empty_p (hardregs))
    3240                 :          0 :                 moved = false;
    3241                 :            :             }
    3242                 :            : 
    3243                 :          0 :           end_sequence ();
    3244                 :            : 
    3245                 :          0 :           if (moved)
    3246                 :            :             {
    3247                 :          0 :               emit_insn (insns);
    3248                 :          0 :               if (equiv_stack_parm != NULL_RTX)
    3249                 :          0 :                 equiv_stack_parm = gen_rtx_fmt_e (code, GET_MODE (parmreg),
    3250                 :            :                                                   equiv_stack_parm);
    3251                 :            :             }
    3252                 :            :         }
    3253                 :            :     }
    3254                 :            : 
    3255                 :    1545740 :   if (moved)
    3256                 :            :     /* Nothing to do.  */
    3257                 :            :     ;
    3258                 :    1545740 :   else if (need_conversion)
    3259                 :            :     {
    3260                 :            :       /* We did not have an insn to convert directly, or the sequence
    3261                 :            :          generated appeared unsafe.  We must first copy the parm to a
    3262                 :            :          pseudo reg, and save the conversion until after all
    3263                 :            :          parameters have been moved.  */
    3264                 :            : 
    3265                 :      56193 :       int save_tree_used;
    3266                 :      56193 :       rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
    3267                 :            : 
    3268                 :      56193 :       emit_move_insn (tempreg, validated_mem);
    3269                 :            : 
    3270                 :      56193 :       push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
    3271                 :      56193 :       tempreg = convert_to_mode (data->nominal_mode, tempreg, unsignedp);
    3272                 :            : 
    3273                 :      56193 :       if (partial_subreg_p (tempreg)
    3274                 :      55697 :           && GET_MODE (tempreg) == data->nominal_mode
    3275                 :      55697 :           && REG_P (SUBREG_REG (tempreg))
    3276                 :      55697 :           && data->nominal_mode == data->passed_mode
    3277                 :      56193 :           && GET_MODE (SUBREG_REG (tempreg)) == GET_MODE (data->entry_parm))
    3278                 :            :         {
    3279                 :            :           /* The argument is already sign/zero extended, so note it
    3280                 :            :              into the subreg.  */
    3281                 :          0 :           SUBREG_PROMOTED_VAR_P (tempreg) = 1;
    3282                 :          0 :           SUBREG_PROMOTED_SET (tempreg, unsignedp);
    3283                 :            :         }
    3284                 :            : 
    3285                 :            :       /* TREE_USED gets set erroneously during expand_assignment.  */
    3286                 :      56193 :       save_tree_used = TREE_USED (parm);
    3287                 :      56193 :       SET_DECL_RTL (parm, rtl);
    3288                 :      56193 :       expand_assignment (parm, make_tree (data->nominal_type, tempreg), false);
    3289                 :      56193 :       SET_DECL_RTL (parm, NULL_RTX);
    3290                 :      56193 :       TREE_USED (parm) = save_tree_used;
    3291                 :      56193 :       all->first_conversion_insn = get_insns ();
    3292                 :      56193 :       all->last_conversion_insn = get_last_insn ();
    3293                 :      56193 :       end_sequence ();
    3294                 :            : 
    3295                 :      56193 :       did_conversion = true;
    3296                 :            :     }
    3297                 :    1489540 :   else if (MEM_P (data->entry_parm)
    3298                 :     694403 :            && GET_MODE_ALIGNMENT (promoted_nominal_mode)
    3299                 :     694403 :               > MEM_ALIGN (data->entry_parm)
    3300                 :    1509210 :            && (((icode = optab_handler (movmisalign_optab,
    3301                 :            :                                         promoted_nominal_mode))
    3302                 :            :                 != CODE_FOR_nothing)
    3303                 :      19665 :                || targetm.slow_unaligned_access (promoted_nominal_mode,
    3304                 :      19688 :                                                  MEM_ALIGN (data->entry_parm))))
    3305                 :            :     {
    3306                 :          4 :       if (icode != CODE_FOR_nothing)
    3307                 :          4 :         emit_insn (GEN_FCN (icode) (parmreg, validated_mem));
    3308                 :            :       else
    3309                 :          0 :         rtl = parmreg = extract_bit_field (validated_mem,
    3310                 :          0 :                         GET_MODE_BITSIZE (promoted_nominal_mode), 0,
    3311                 :            :                         unsignedp, parmreg,
    3312                 :            :                         promoted_nominal_mode, VOIDmode, false, NULL);
    3313                 :            :     }
    3314                 :            :   else
    3315                 :    1489540 :     emit_move_insn (parmreg, validated_mem);
    3316                 :            : 
    3317                 :            :   /* If we were passed a pointer but the actual value can safely live
    3318                 :            :      in a register, retrieve it and use it directly.  */
    3319                 :    1545740 :   if (data->arg.pass_by_reference && TYPE_MODE (TREE_TYPE (parm)) != BLKmode)
    3320                 :            :     {
    3321                 :            :       /* We can't use nominal_mode, because it will have been set to
    3322                 :            :          Pmode above.  We must use the actual mode of the parm.  */
    3323                 :         15 :       if (use_register_for_decl (parm))
    3324                 :            :         {
    3325                 :         13 :           parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
    3326                 :         13 :           mark_user_reg (parmreg);
    3327                 :            :         }
    3328                 :            :       else
    3329                 :            :         {
    3330                 :          2 :           int align = STACK_SLOT_ALIGNMENT (TREE_TYPE (parm),
    3331                 :            :                                             TYPE_MODE (TREE_TYPE (parm)),
    3332                 :            :                                             TYPE_ALIGN (TREE_TYPE (parm)));
    3333                 :          2 :           parmreg
    3334                 :          4 :             = assign_stack_local (TYPE_MODE (TREE_TYPE (parm)),
    3335                 :          4 :                                   GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parm))),
    3336                 :            :                                   align);
    3337                 :          2 :           set_mem_attributes (parmreg, parm, 1);
    3338                 :            :         }
    3339                 :            : 
    3340                 :            :       /* We need to preserve an address based on VIRTUAL_STACK_VARS_REGNUM for
    3341                 :            :          the debug info in case it is not legitimate.  */
    3342                 :         15 :       if (GET_MODE (parmreg) != GET_MODE (rtl))
    3343                 :            :         {
    3344                 :          0 :           rtx tempreg = gen_reg_rtx (GET_MODE (rtl));
    3345                 :          0 :           int unsigned_p = TYPE_UNSIGNED (TREE_TYPE (parm));
    3346                 :            : 
    3347                 :          0 :           push_to_sequence2 (all->first_conversion_insn,
    3348                 :            :                              all->last_conversion_insn);
    3349                 :          0 :           emit_move_insn (tempreg, rtl);
    3350                 :          0 :           tempreg = convert_to_mode (GET_MODE (parmreg), tempreg, unsigned_p);
    3351                 :          0 :           emit_move_insn (MEM_P (parmreg) ? copy_rtx (parmreg) : parmreg,
    3352                 :            :                           tempreg);
    3353                 :          0 :           all->first_conversion_insn = get_insns ();
    3354                 :          0 :           all->last_conversion_insn = get_last_insn ();
    3355                 :          0 :           end_sequence ();
    3356                 :            : 
    3357                 :          0 :           did_conversion = true;
    3358                 :            :         }
    3359                 :            :       else
    3360                 :         15 :         emit_move_insn (MEM_P (parmreg) ? copy_rtx (parmreg) : parmreg, rtl);
    3361                 :            : 
    3362                 :         15 :       rtl = parmreg;
    3363                 :            : 
    3364                 :            :       /* STACK_PARM is the pointer, not the parm, and PARMREG is
    3365                 :            :          now the parm.  */
    3366                 :         15 :       data->stack_parm = NULL;
    3367                 :            :     }
    3368                 :            : 
    3369                 :    1545740 :   set_parm_rtl (parm, rtl);
    3370                 :            : 
    3371                 :            :   /* Mark the register as eliminable if we did no conversion and it was
    3372                 :            :      copied from memory at a fixed offset, and the arg pointer was not
    3373                 :            :      copied to a pseudo-reg.  If the arg pointer is a pseudo reg or the
    3374                 :            :      offset formed an invalid address, such memory-equivalences as we
    3375                 :            :      make here would screw up life analysis for it.  */
    3376                 :    1545740 :   if (data->nominal_mode == data->passed_mode
    3377                 :    1489540 :       && !did_conversion
    3378                 :    1489540 :       && data->stack_parm != 0
    3379                 :     709130 :       && MEM_P (data->stack_parm)
    3380                 :     709130 :       && data->locate.offset.var == 0
    3381                 :    2254870 :       && reg_mentioned_p (virtual_incoming_args_rtx,
    3382                 :     709130 :                           XEXP (data->stack_parm, 0)))
    3383                 :            :     {
    3384                 :     709130 :       rtx_insn *linsn = get_last_insn ();
    3385                 :     709130 :       rtx_insn *sinsn;
    3386                 :     709130 :       rtx set;
    3387                 :            : 
    3388                 :            :       /* Mark complex types separately.  */
    3389                 :     709130 :       if (GET_CODE (parmreg) == CONCAT)
    3390                 :            :         {
    3391                 :        781 :           scalar_mode submode = GET_MODE_INNER (GET_MODE (parmreg));
    3392                 :        781 :           int regnor = REGNO (XEXP (parmreg, 0));
    3393                 :        781 :           int regnoi = REGNO (XEXP (parmreg, 1));
    3394                 :        781 :           rtx stackr = adjust_address_nv (data->stack_parm, submode, 0);
    3395                 :       1562 :           rtx stacki = adjust_address_nv (data->stack_parm, submode,
    3396                 :            :                                           GET_MODE_SIZE (submode));
    3397                 :            : 
    3398                 :            :           /* Scan backwards for the set of the real and
    3399                 :            :              imaginary parts.  */
    3400                 :       6132 :           for (sinsn = linsn; sinsn != 0;
    3401                 :       5351 :                sinsn = prev_nonnote_insn (sinsn))
    3402                 :            :             {
    3403                 :       5351 :               set = single_set (sinsn);
    3404                 :       5351 :               if (set == 0)
    3405                 :          0 :                 continue;
    3406                 :            : 
    3407                 :       5351 :               if (SET_DEST (set) == regno_reg_rtx [regnoi])
    3408                 :        781 :                 set_unique_reg_note (sinsn, REG_EQUIV, stacki);
    3409                 :       4570 :               else if (SET_DEST (set) == regno_reg_rtx [regnor])
    3410                 :        781 :                 set_unique_reg_note (sinsn, REG_EQUIV, stackr);
    3411                 :            :             }
    3412                 :            :         }
    3413                 :            :       else
    3414                 :     708349 :         set_dst_reg_note (linsn, REG_EQUIV, equiv_stack_parm, parmreg);
    3415                 :            :     }
    3416                 :            : 
    3417                 :            :   /* For pointer data type, suggest pointer register.  */
    3418                 :    1545740 :   if (POINTER_TYPE_P (TREE_TYPE (parm)))
    3419                 :     551204 :     mark_reg_pointer (parmreg,
    3420                 :    1102410 :                       TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
    3421                 :    1545740 : }
    3422                 :            : 
    3423                 :            : /* A subroutine of assign_parms.  Allocate stack space to hold the current
    3424                 :            :    parameter.  Get it there.  Perform all ABI specified conversions.  */
    3425                 :            : 
    3426                 :            : static void
    3427                 :     420198 : assign_parm_setup_stack (struct assign_parm_data_all *all, tree parm,
    3428                 :            :                          struct assign_parm_data_one *data)
    3429                 :            : {
    3430                 :            :   /* Value must be stored in the stack slot STACK_PARM during function
    3431                 :            :      execution.  */
    3432                 :     420198 :   bool to_conversion = false;
    3433                 :            : 
    3434                 :     420198 :   assign_parm_remove_parallels (data);
    3435                 :            : 
    3436                 :     420198 :   if (data->arg.mode != data->nominal_mode)
    3437                 :            :     {
    3438                 :            :       /* Conversion is required.  */
    3439                 :      19135 :       rtx tempreg = gen_reg_rtx (GET_MODE (data->entry_parm));
    3440                 :            : 
    3441                 :      19135 :       emit_move_insn (tempreg, validize_mem (copy_rtx (data->entry_parm)));
    3442                 :            : 
    3443                 :      19135 :       push_to_sequence2 (all->first_conversion_insn, all->last_conversion_insn);
    3444                 :      19135 :       to_conversion = true;
    3445                 :            : 
    3446                 :      19135 :       data->entry_parm = convert_to_mode (data->nominal_mode, tempreg,
    3447                 :      19135 :                                           TYPE_UNSIGNED (TREE_TYPE (parm)));
    3448                 :            : 
    3449                 :      19135 :       if (data->stack_parm)
    3450                 :            :         {
    3451                 :          1 :           poly_int64 offset
    3452                 :          1 :             = subreg_lowpart_offset (data->nominal_mode,
    3453                 :          1 :                                      GET_MODE (data->stack_parm));
    3454                 :            :           /* ??? This may need a big-endian conversion on sparc64.  */
    3455                 :          1 :           data->stack_parm
    3456                 :          1 :             = adjust_address (data->stack_parm, data->nominal_mode, 0);
    3457                 :          1 :           if (maybe_ne (offset, 0) && MEM_OFFSET_KNOWN_P (data->stack_parm))
    3458                 :          0 :             set_mem_offset (data->stack_parm,
    3459                 :          0 :                             MEM_OFFSET (data->stack_parm) + offset);
    3460                 :            :         }
    3461                 :            :     }
    3462                 :            : 
    3463                 :     420198 :   if (data->entry_parm != data->stack_parm)
    3464                 :            :     {
    3465                 :     307871 :       rtx src, dest;
    3466                 :            : 
    3467                 :     307871 :       if (data->stack_parm == 0)
    3468                 :            :         {
    3469                 :     297604 :           int align = STACK_SLOT_ALIGNMENT (data->arg.type,
    3470                 :            :                                             GET_MODE (data->entry_parm),
    3471                 :            :                                             TYPE_ALIGN (data->arg.type));
    3472                 :     297604 :           if (align < (int)GET_MODE_ALIGNMENT (GET_MODE (data->entry_parm))
    3473                 :     298897 :               && ((optab_handler (movmisalign_optab,
    3474                 :       1293 :                                   GET_MODE (data->entry_parm))
    3475                 :            :                    != CODE_FOR_nothing)
    3476                 :       1293 :                   || targetm.slow_unaligned_access (GET_MODE (data->entry_parm),
    3477                 :            :                                                     align)))
    3478                 :          0 :             align = GET_MODE_ALIGNMENT (GET_MODE (data->entry_parm));
    3479                 :     297604 :           data->stack_parm
    3480                 :     297604 :             = assign_stack_local (GET_MODE (data->entry_parm),
    3481                 :     595208 :                                   GET_MODE_SIZE (GET_MODE (data->entry_parm)),
    3482                 :            :                                   align);
    3483                 :     297604 :           align = MEM_ALIGN (data->stack_parm);
    3484                 :     297604 :           set_mem_attributes (data->stack_parm, parm, 1);
    3485                 :     297604 :           set_mem_align (data->stack_parm, align);
    3486                 :            :         }
    3487                 :            : 
    3488                 :     307871 :       dest = validize_mem (copy_rtx (data->stack_parm));
    3489                 :     307871 :       src = validize_mem (copy_rtx (data->entry_parm));
    3490                 :            : 
    3491                 :     307871 :       if (TYPE_EMPTY_P (data->arg.type))
    3492                 :            :         /* Empty types don't really need to be copied.  */;
    3493                 :     306860 :       else if (MEM_P (src))
    3494                 :            :         {
    3495                 :            :           /* Use a block move to handle potentially misaligned entry_parm.  */
    3496                 :         47 :           if (!to_conversion)
    3497                 :         47 :             push_to_sequence2 (all->first_conversion_insn,
    3498                 :            :                                all->last_conversion_insn);
    3499                 :         47 :           to_conversion = true;
    3500                 :            : 
    3501                 :         47 :           emit_block_move (dest, src,
    3502                 :         47 :                            GEN_INT (int_size_in_bytes (data->arg.type)),
    3503                 :            :                            BLOCK_OP_NORMAL);
    3504                 :            :         }
    3505                 :            :       else
    3506                 :            :         {
    3507                 :     306813 :           if (!REG_P (src))
    3508                 :      19680 :             src = force_reg (GET_MODE (src), src);
    3509                 :     306813 :           emit_move_insn (dest, src);
    3510                 :            :         }
    3511                 :            :     }
    3512                 :            : 
    3513                 :     420198 :   if (to_conversion)
    3514                 :            :     {
    3515                 :      19182 :       all->first_conversion_insn = get_insns ();
    3516                 :      19182 :       all->last_conversion_insn = get_last_insn ();
    3517                 :      19182 :       end_sequence ();
    3518                 :            :     }
    3519                 :            : 
    3520                 :     420198 :   set_parm_rtl (parm, data->stack_parm);
    3521                 :     420198 : }
    3522                 :            : 
    3523                 :            : /* A subroutine of assign_parms.  If the ABI splits complex arguments, then
    3524                 :            :    undo the frobbing that we did in assign_parms_augmented_arg_list.  */
    3525                 :            : 
    3526                 :            : static void
    3527                 :          0 : assign_parms_unsplit_complex (struct assign_parm_data_all *all,
    3528                 :            :                               vec<tree> fnargs)
    3529                 :            : {
    3530                 :          0 :   tree parm;
    3531                 :          0 :   tree orig_fnargs = all->orig_fnargs;
    3532                 :          0 :   unsigned i = 0;
    3533                 :            : 
    3534                 :          0 :   for (parm = orig_fnargs; parm; parm = TREE_CHAIN (parm), ++i)
    3535                 :            :     {
    3536                 :          0 :       if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
    3537                 :          0 :           && targetm.calls.split_complex_arg (TREE_TYPE (parm)))
    3538                 :            :         {
    3539                 :          0 :           rtx tmp, real, imag;
    3540                 :          0 :           scalar_mode inner = GET_MODE_INNER (DECL_MODE (parm));
    3541                 :            : 
    3542                 :          0 :           real = DECL_RTL (fnargs[i]);
    3543                 :          0 :           imag = DECL_RTL (fnargs[i + 1]);
    3544                 :          0 :           if (inner != GET_MODE (real))
    3545                 :            :             {
    3546                 :          0 :               real = gen_lowpart_SUBREG (inner, real);
    3547                 :          0 :               imag = gen_lowpart_SUBREG (inner, imag);
    3548                 :            :             }
    3549                 :            : 
    3550                 :          0 :           if (TREE_ADDRESSABLE (parm))
    3551                 :            :             {
    3552                 :          0 :               rtx rmem, imem;
    3553                 :          0 :               HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (parm));
    3554                 :          0 :               int align = STACK_SLOT_ALIGNMENT (TREE_TYPE (parm),
    3555                 :            :                                                 DECL_MODE (parm),
    3556                 :            :                                                 TYPE_ALIGN (TREE_TYPE (parm)));
    3557                 :            : 
    3558                 :            :               /* split_complex_arg put the real and imag parts in
    3559                 :            :                  pseudos.  Move them to memory.  */
    3560                 :          0 :               tmp = assign_stack_local (DECL_MODE (parm), size, align);
    3561                 :          0 :               set_mem_attributes (tmp, parm, 1);
    3562                 :          0 :               rmem = adjust_address_nv (tmp, inner, 0);
    3563                 :          0 :               imem = adjust_address_nv (tmp, inner, GET_MODE_SIZE (inner));
    3564                 :          0 :               push_to_sequence2 (all->first_conversion_insn,
    3565                 :            :                                  all->last_conversion_insn);
    3566                 :          0 :               emit_move_insn (rmem, real);
    3567                 :          0 :               emit_move_insn (imem, imag);
    3568                 :          0 :               all->first_conversion_insn = get_insns ();
    3569                 :          0 :               all->last_conversion_insn = get_last_insn ();
    3570                 :          0 :               end_sequence ();
    3571                 :            :             }
    3572                 :            :           else
    3573                 :          0 :             tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag);
    3574                 :          0 :           set_parm_rtl (parm, tmp);
    3575                 :            : 
    3576                 :          0 :           real = DECL_INCOMING_RTL (fnargs[i]);
    3577                 :          0 :           imag = DECL_INCOMING_RTL (fnargs[i + 1]);
    3578                 :          0 :           if (inner != GET_MODE (real))
    3579                 :            :             {
    3580                 :          0 :               real = gen_lowpart_SUBREG (inner, real);
    3581                 :          0 :               imag = gen_lowpart_SUBREG (inner, imag);
    3582                 :            :             }
    3583                 :          0 :           tmp = gen_rtx_CONCAT (DECL_MODE (parm), real, imag);
    3584                 :          0 :           set_decl_incoming_rtl (parm, tmp, false);
    3585                 :          0 :           i++;
    3586                 :            :         }
    3587                 :            :     }
    3588                 :          0 : }
    3589                 :            : 
    3590                 :            : /* Assign RTL expressions to the function's parameters.  This may involve
    3591                 :            :    copying them into registers and using those registers as the DECL_RTL.  */
    3592                 :            : 
    3593                 :            : static void
    3594                 :     944512 : assign_parms (tree fndecl)
    3595                 :            : {
    3596                 :     944512 :   struct assign_parm_data_all all;
    3597                 :     944512 :   tree parm;
    3598                 :     944512 :   vec<tree> fnargs;
    3599                 :     944512 :   unsigned i;
    3600                 :            : 
    3601                 :     944512 :   crtl->args.internal_arg_pointer
    3602                 :     944512 :     = targetm.calls.internal_arg_pointer ();
    3603                 :            : 
    3604                 :     944512 :   assign_parms_initialize_all (&all);
    3605                 :     944512 :   fnargs = assign_parms_augmented_arg_list (&all);
    3606                 :            : 
    3607                 :    2960010 :   FOR_EACH_VEC_ELT (fnargs, i, parm)
    3608                 :            :     {
    3609                 :    2015500 :       struct assign_parm_data_one data;
    3610                 :            : 
    3611                 :            :       /* Extract the type of PARM; adjust it according to ABI.  */
    3612                 :    2015500 :       assign_parm_find_data_types (&all, parm, &data);
    3613                 :            : 
    3614                 :            :       /* Early out for errors and void parameters.  */
    3615                 :    2015500 :       if (data.passed_mode == VOIDmode)
    3616                 :            :         {
    3617                 :          0 :           SET_DECL_RTL (parm, const0_rtx);
    3618                 :          0 :           DECL_INCOMING_RTL (parm) = DECL_RTL (parm);
    3619                 :          0 :           continue;
    3620                 :            :         }
    3621                 :            : 
    3622                 :            :       /* Estimate stack alignment from parameter alignment.  */
    3623                 :    2015500 :       if (SUPPORTS_STACK_ALIGNMENT)
    3624                 :            :         {
    3625                 :    2015500 :           unsigned int align
    3626                 :    4031000 :             = targetm.calls.function_arg_boundary (data.arg.mode,
    3627                 :    2015500 :                                                    data.arg.type);
    3628                 :    2015500 :           align = MINIMUM_ALIGNMENT (data.arg.type, data.arg.mode, align);
    3629                 :    2015500 :           if (TYPE_ALIGN (data.nominal_type) > align)
    3630                 :       3757 :             align = MINIMUM_ALIGNMENT (data.nominal_type,
    3631                 :            :                                        TYPE_MODE (data.nominal_type),
    3632                 :            :                                        TYPE_ALIGN (data.nominal_type));
    3633                 :    2015500 :           if (crtl->stack_alignment_estimated < align)
    3634                 :            :             {
    3635                 :     228751 :               gcc_assert (!crtl->stack_realign_processed);
    3636                 :     228751 :               crtl->stack_alignment_estimated = align;
    3637                 :            :             }
    3638                 :            :         }
    3639                 :            : 
    3640                 :            :       /* Find out where the parameter arrives in this function.  */
    3641                 :    2015500 :       assign_parm_find_entry_rtl (&all, &data);
    3642                 :            : 
    3643                 :            :       /* Find out where stack space for this parameter might be.  */
    3644                 :    2015500 :       if (assign_parm_is_stack_parm (&all, &data))
    3645                 :            :         {
    3646                 :     886055 :           assign_parm_find_stack_rtl (parm, &data);
    3647                 :     886055 :           assign_parm_adjust_entry_rtl (&data);
    3648                 :            :           /* For arguments that occupy no space in the parameter
    3649                 :            :              passing area, have non-zero size and have address taken,
    3650                 :            :              force creation of a stack slot so that they have distinct
    3651                 :            :              address from other parameters.  */
    3652                 :     886055 :           if (TYPE_EMPTY_P (data.arg.type)
    3653                 :       4281 :               && TREE_ADDRESSABLE (parm)
    3654                 :       1011 :               && data.entry_parm == data.stack_parm
    3655                 :       1011 :               && MEM_P (data.entry_parm)
    3656                 :     887066 :               && int_size_in_bytes (data.arg.type))
    3657                 :       1011 :             data.stack_parm = NULL_RTX;
    3658                 :            :         }
    3659                 :            :       /* Record permanently how this parm was passed.  */
    3660                 :    2015500 :       if (data.arg.pass_by_reference)
    3661                 :            :         {
    3662                 :         51 :           rtx incoming_rtl
    3663                 :         51 :             = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (data.arg.type)),
    3664                 :            :                            data.entry_parm);
    3665                 :         51 :           set_decl_incoming_rtl (parm, incoming_rtl, true);
    3666                 :            :         }
    3667                 :            :       else
    3668                 :    2015450 :         set_decl_incoming_rtl (parm, data.entry_parm, false);
    3669                 :            : 
    3670                 :    2015500 :       assign_parm_adjust_stack_rtl (&data);
    3671                 :            : 
    3672                 :    2015500 :       if (assign_parm_setup_block_p (&data))
    3673                 :      49565 :         assign_parm_setup_block (&all, parm, &data);
    3674                 :    1965940 :       else if (data.arg.pass_by_reference || use_register_for_decl (parm))
    3675                 :    1545740 :         assign_parm_setup_reg (&all, parm, &data);
    3676                 :            :       else
    3677                 :     420198 :         assign_parm_setup_stack (&all, parm, &data);
    3678                 :            : 
    3679                 :    2015500 :       if (cfun->stdarg && !DECL_CHAIN (parm))
    3680                 :      15984 :         assign_parms_setup_varargs (&all, &data, false);
    3681                 :            : 
    3682                 :            :       /* Update info on where next arg arrives in registers.  */
    3683                 :    2015500 :       targetm.calls.function_arg_advance (all.args_so_far, data.arg);
    3684                 :            :     }
    3685                 :            : 
    3686                 :     944512 :   if (targetm.calls.split_complex_arg)
    3687                 :          0 :     assign_parms_unsplit_complex (&all, fnargs);
    3688                 :            : 
    3689                 :     944512 :   fnargs.release ();
    3690                 :            : 
    3691                 :            :   /* Output all parameter conversion instructions (possibly including calls)
    3692                 :            :      now that all parameters have been copied out of hard registers.  */
    3693                 :     944512 :   emit_insn (all.first_conversion_insn);
    3694                 :            : 
    3695                 :            :   /* Estimate reload stack alignment from scalar return mode.  */
    3696                 :     944512 :   if (SUPPORTS_STACK_ALIGNMENT)
    3697                 :            :     {
    3698                 :     944512 :       if (DECL_RESULT (fndecl))
    3699                 :            :         {
    3700                 :     944512 :           tree type = TREE_TYPE (DECL_RESULT (fndecl));
    3701                 :     944512 :           machine_mode mode = TYPE_MODE (type);
    3702                 :            : 
    3703                 :     944512 :           if (mode != BLKmode
    3704                 :     911313 :               && mode != VOIDmode
    3705                 :     467062 :               && !AGGREGATE_TYPE_P (type))
    3706                 :            :             {
    3707                 :     427178 :               unsigned int align = GET_MODE_ALIGNMENT (mode);
    3708                 :     427178 :               if (crtl->stack_alignment_estimated < align)
    3709                 :            :                 {
    3710                 :          9 :                   gcc_assert (!crtl->stack_realign_processed);
    3711                 :          9 :                   crtl->stack_alignment_estimated = align;
    3712                 :            :                 }
    3713                 :            :             }
    3714                 :            :         }
    3715                 :            :     }
    3716                 :            : 
    3717                 :            :   /* If we are receiving a struct value address as the first argument, set up
    3718                 :            :      the RTL for the function result. As this might require code to convert
    3719                 :            :      the transmitted address to Pmode, we do this here to ensure that possible
    3720                 :            :      preliminary conversions of the address have been emitted already.  */
    3721                 :     944512 :   if (all.function_result_decl)
    3722                 :            :     {
    3723                 :      50830 :       tree result = DECL_RESULT (current_function_decl);
    3724                 :      50830 :       rtx addr = DECL_RTL (all.function_result_decl);
    3725                 :      50830 :       rtx x;
    3726                 :            : 
    3727                 :     101660 :       if (DECL_BY_REFERENCE (result))
    3728                 :            :         {
    3729                 :       6367 :           SET_DECL_VALUE_EXPR (result, all.function_result_decl);
    3730                 :       6367 :           x = addr;
    3731                 :            :         }
    3732                 :            :       else
    3733                 :            :         {
    3734                 :      44463 :           SET_DECL_VALUE_EXPR (result,
    3735                 :            :                                build1 (INDIRECT_REF, TREE_TYPE (result),
    3736                 :            :                                        all.function_result_decl));
    3737                 :      88926 :           addr = convert_memory_address (Pmode, addr);
    3738                 :      44463 :           x = gen_rtx_MEM (DECL_MODE (result), addr);
    3739                 :      44463 :           set_mem_attributes (x, result, 1);
    3740                 :            :         }
    3741                 :            : 
    3742                 :      50830 :       DECL_HAS_VALUE_EXPR_P (result) = 1;
    3743                 :            : 
    3744                 :      50830 :       set_parm_rtl (result, x);
    3745                 :            :     }
    3746                 :            : 
    3747                 :            :   /* We have aligned all the args, so add space for the pretend args.  */
    3748                 :     944512 :   crtl->args.pretend_args_size = all.pretend_args_size;
    3749                 :     944512 :   all.stack_args_size.constant += all.extra_pretend_bytes;
    3750                 :     944512 :   crtl->args.size = all.stack_args_size.constant;
    3751                 :            : 
    3752                 :            :   /* Adjust function incoming argument size for alignment and
    3753                 :            :      minimum length.  */
    3754                 :            : 
    3755                 :     944512 :   crtl->args.size = upper_bound (crtl->args.size, all.reg_parm_stack_space);
    3756                 :    1889020 :   crtl->args.size = aligned_upper_bound (crtl->args.size,
    3757                 :    1039610 :                                          PARM_BOUNDARY / BITS_PER_UNIT);
    3758                 :            : 
    3759                 :     944512 :   if (ARGS_GROW_DOWNWARD)
    3760                 :            :     {
    3761                 :            :       crtl->args.arg_offset_rtx
    3762                 :            :         = (all.stack_args_size.var == 0
    3763                 :            :            ? gen_int_mode (-all.stack_args_size.constant, Pmode)
    3764                 :            :            : expand_expr (size_diffop (all.stack_args_size.var,
    3765                 :            :                                        size_int (-all.stack_args_size.constant)),
    3766                 :            :                           NULL_RTX, VOIDmode, EXPAND_NORMAL));
    3767                 :            :     }
    3768                 :            :   else
    3769                 :    1039650 :     crtl->args.arg_offset_rtx = ARGS_SIZE_RTX (all.stack_args_size);
    3770                 :            : 
    3771                 :            :   /* See how many bytes, if any, of its args a function should try to pop
    3772                 :            :      on return.  */
    3773                 :            : 
    3774                 :     944512 :   crtl->args.pops_args = targetm.calls.return_pops_args (fndecl,
    3775                 :     944512 :                                                          TREE_TYPE (fndecl),
    3776                 :            :                                                          crtl->args.size);
    3777                 :            : 
    3778                 :            :   /* For stdarg.h function, save info about
    3779                 :            :      regs and stack space used by the named args.  */
    3780                 :            : 
    3781                 :     944512 :   crtl->args.info = all.args_so_far_v;
    3782                 :            : 
    3783                 :            :   /* Set the rtx used for the function return value.  Put this in its
    3784                 :            :      own variable so any optimizers that need this information don't have
    3785                 :            :      to include tree.h.  Do this here so it gets done when an inlined
    3786                 :            :      function gets output.  */
    3787                 :            : 
    3788                 :     944512 :   crtl->return_rtx
    3789                 :     944512 :     = (DECL_RTL_SET_P (DECL_RESULT (fndecl))
    3790                 :     944512 :        ? DECL_RTL (DECL_RESULT (fndecl)) : NULL_RTX);
    3791                 :            : 
    3792                 :            :   /* If scalar return value was computed in a pseudo-reg, or was a named
    3793                 :            :      return value that got dumped to the stack, copy that to the hard
    3794                 :            :      return register.  */
    3795                 :     944512 :   if (DECL_RTL_SET_P (DECL_RESULT (fndecl)))
    3796                 :            :     {
    3797                 :     500261 :       tree decl_result = DECL_RESULT (fndecl);
    3798                 :     500261 :       rtx decl_rtl = DECL_RTL (decl_result);
    3799                 :            : 
    3800                 :     500261 :       if (REG_P (decl_rtl)
    3801                 :     500261 :           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
    3802                 :      48481 :           : DECL_REGISTER (decl_result))
    3803                 :            :         {
    3804                 :     454297 :           rtx real_decl_rtl;
    3805                 :            : 
    3806                 :     454297 :           real_decl_rtl = targetm.calls.function_value (TREE_TYPE (decl_result),
    3807                 :            :                                                         fndecl, true);
    3808                 :     454297 :           REG_FUNCTION_VALUE_P (real_decl_rtl) = 1;
    3809                 :            :           /* The delay slot scheduler assumes that crtl->return_rtx
    3810                 :            :              holds the hard register containing the return value, not a
    3811                 :            :              temporary pseudo.  */
    3812                 :     454297 :           crtl->return_rtx = real_decl_rtl;
    3813                 :            :         }
    3814                 :            :     }
    3815                 :     944512 : }
    3816                 :            : 
    3817                 :            : /* A subroutine of gimplify_parameters, invoked via walk_tree.
    3818                 :            :    For all seen types, gimplify their sizes.  */
    3819                 :            : 
    3820                 :            : static tree
    3821                 :    5850030 : gimplify_parm_type (tree *tp, int *walk_subtrees, void *data)
    3822                 :            : {
    3823                 :    5850030 :   tree t = *tp;
    3824                 :            : 
    3825                 :    5850030 :   *walk_subtrees = 0;
    3826                 :    5850030 :   if (TYPE_P (t))
    3827                 :            :     {
    3828                 :    5850030 :       if (POINTER_TYPE_P (t))
    3829                 :    2073700 :         *walk_subtrees = 1;
    3830                 :    3776320 :       else if (TYPE_SIZE (t) && !TREE_CONSTANT (TYPE_SIZE (t))
    3831                 :    3776530 :                && !TYPE_SIZES_GIMPLIFIED (t))
    3832                 :            :         {
    3833                 :        142 :           gimplify_type_sizes (t, (gimple_seq *) data);
    3834                 :        142 :           *walk_subtrees = 1;
    3835                 :            :         }
    3836                 :            :     }
    3837                 :            : 
    3838                 :    5850030 :   return NULL;
    3839                 :            : }
    3840                 :            : 
    3841                 :            : /* Gimplify the parameter list for current_function_decl.  This involves
    3842                 :            :    evaluating SAVE_EXPRs of variable sized parameters and generating code
    3843                 :            :    to implement callee-copies reference parameters.  Returns a sequence of
    3844                 :            :    statements to add to the beginning of the function.  */
    3845                 :            : 
    3846                 :            : gimple_seq
    3847                 :    1863280 : gimplify_parameters (gimple_seq *cleanup)
    3848                 :            : {
    3849                 :    1863280 :   struct assign_parm_data_all all;
    3850                 :    1863280 :   tree parm;
    3851                 :    1863280 :   gimple_seq stmts = NULL;
    3852                 :    1863280 :   vec<tree> fnargs;
    3853                 :    1863280 :   unsigned i;
    3854                 :            : 
    3855                 :    1863280 :   assign_parms_initialize_all (&all);
    3856                 :    1863280 :   fnargs = assign_parms_augmented_arg_list (&all);
    3857                 :            : 
    3858                 :    5639440 :   FOR_EACH_VEC_ELT (fnargs, i, parm)
    3859                 :            :     {
    3860                 :    3776160 :       struct assign_parm_data_one data;
    3861                 :            : 
    3862                 :            :       /* Extract the type of PARM; adjust it according to ABI.  */
    3863                 :    3776160 :       assign_parm_find_data_types (&all, parm, &data);
    3864                 :            : 
    3865                 :            :       /* Early out for errors and void parameters.  */
    3866                 :    3776160 :       if (data.passed_mode == VOIDmode || DECL_SIZE (parm) == NULL)
    3867                 :         93 :         continue;
    3868                 :            : 
    3869                 :            :       /* Update info on where next arg arrives in registers.  */
    3870                 :    3776070 :       targetm.calls.function_arg_advance (all.args_so_far, data.arg);
    3871                 :            : 
    3872                 :            :       /* ??? Once upon a time variable_size stuffed parameter list
    3873                 :            :          SAVE_EXPRs (amongst others) onto a pending sizes list.  This
    3874                 :            :          turned out to be less than manageable in the gimple world.
    3875                 :            :          Now we have to hunt them down ourselves.  */
    3876                 :    3776070 :       walk_tree_without_duplicates (&data.arg.type,
    3877                 :            :                                     gimplify_parm_type, &stmts);
    3878                 :            : 
    3879                 :    3776070 :       if (TREE_CODE (DECL_SIZE_UNIT (parm)) != INTEGER_CST)
    3880                 :            :         {
    3881                 :         36 :           gimplify_one_sizepos (&DECL_SIZE (parm), &stmts);
    3882                 :         36 :           gimplify_one_sizepos (&DECL_SIZE_UNIT (parm), &stmts);
    3883                 :            :         }
    3884                 :            : 
    3885                 :    3776070 :       if (data.arg.pass_by_reference)
    3886                 :            :         {
    3887                 :         54 :           tree type = TREE_TYPE (data.arg.type);
    3888                 :         54 :           function_arg_info orig_arg (type, data.arg.named);
    3889                 :         54 :           if (reference_callee_copied (&all.args_so_far_v, orig_arg))
    3890                 :            :             {
    3891                 :          0 :               tree local, t;
    3892                 :            : 
    3893                 :            :               /* For constant-sized objects, this is trivial; for
    3894                 :            :                  variable-sized objects, we have to play games.  */
    3895                 :          0 :               if (TREE_CODE (DECL_SIZE_UNIT (parm)) == INTEGER_CST
    3896                 :          0 :                   && !(flag_stack_check == GENERIC_STACK_CHECK
    3897                 :          0 :                        && compare_tree_int (DECL_SIZE_UNIT (parm),
    3898                 :            :                                             STACK_CHECK_MAX_VAR_SIZE) > 0))
    3899                 :            :                 {
    3900                 :          0 :                   local = create_tmp_var (type, get_name (parm));
    3901                 :          0 :                   DECL_IGNORED_P (local) = 0;
    3902                 :            :                   /* If PARM was addressable, move that flag over
    3903                 :            :                      to the local copy, as its address will be taken,
    3904                 :            :                      not the PARMs.  Keep the parms address taken
    3905                 :            :                      as we'll query that flag during gimplification.  */
    3906                 :          0 :                   if (TREE_ADDRESSABLE (parm))
    3907                 :          0 :                     TREE_ADDRESSABLE (local) = 1;
    3908                 :          0 :                   else if (TREE_CODE (type) == COMPLEX_TYPE
    3909                 :          0 :                            || TREE_CODE (type) == VECTOR_TYPE)
    3910                 :          0 :                     DECL_GIMPLE_REG_P (local) = 1;
    3911                 :            : 
    3912                 :          0 :                   if (!is_gimple_reg (local)
    3913                 :          0 :                       && flag_stack_reuse != SR_NONE)
    3914                 :            :                     {
    3915                 :          0 :                       tree clobber = build_clobber (type);
    3916                 :          0 :                       gimple *clobber_stmt;
    3917                 :          0 :                       clobber_stmt = gimple_build_assign (local, clobber);
    3918                 :          0 :                       gimple_seq_add_stmt (cleanup, clobber_stmt);
    3919                 :            :                     }
    3920                 :            :                 }
    3921                 :            :               else
    3922                 :            :                 {
    3923                 :          0 :                   tree ptr_type, addr;
    3924                 :            : 
    3925                 :          0 :                   ptr_type = build_pointer_type (type);
    3926                 :          0 :                   addr = create_tmp_reg (ptr_type, get_name (parm));
    3927                 :          0 :                   DECL_IGNORED_P (addr) = 0;
    3928                 :          0 :                   local = build_fold_indirect_ref (addr);
    3929                 :            : 
    3930                 :          0 :                   t = build_alloca_call_expr (DECL_SIZE_UNIT (parm),
    3931                 :          0 :                                               DECL_ALIGN (parm),
    3932                 :            :                                               max_int_size_in_bytes (type));
    3933                 :            :                   /* The call has been built for a variable-sized object.  */
    3934                 :          0 :                   CALL_ALLOCA_FOR_VAR_P (t) = 1;
    3935                 :          0 :                   t = fold_convert (ptr_type, t);
    3936                 :          0 :                   t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
    3937                 :          0 :                   gimplify_and_add (t, &stmts);
    3938                 :            :                 }
    3939                 :            : 
    3940                 :          0 :               gimplify_assign (local, parm, &stmts);
    3941                 :            : 
    3942                 :          0 :               SET_DECL_VALUE_EXPR (parm, local);
    3943                 :          0 :               DECL_HAS_VALUE_EXPR_P (parm) = 1;
    3944                 :            :             }
    3945                 :            :         }
    3946                 :            :     }
    3947                 :            : 
    3948                 :    1863280 :   fnargs.release ();
    3949                 :            : 
    3950                 :    1863280 :   return stmts;
    3951                 :            : }
    3952                 :            : 
    3953                 :            : /* Compute the size and offset from the start of the stacked arguments for a
    3954                 :            :    parm passed in mode PASSED_MODE and with type TYPE.
    3955                 :            : 
    3956                 :            :    INITIAL_OFFSET_PTR points to the current offset into the stacked
    3957                 :            :    arguments.
    3958                 :            : 
    3959                 :            :    The starting offset and size for this parm are returned in
    3960                 :            :    LOCATE->OFFSET and LOCATE->SIZE, respectively.  When IN_REGS is
    3961                 :            :    nonzero, the offset is that of stack slot, which is returned in
    3962                 :            :    LOCATE->SLOT_OFFSET.  LOCATE->ALIGNMENT_PAD is the amount of
    3963                 :            :    padding required from the initial offset ptr to the stack slot.
    3964                 :            : 
    3965                 :            :    IN_REGS is nonzero if the argument will be passed in registers.  It will
    3966                 :            :    never be set if REG_PARM_STACK_SPACE is not defined.
    3967                 :            : 
    3968                 :            :    REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
    3969                 :            :    for arguments which are passed in registers.
    3970                 :            : 
    3971                 :            :    FNDECL is the function in which the argument was defined.
    3972                 :            : 
    3973                 :            :    There are two types of rounding that are done.  The first, controlled by
    3974                 :            :    TARGET_FUNCTION_ARG_BOUNDARY, forces the offset from the start of the
    3975                 :            :    argument list to be aligned to the specific boundary (in bits).  This
    3976                 :            :    rounding affects the initial and starting offsets, but not the argument
    3977                 :            :    size.
    3978                 :            : 
    3979                 :            :    The second, controlled by TARGET_FUNCTION_ARG_PADDING and PARM_BOUNDARY,
    3980                 :            :    optionally rounds the size of the parm to PARM_BOUNDARY.  The
    3981                 :            :    initial offset is not affected by this rounding, while the size always
    3982                 :            :    is and the starting offset may be.  */
    3983                 :            : 
    3984                 :            : /*  LOCATE->OFFSET will be negative for ARGS_GROW_DOWNWARD case;
    3985                 :            :     INITIAL_OFFSET_PTR is positive because locate_and_pad_parm's
    3986                 :            :     callers pass in the total size of args so far as
    3987                 :            :     INITIAL_OFFSET_PTR.  LOCATE->SIZE is always positive.  */
    3988                 :            : 
    3989                 :            : void
    3990                 :    3702390 : locate_and_pad_parm (machine_mode passed_mode, tree type, int in_regs,
    3991                 :            :                      int reg_parm_stack_space, int partial,
    3992                 :            :                      tree fndecl ATTRIBUTE_UNUSED,
    3993                 :            :                      struct args_size *initial_offset_ptr,
    3994                 :            :                      struct locate_and_pad_arg_data *locate)
    3995                 :            : {
    3996                 :    3702390 :   tree sizetree;
    3997                 :    3702390 :   pad_direction where_pad;
    3998                 :    3702390 :   unsigned int boundary, round_boundary;
    3999                 :    3702390 :   int part_size_in_regs;
    4000                 :            : 
    4001                 :            :   /* If we have found a stack parm before we reach the end of the
    4002                 :            :      area reserved for registers, skip that area.  */
    4003                 :    3702390 :   if (! in_regs)
    4004                 :            :     {
    4005                 :    2479690 :       if (reg_parm_stack_space > 0)
    4006                 :            :         {
    4007                 :      17274 :           if (initial_offset_ptr->var
    4008                 :      17274 :               || !ordered_p (initial_offset_ptr->constant,
    4009                 :            :                              reg_parm_stack_space))
    4010                 :            :             {
    4011                 :          0 :               initial_offset_ptr->var
    4012                 :          0 :                 = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
    4013                 :            :                               ssize_int (reg_parm_stack_space));
    4014                 :          0 :               initial_offset_ptr->constant = 0;
    4015                 :            :             }
    4016                 :            :           else
    4017                 :      17274 :             initial_offset_ptr->constant
    4018                 :      17274 :               = ordered_max (initial_offset_ptr->constant,
    4019                 :      17274 :                              reg_parm_stack_space);
    4020                 :            :         }
    4021                 :            :     }
    4022                 :            : 
    4023                 :    3702390 :   part_size_in_regs = (reg_parm_stack_space == 0 ? partial : 0);
    4024                 :            : 
    4025                 :    7404770 :   sizetree = (type
    4026                 :    3702390 :               ? arg_size_in_bytes (type)
    4027                 :      35617 :               : size_int (GET_MODE_SIZE (passed_mode)));
    4028                 :    3702390 :   where_pad = targetm.calls.function_arg_padding (passed_mode, type);
    4029                 :    3702390 :   boundary = targetm.calls.function_arg_boundary (passed_mode, type);
    4030                 :    3702390 :   round_boundary = targetm.calls.function_arg_round_boundary (passed_mode,
    4031                 :            :                                                               type);
    4032                 :    3702390 :   locate->where_pad = where_pad;
    4033                 :            : 
    4034                 :            :   /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT.  */
    4035                 :    3702390 :   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
    4036                 :            :     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
    4037                 :            : 
    4038                 :    3702390 :   locate->boundary = boundary;
    4039                 :            : 
    4040                 :    3702390 :   if (SUPPORTS_STACK_ALIGNMENT)
    4041                 :            :     {
    4042                 :            :       /* stack_alignment_estimated can't change after stack has been
    4043                 :            :          realigned.  */
    4044                 :    3702390 :       if (crtl->stack_alignment_estimated < boundary)
    4045                 :            :         {
    4046                 :       5216 :           if (!crtl->stack_realign_processed)
    4047                 :       5216 :             crtl->stack_alignment_estimated = boundary;
    4048                 :            :           else
    4049                 :            :             {
    4050                 :            :               /* If stack is realigned and stack alignment value
    4051                 :            :                  hasn't been finalized, it is OK not to increase
    4052                 :            :                  stack_alignment_estimated.  The bigger alignment
    4053                 :            :                  requirement is recorded in stack_alignment_needed
    4054                 :            :                  below.  */
    4055                 :          0 :               gcc_assert (!crtl->stack_realign_finalized
    4056                 :            :                           && crtl->stack_realign_needed);
    4057                 :            :             }
    4058                 :            :         }
    4059                 :            :     }
    4060                 :            : 
    4061                 :    3702390 :   if (ARGS_GROW_DOWNWARD)
    4062                 :            :     {
    4063                 :            :       locate->slot_offset.constant = -initial_offset_ptr->constant;
    4064                 :            :       if (initial_offset_ptr->var)
    4065                 :            :         locate->slot_offset.var = size_binop (MINUS_EXPR, ssize_int (0),
    4066                 :            :                                               initial_offset_ptr->var);
    4067                 :            : 
    4068                 :            :       {
    4069                 :            :         tree s2 = sizetree;
    4070                 :            :         if (where_pad != PAD_NONE
    4071                 :            :             && (!tree_fits_uhwi_p (sizetree)
    4072                 :            :                 || (tree_to_uhwi (sizetree) * BITS_PER_UNIT) % round_boundary))
    4073                 :            :           s2 = round_up (s2, round_boundary / BITS_PER_UNIT);
    4074                 :            :         SUB_PARM_SIZE (locate->slot_offset, s2);
    4075                 :            :       }
    4076                 :            : 
    4077                 :            :       locate->slot_offset.constant += part_size_in_regs;
    4078                 :            : 
    4079                 :            :       if (!in_regs || reg_parm_stack_space > 0)
    4080                 :            :         pad_to_arg_alignment (&locate->slot_offset, boundary,
    4081                 :            :                               &locate->alignment_pad);
    4082                 :            : 
    4083                 :            :       locate->size.constant = (-initial_offset_ptr->constant
    4084                 :            :                                - locate->slot_offset.constant);
    4085                 :            :       if (initial_offset_ptr->var)
    4086                 :            :         locate->size.var = size_binop (MINUS_EXPR,
    4087                 :            :                                        size_binop (MINUS_EXPR,
    4088                 :            :                                                    ssize_int (0),
    4089                 :            :                                                    initial_offset_ptr->var),
    4090                 :            :                                        locate->slot_offset.var);
    4091                 :            : 
    4092                 :            :       /* Pad_below needs the pre-rounded size to know how much to pad
    4093                 :            :          below.  */
    4094                 :            :       locate->offset = locate->slot_offset;
    4095                 :            :       if (where_pad == PAD_DOWNWARD)
    4096                 :            :         pad_below (&locate->offset, passed_mode, sizetree);
    4097                 :            : 
    4098                 :            :     }
    4099                 :            :   else
    4100                 :            :     {
    4101                 :    3702390 :       if (!in_regs || reg_parm_stack_space > 0)
    4102                 :    2572940 :         pad_to_arg_alignment (initial_offset_ptr, boundary,
    4103                 :            :                               &locate->alignment_pad);
    4104                 :    3702390 :       locate->slot_offset = *initial_offset_ptr;
    4105                 :            : 
    4106                 :            : #ifdef PUSH_ROUNDING
    4107                 :    3702390 :       if (passed_mode != BLKmode)
    4108                 :    3432060 :         sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
    4109                 :            : #endif
    4110                 :            : 
    4111                 :            :       /* Pad_below needs the pre-rounded size to know how much to pad below
    4112                 :            :          so this must be done before rounding up.  */
    4113                 :    3702390 :       locate->offset = locate->slot_offset;
    4114                 :    3702390 :       if (where_pad == PAD_DOWNWARD)
    4115                 :          0 :         pad_below (&locate->offset, passed_mode, sizetree);
    4116                 :            : 
    4117                 :    3702390 :       if (where_pad != PAD_NONE
    4118                 :    3702390 :           && (!tree_fits_uhwi_p (sizetree)
    4119                 :    3702390 :               || (tree_to_uhwi (sizetree) * BITS_PER_UNIT) % round_boundary))
    4120                 :      16059 :         sizetree = round_up (sizetree, round_boundary / BITS_PER_UNIT);
    4121                 :            : 
    4122                 :    3702390 :       ADD_PARM_SIZE (locate->size, sizetree);
    4123                 :            : 
    4124                 :    3702390 :       locate->size.constant -= part_size_in_regs;
    4125                 :            :     }
    4126                 :            : 
    4127                 :    3702390 :   locate->offset.constant
    4128                 :    3702390 :     += targetm.calls.function_arg_offset (passed_mode, type);
    4129                 :    3702390 : }
    4130                 :            : 
    4131                 :            : /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
    4132                 :            :    BOUNDARY is measured in bits, but must be a multiple of a storage unit.  */
    4133                 :            : 
    4134                 :            : static void
    4135                 :    2572940 : pad_to_arg_alignment (struct args_size *offset_ptr, int boundary,
    4136                 :            :                       struct args_size *alignment_pad)
    4137                 :            : {
    4138                 :    2572940 :   tree save_var = NULL_TREE;
    4139                 :    2572940 :   poly_int64 save_constant = 0;
    4140                 :    2572940 :   int boundary_in_bytes = boundary / BITS_PER_UNIT;
    4141                 :    2572940 :   poly_int64 sp_offset = STACK_POINTER_OFFSET;
    4142                 :            : 
    4143                 :            : #ifdef SPARC_STACK_BOUNDARY_HACK
    4144                 :            :   /* ??? The SPARC port may claim a STACK_BOUNDARY higher than
    4145                 :            :      the real alignment of %sp.  However, when it does this, the
    4146                 :            :      alignment of %sp+STACK_POINTER_OFFSET is STACK_BOUNDARY.  */
    4147                 :            :   if (SPARC_STACK_BOUNDARY_HACK)
    4148                 :            :     sp_offset = 0;
    4149                 :            : #endif
    4150                 :            : 
    4151                 :    4006410 :   if (boundary > PARM_BOUNDARY)
    4152                 :            :     {
    4153                 :     102850 :       save_var = offset_ptr->var;
    4154                 :     102850 :       save_constant = offset_ptr->constant;
    4155                 :            :     }
    4156                 :            : 
    4157                 :    2572940 :   alignment_pad->var = NULL_TREE;
    4158                 :    2572940 :   alignment_pad->constant = 0;
    4159                 :            : 
    4160                 :    2572940 :   if (boundary > BITS_PER_UNIT)
    4161                 :            :     {
    4162                 :    2572940 :       int misalign;
    4163                 :    2572940 :       if (offset_ptr->var
    4164                 :    2572940 :           || !known_misalignment (offset_ptr->constant + sp_offset,
    4165                 :            :                                   boundary_in_bytes, &misalign))
    4166                 :            :         {
    4167                 :          0 :           tree sp_offset_tree = ssize_int (sp_offset);
    4168                 :          0 :           tree offset = size_binop (PLUS_EXPR,
    4169                 :            :                                     ARGS_SIZE_TREE (*offset_ptr),
    4170                 :            :                                     sp_offset_tree);
    4171                 :          0 :           tree rounded;
    4172                 :          0 :           if (ARGS_GROW_DOWNWARD)
    4173                 :            :             rounded = round_down (offset, boundary / BITS_PER_UNIT);
    4174                 :            :           else
    4175                 :          0 :             rounded = round_up   (offset, boundary / BITS_PER_UNIT);
    4176                 :            : 
    4177                 :          0 :           offset_ptr->var = size_binop (MINUS_EXPR, rounded, sp_offset_tree);
    4178                 :            :           /* ARGS_SIZE_TREE includes constant term.  */
    4179                 :          0 :           offset_ptr->constant = 0;
    4180                 :          0 :           if (boundary > PARM_BOUNDARY)
    4181                 :          0 :             alignment_pad->var = size_binop (MINUS_EXPR, offset_ptr->var,
    4182                 :            :                                              save_var);
    4183                 :            :         }
    4184                 :            :       else
    4185                 :            :         {
    4186                 :    2572940 :           if (ARGS_GROW_DOWNWARD)
    4187                 :            :             offset_ptr->constant -= misalign;
    4188                 :            :           else
    4189                 :    2572940 :             offset_ptr->constant += -misalign & (boundary_in_bytes - 1);
    4190                 :            : 
    4191                 :    2572940 :           if (boundary > PARM_BOUNDARY)
    4192                 :     102850 :             alignment_pad->constant = offset_ptr->constant - save_constant;
    4193                 :            :         }
    4194                 :            :     }
    4195                 :    2572940 : }
    4196                 :            : 
    4197                 :            : static void
    4198                 :          0 : pad_below (struct args_size *offset_ptr, machine_mode passed_mode, tree sizetree)
    4199                 :            : {
    4200                 :          0 :   unsigned int align = PARM_BOUNDARY / BITS_PER_UNIT;
    4201                 :          0 :   int misalign;
    4202                 :          0 :   if (passed_mode != BLKmode
    4203                 :          0 :       && known_misalignment (GET_MODE_SIZE (passed_mode), align, &misalign))
    4204                 :          0 :     offset_ptr->constant += -misalign & (align - 1);
    4205                 :            :   else
    4206                 :            :     {
    4207                 :          0 :       if (TREE_CODE (sizetree) != INTEGER_CST
    4208                 :          0 :           || (TREE_INT_CST_LOW (sizetree) & (align - 1)) != 0)
    4209                 :            :         {
    4210                 :            :           /* Round the size up to multiple of PARM_BOUNDARY bits.  */
    4211                 :          0 :           tree s2 = round_up (sizetree, align);
    4212                 :            :           /* Add it in.  */
    4213                 :          0 :           ADD_PARM_SIZE (*offset_ptr, s2);
    4214                 :          0 :           SUB_PARM_SIZE (*offset_ptr, sizetree);
    4215                 :            :         }
    4216                 :            :     }
    4217                 :          0 : }
    4218                 :            : 
    4219                 :            : 
    4220                 :            : /* True if register REGNO was alive at a place where `setjmp' was
    4221                 :            :    called and was set more than once or is an argument.  Such regs may
    4222                 :            :    be clobbered by `longjmp'.  */
    4223                 :            : 
    4224                 :            : static bool
    4225                 :         48 : regno_clobbered_at_setjmp (bitmap setjmp_crosses, int regno)
    4226                 :            : {
    4227                 :            :   /* There appear to be cases where some local vars never reach the
    4228                 :            :      backend but have bogus regnos.  */
    4229                 :         48 :   if (regno >= max_reg_num ())
    4230                 :            :     return false;
    4231                 :            : 
    4232                 :         48 :   return ((REG_N_SETS (regno) > 1
    4233                 :         46 :            || REGNO_REG_SET_P (df_get_live_out (ENTRY_BLOCK_PTR_FOR_FN (cfun)),
    4234                 :            :                                regno))
    4235                 :         48 :           && REGNO_REG_SET_P (setjmp_crosses, regno));
    4236                 :            : }
    4237                 :            : 
    4238                 :            : /* Walk the tree of blocks describing the binding levels within a
    4239                 :            :    function and warn about variables the might be killed by setjmp or
    4240                 :            :    vfork.  This is done after calling flow_analysis before register
    4241                 :            :    allocation since that will clobber the pseudo-regs to hard
    4242                 :            :    regs.  */
    4243                 :            : 
    4244                 :            : static void
    4245                 :         70 : setjmp_vars_warning (bitmap setjmp_crosses, tree block)
    4246                 :            : {
    4247                 :         70 :   tree decl, sub;
    4248                 :            : 
    4249                 :        181 :   for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
    4250                 :            :     {
    4251                 :        111 :       if (VAR_P (decl)
    4252                 :        111 :           && DECL_RTL_SET_P (decl)
    4253                 :         23 :           && REG_P (DECL_RTL (decl))
    4254                 :        127 :           && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl))))
    4255                 :          1 :         warning (OPT_Wclobbered, "variable %q+D might be clobbered by"
    4256                 :            :                  " %<longjmp%> or %<vfork%>", decl);
    4257                 :            :     }
    4258                 :            : 
    4259                 :        120 :   for (sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub))
    4260                 :         50 :     setjmp_vars_warning (setjmp_crosses, sub);
    4261                 :         70 : }
    4262                 :            : 
    4263                 :            : /* Do the appropriate part of setjmp_vars_warning
    4264                 :            :    but for arguments instead of local variables.  */
    4265                 :            : 
    4266                 :            : static void
    4267                 :         20 : setjmp_args_warning (bitmap setjmp_crosses)
    4268                 :            : {
    4269                 :         20 :   tree decl;
    4270                 :         52 :   for (decl = DECL_ARGUMENTS (current_function_decl);
    4271                 :         52 :        decl; decl = DECL_CHAIN (decl))
    4272                 :         32 :     if (DECL_RTL (decl) != 0
    4273                 :         32 :         && REG_P (DECL_RTL (decl))
    4274                 :         64 :         && regno_clobbered_at_setjmp (setjmp_crosses, REGNO (DECL_RTL (decl))))
    4275                 :          0 :       warning (OPT_Wclobbered,
    4276                 :            :                "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>",
    4277                 :            :                decl);
    4278                 :         20 : }
    4279                 :            : 
    4280                 :            : /* Generate warning messages for variables live across setjmp.  */
    4281                 :            : 
    4282                 :            : void
    4283                 :      41302 : generate_setjmp_warnings (void)
    4284                 :            : {
    4285                 :      41302 :   bitmap setjmp_crosses = regstat_get_setjmp_crosses ();
    4286                 :            : 
    4287                 :      41302 :   if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS
    4288                 :      41302 :       || bitmap_empty_p (setjmp_crosses))
    4289                 :            :     return;
    4290                 :            : 
    4291                 :         20 :   setjmp_vars_warning (setjmp_crosses, DECL_INITIAL (current_function_decl));
    4292                 :         20 :   setjmp_args_warning (setjmp_crosses);
    4293                 :            : }
    4294                 :            : 
    4295                 :            : 
    4296                 :            : /* Reverse the order of elements in the fragment chain T of blocks,
    4297                 :            :    and return the new head of the chain (old last element).
    4298                 :            :    In addition to that clear BLOCK_SAME_RANGE flags when needed
    4299                 :            :    and adjust BLOCK_SUPERCONTEXT from the super fragment to
    4300                 :            :    its super fragment origin.  */
    4301                 :            : 
    4302                 :            : static tree
    4303                 :    3088160 : block_fragments_nreverse (tree t)
    4304                 :            : {
    4305                 :    3088160 :   tree prev = 0, block, next, prev_super = 0;
    4306                 :    3088160 :   tree super = BLOCK_SUPERCONTEXT (t);
    4307                 :    3088160 :   if (BLOCK_FRAGMENT_ORIGIN (super))
    4308                 :    2493270 :     super = BLOCK_FRAGMENT_ORIGIN (super);
    4309                 :    9133800 :   for (block = t; block; block = next)
    4310                 :            :     {
    4311                 :    6045640 :       next = BLOCK_FRAGMENT_CHAIN (block);
    4312                 :    6045640 :       BLOCK_FRAGMENT_CHAIN (block) = prev;
    4313                 :    2957480 :       if ((prev && !BLOCK_SAME_RANGE (prev))
    4314                 :    7698520 :           || (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (block))
    4315                 :            :               != prev_super))
    4316                 :    1787280 :         BLOCK_SAME_RANGE (block) = 0;
    4317                 :    6045640 :       prev_super = BLOCK_SUPERCONTEXT (block);
    4318                 :    6045640 :       BLOCK_SUPERCONTEXT (block) = super;
    4319                 :    6045640 :       prev = block;
    4320                 :            :     }
    4321                 :    3088160 :   t = BLOCK_FRAGMENT_ORIGIN (t);
    4322                 :    3088160 :   if (BLOCK_FRAGMENT_CHAIN (BLOCK_SUPERCONTEXT (t))
    4323                 :            :       != prev_super)
    4324                 :    1040140 :     BLOCK_SAME_RANGE (t) = 0;
    4325                 :    3088160 :   BLOCK_SUPERCONTEXT (t) = super;
    4326                 :    3088160 :   return prev;
    4327                 :            : }
    4328                 :            : 
    4329                 :            : /* Reverse the order of elements in the chain T of blocks,
    4330                 :            :    and return the new head of the chain (old last element).
    4331                 :            :    Also do the same on subblocks and reverse the order of elements
    4332                 :            :    in BLOCK_FRAGMENT_CHAIN as well.  */
    4333                 :            : 
    4334                 :            : static tree
    4335                 :   13352300 : blocks_nreverse_all (tree t)
    4336                 :            : {
    4337                 :   13352300 :   tree prev = 0, block, next;
    4338                 :   26316200 :   for (block = t; block; block = next)
    4339                 :            :     {
    4340                 :   12963900 :       next = BLOCK_CHAIN (block);
    4341                 :   12963900 :       BLOCK_CHAIN (block) = prev;
    4342                 :   12963900 :       if (BLOCK_FRAGMENT_CHAIN (block)
    4343                 :   12963900 :           && BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE)
    4344                 :            :         {
    4345                 :    3088160 :           BLOCK_FRAGMENT_CHAIN (block)
    4346                 :    3088160 :             = block_fragments_nreverse (BLOCK_FRAGMENT_CHAIN (block));
    4347                 :    3088160 :           if (!BLOCK_SAME_RANGE (BLOCK_FRAGMENT_CHAIN (block)))
    4348                 :    1500760 :             BLOCK_SAME_RANGE (block) = 0;
    4349                 :            :         }
    4350                 :   12963900 :       BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
    4351                 :   12963900 :       prev = block;
    4352                 :            :     }
    4353                 :   13352300 :   return prev;
    4354                 :            : }
    4355                 :            : 
    4356                 :            : 
    4357                 :            : /* Identify BLOCKs referenced by more than one NOTE_INSN_BLOCK_{BEG,END},
    4358                 :            :    and create duplicate blocks.  */
    4359                 :            : /* ??? Need an option to either create block fragments or to create
    4360                 :            :    abstract origin duplicates of a source block.  It really depends
    4361                 :            :    on what optimization has been performed.  */
    4362                 :            : 
    4363                 :            : void
    4364                 :     388437 : reorder_blocks (void)
    4365                 :            : {
    4366                 :     388437 :   tree block = DECL_INITIAL (current_function_decl);
    4367                 :            : 
    4368                 :     388437 :   if (block == NULL_TREE)
    4369                 :          0 :     return;
    4370                 :            : 
    4371                 :     776874 :   auto_vec<tree, 10> block_stack;
    4372                 :            : 
    4373                 :            :   /* Reset the TREE_ASM_WRITTEN bit for all blocks.  */
    4374                 :     388437 :   clear_block_marks (block);
    4375                 :            : 
    4376                 :            :   /* Prune the old trees away, so that they don't get in the way.  */
    4377                 :     388437 :   BLOCK_SUBBLOCKS (block) = NULL_TREE;
    4378                 :     388437 :   BLOCK_CHAIN (block) = NULL_TREE;
    4379                 :            : 
    4380                 :            :   /* Recreate the block tree from the note nesting.  */
    4381                 :     388437 :   reorder_blocks_1 (get_insns (), block, &block_stack);
    4382                 :     388437 :   BLOCK_SUBBLOCKS (block) = blocks_nreverse_all (BLOCK_SUBBLOCKS (block));
    4383                 :            : }
    4384                 :            : 
    4385                 :            : /* Helper function for reorder_blocks.  Reset TREE_ASM_WRITTEN.  */
    4386                 :            : 
    4387                 :            : void
    4388                 :   15020400 : clear_block_marks (tree block)
    4389                 :            : {
    4390                 :   27789700 :   while (block)
    4391                 :            :     {
    4392                 :   12769200 :       TREE_ASM_WRITTEN (block) = 0;
    4393                 :   12769200 :       clear_block_marks (BLOCK_SUBBLOCKS (block));
    4394                 :   12769200 :       block = BLOCK_CHAIN (block);
    4395                 :            :     }
    4396                 :   15020400 : }
    4397                 :            : 
    4398                 :            : static void
    4399                 :     388437 : reorder_blocks_1 (rtx_insn *insns, tree current_block,
    4400                 :            :                   vec<tree> *p_block_stack)
    4401                 :            : {
    4402                 :     388437 :   rtx_insn *insn;
    4403                 :     388437 :   tree prev_beg = NULL_TREE, prev_end = NULL_TREE;
    4404                 :            : 
    4405                 :  230125000 :   for (insn = insns; insn; insn = NEXT_INSN (insn))
    4406                 :            :     {
    4407                 :  114868000 :       if (NOTE_P (insn))
    4408                 :            :         {
    4409                 :   79417000 :           if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_BEG)
    4410                 :            :             {
    4411                 :   12963900 :               tree block = NOTE_BLOCK (insn);
    4412                 :   12963900 :               tree origin;
    4413                 :            : 
    4414                 :   12963900 :               gcc_assert (BLOCK_FRAGMENT_ORIGIN (block) == NULL_TREE);
    4415                 :   12963900 :               origin = block;
    4416                 :            : 
    4417                 :   12963900 :               if (prev_end)
    4418                 :     650789 :                 BLOCK_SAME_RANGE (prev_end) = 0;
    4419                 :   12963900 :               prev_end = NULL_TREE;
    4420                 :            : 
    4421                 :            :               /* If we have seen this block before, that means it now
    4422                 :            :                  spans multiple address regions.  Create a new fragment.  */
    4423                 :   12963900 :               if (TREE_ASM_WRITTEN (block))
    4424                 :            :                 {
    4425                 :    6045640 :                   tree new_block = copy_node (block);
    4426                 :            : 
    4427                 :    6045640 :                   BLOCK_SAME_RANGE (new_block) = 0;
    4428                 :    6045640 :                   BLOCK_FRAGMENT_ORIGIN (new_block) = origin;
    4429                 :    6045640 :                   BLOCK_FRAGMENT_CHAIN (new_block)
    4430                 :    6045640 :                     = BLOCK_FRAGMENT_CHAIN (origin);
    4431                 :    6045640 :                   BLOCK_FRAGMENT_CHAIN (origin) = new_block;
    4432                 :            : 
    4433                 :    6045640 :                   NOTE_BLOCK (insn) = new_block;
    4434                 :    6045640 :                   block = new_block;
    4435                 :            :                 }
    4436                 :            : 
    4437                 :   12963900 :               if (prev_beg == current_block && prev_beg)
    4438                 :    8224630 :                 BLOCK_SAME_RANGE (block) = 1;
    4439                 :            : 
    4440                 :   12963900 :               prev_beg = origin;
    4441                 :            : 
    4442                 :   12963900 :               BLOCK_SUBBLOCKS (block) = 0;
    4443                 :   12963900 :               TREE_ASM_WRITTEN (block) = 1;
    4444                 :            :               /* When there's only one block for the entire function,
    4445                 :            :                  current_block == block and we mustn't do this, it
    4446                 :            :                  will cause infinite recursion.  */
    4447                 :   12963900 :               if (block != current_block)
    4448                 :            :                 {
    4449                 :   12963900 :                   tree super;
    4450                 :   12963900 :                   if (block != origin)
    4451                 :    6045640 :                     gcc_assert (BLOCK_SUPERCONTEXT (origin) == current_block
    4452                 :            :                                 || BLOCK_FRAGMENT_ORIGIN (BLOCK_SUPERCONTEXT
    4453                 :            :                                                                       (origin))
    4454                 :            :                                    == current_block);
    4455                 :   12963900 :                   if (p_block_stack->is_empty ())
    4456                 :            :                     super = current_block;
    4457                 :            :                   else
    4458                 :            :                     {
    4459                 :   11392700 :                       super = p_block_stack->last ();
    4460                 :   17638200 :                       gcc_assert (super == current_block
    4461                 :            :                                   || BLOCK_FRAGMENT_ORIGIN (super)
    4462                 :            :                                      == current_block);
    4463                 :            :                     }
    4464                 :   12963900 :                   BLOCK_SUPERCONTEXT (block) = super;
    4465                 :   12963900 :                   BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
    4466                 :   12963900 :                   BLOCK_SUBBLOCKS (current_block) = block;
    4467                 :   12963900 :                   current_block = origin;
    4468                 :            :                 }
    4469                 :   12963900 :               p_block_stack->safe_push (block);
    4470                 :            :             }
    4471                 :   66453100 :           else if (NOTE_KIND (insn) == NOTE_INSN_BLOCK_END)
    4472                 :            :             {
    4473                 :   12963900 :               NOTE_BLOCK (insn) = p_block_stack->pop ();
    4474                 :   12963900 :               current_block = BLOCK_SUPERCONTEXT (current_block);
    4475                 :   12963900 :               if (BLOCK_FRAGMENT_ORIGIN (current_block))
    4476                 :    2449310 :                 current_block = BLOCK_FRAGMENT_ORIGIN (current_block);
    4477                 :   12963900 :               prev_beg = NULL_TREE;
    4478                 :   12963900 :               prev_end = BLOCK_SAME_RANGE (NOTE_BLOCK (insn))
    4479                 :   12963900 :                          ? NOTE_BLOCK (insn) : NULL_TREE;
    4480                 :            :             }
    4481                 :            :         }
    4482                 :            :       else
    4483                 :            :         {
    4484                 :   35451200 :           prev_beg = NULL_TREE;
    4485                 :   35451200 :           if (prev_end)
    4486                 :     503353 :             BLOCK_SAME_RANGE (prev_end) = 0;
    4487                 :            :           prev_end = NULL_TREE;
    4488                 :            :         }
    4489                 :            :     }
    4490                 :     388437 : }
    4491                 :            : 
    4492                 :            : /* Reverse the order of elements in the chain T of blocks,
    4493                 :            :    and return the new head of the chain (old last element).  */
    4494                 :            : 
    4495                 :            : tree
    4496                 :   16138900 : blocks_nreverse (tree t)
    4497                 :            : {
    4498                 :   16138900 :   tree prev = 0, block, next;
    4499                 :   27883500 :   for (block = t; block; block = next)
    4500                 :            :     {
    4501                 :   11744700 :       next = BLOCK_CHAIN (block);
    4502                 :   11744700 :       BLOCK_CHAIN (block) = prev;
    4503                 :   11744700 :       prev = block;
    4504                 :            :     }
    4505                 :   16138900 :   return prev;
    4506                 :            : }
    4507                 :            : 
    4508                 :            : /* Concatenate two chains of blocks (chained through BLOCK_CHAIN)
    4509                 :            :    by modifying the last node in chain 1 to point to chain 2.  */
    4510                 :            : 
    4511                 :            : tree
    4512                 :    6855580 : block_chainon (tree op1, tree op2)
    4513                 :            : {
    4514                 :    6855580 :   tree t1;
    4515                 :            : 
    4516                 :    6855580 :   if (!op1)
    4517                 :            :     return op2;
    4518                 :     390485 :   if (!op2)
    4519                 :            :     return op1;
    4520                 :            : 
    4521                 :   11360100 :   for (t1 = op1; BLOCK_CHAIN (t1); t1 = BLOCK_CHAIN (t1))
    4522                 :   10969600 :     continue;
    4523                 :     390485 :   BLOCK_CHAIN (t1) = op2;
    4524                 :            : 
    4525                 :            : #ifdef ENABLE_TREE_CHECKING
    4526                 :     390485 :   {
    4527                 :     390485 :     tree t2;
    4528                 :     794362 :     for (t2 = op2; t2; t2 = BLOCK_CHAIN (t2))
    4529                 :     403877 :       gcc_assert (t2 != t1);
    4530                 :            :   }
    4531                 :            : #endif
    4532                 :            : 
    4533                 :            :   return op1;
    4534                 :            : }
    4535                 :            : 
    4536                 :            : /* Count the subblocks of the list starting with BLOCK.  If VECTOR is
    4537                 :            :    non-NULL, list them all into VECTOR, in a depth-first preorder
    4538                 :            :    traversal of the block tree.  Also clear TREE_ASM_WRITTEN in all
    4539                 :            :    blocks.  */
    4540                 :            : 
    4541                 :            : static int
    4542                 :   64324000 : all_blocks (tree block, tree *vector)
    4543                 :            : {
    4544                 :   64324000 :   int n_blocks = 0;
    4545                 :            : 
    4546                 :  126014000 :   while (block)
    4547                 :            :     {
    4548                 :   61689800 :       TREE_ASM_WRITTEN (block) = 0;
    4549                 :            : 
    4550                 :            :       /* Record this block.  */
    4551                 :   61689800 :       if (vector)
    4552                 :   30844900 :         vector[n_blocks] = block;
    4553                 :            : 
    4554                 :   61689800 :       ++n_blocks;
    4555                 :            : 
    4556                 :            :       /* Record the subblocks, and their subblocks...  */
    4557                 :  123380000 :       n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
    4558                 :   30844900 :                               vector ? vector + n_blocks : 0);
    4559                 :   61689800 :       block = BLOCK_CHAIN (block);
    4560                 :            :     }
    4561                 :            : 
    4562                 :   64324000 :   return n_blocks;
    4563                 :            : }
    4564                 :            : 
    4565                 :            : /* Return a vector containing all the blocks rooted at BLOCK.  The
    4566                 :            :    number of elements in the vector is stored in N_BLOCKS_P.  The
    4567                 :            :    vector is dynamically allocated; it is the caller's responsibility
    4568                 :            :    to call `free' on the pointer returned.  */
    4569                 :            : 
    4570                 :            : static tree *
    4571                 :    1317060 : get_block_vector (tree block, int *n_blocks_p)
    4572                 :            : {
    4573                 :    1317060 :   tree *block_vector;
    4574                 :            : 
    4575                 :    1317060 :   *n_blocks_p = all_blocks (block, NULL);
    4576                 :    1317060 :   block_vector = XNEWVEC (tree, *n_blocks_p);
    4577                 :    1317060 :   all_blocks (block, block_vector);
    4578                 :            : 
    4579                 :    1317060 :   return block_vector;
    4580                 :            : }
    4581                 :            : 
    4582                 :            : static GTY(()) int next_block_index = 2;
    4583                 :            : 
    4584                 :            : /* Set BLOCK_NUMBER for all the blocks in FN.  */
    4585                 :            : 
    4586                 :            : void
    4587                 :    1317060 : number_blocks (tree fn)
    4588                 :            : {
    4589                 :    1317060 :   int i;
    4590                 :    1317060 :   int n_blocks;
    4591                 :    1317060 :   tree *block_vector;
    4592                 :            : 
    4593                 :            :   /* For XCOFF debugging output, we start numbering the blocks
    4594                 :            :      from 1 within each function, rather than keeping a running
    4595                 :            :      count.  */
    4596                 :            : #if defined (XCOFF_DEBUGGING_INFO)
    4597                 :            :   if (write_symbols == XCOFF_DEBUG)
    4598                 :            :     next_block_index = 1;
    4599                 :            : #endif
    4600                 :            : 
    4601                 :    1317060 :   block_vector = get_block_vector (DECL_INITIAL (fn), &n_blocks);
    4602                 :            : 
    4603                 :            :   /* The top-level BLOCK isn't numbered at all.  */
    4604                 :   30844900 :   for (i = 1; i < n_blocks; ++i)
    4605                 :            :     /* We number the blocks from two.  */
    4606                 :   29527900 :     BLOCK_NUMBER (block_vector[i]) = next_block_index++;
    4607                 :            : 
    4608                 :    1317060 :   free (block_vector);
    4609                 :            : 
    4610                 :    1317060 :   return;
    4611                 :            : }
    4612                 :            : 
    4613                 :            : /* If VAR is present in a subblock of BLOCK, return the subblock.  */
    4614                 :            : 
    4615                 :            : DEBUG_FUNCTION tree
    4616                 :          0 : debug_find_var_in_block_tree (tree var, tree block)
    4617                 :            : {
    4618                 :          0 :   tree t;
    4619                 :            : 
    4620                 :          0 :   for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
    4621                 :          0 :     if (t == var)
    4622                 :            :       return block;
    4623                 :            : 
    4624                 :          0 :   for (t = BLOCK_SUBBLOCKS (block); t; t = TREE_CHAIN (t))
    4625                 :            :     {
    4626                 :          0 :       tree ret = debug_find_var_in_block_tree (var, t);
    4627                 :          0 :       if (ret)
    4628                 :          0 :         return ret;
    4629                 :            :     }
    4630                 :            : 
    4631                 :            :   return NULL_TREE;
    4632                 :            : }
    4633                 :            : 
    4634                 :            : /* Keep track of whether we're in a dummy function context.  If we are,
    4635                 :            :    we don't want to invoke the set_current_function hook, because we'll
    4636                 :            :    get into trouble if the hook calls target_reinit () recursively or
    4637                 :            :    when the initial initialization is not yet complete.  */
    4638                 :            : 
    4639                 :            : static bool in_dummy_function;
    4640                 :            : 
    4641                 :            : /* Invoke the target hook when setting cfun.  Update the optimization options
    4642                 :            :    if the function uses different options than the default.  */
    4643                 :            : 
    4644                 :            : static void
    4645                 :  231647000 : invoke_set_current_function_hook (tree fndecl)
    4646                 :            : {
    4647                 :  231647000 :   if (!in_dummy_function)
    4648                 :            :     {
    4649                 :  231343000 :       tree opts = ((fndecl)
    4650                 :  348739000 :                    ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl)
    4651                 :  231343000 :                    : optimization_default_node);
    4652                 :            : 
    4653                 :  231343000 :       if (!opts)
    4654                 :  113443000 :         opts = optimization_default_node;
    4655                 :            : 
    4656                 :            :       /* Change optimization options if needed.  */
    4657                 :  231343000 :       if (optimization_current_node != opts)
    4658                 :            :         {
    4659                 :    1956280 :           optimization_current_node = opts;
    4660                 :    1956280 :           cl_optimization_restore (&global_options, TREE_OPTIMIZATION (opts));
    4661                 :            :         }
    4662                 :            : 
    4663                 :  231343000 :       targetm.set_current_function (fndecl);
    4664                 :  231343000 :       this_fn_optabs = this_target_optabs;
    4665                 :            : 
    4666                 :            :       /* Initialize global alignment variables after op.  */
    4667                 :  231343000 :       parse_alignment_opts ();
    4668                 :            : 
    4669                 :  231343000 :       if (opts != optimization_default_node)
    4670                 :            :         {
    4671                 :     992243 :           init_tree_optimization_optabs (opts);
    4672                 :     992243 :           if (TREE_OPTIMIZATION_OPTABS (opts))
    4673                 :       1842 :             this_fn_optabs = (struct target_optabs *)
    4674                 :       1842 :               TREE_OPTIMIZATION_OPTABS (opts);
    4675                 :            :         }
    4676                 :            :     }
    4677                 :  231647000 : }
    4678                 :            : 
    4679                 :            : /* cfun should never be set directly; use this function.  */
    4680                 :            : 
    4681                 :            : void
    4682                 :  858733000 : set_cfun (struct function *new_cfun, bool force)
    4683                 :            : {
    4684                 :  858733000 :   if (cfun != new_cfun || force)
    4685                 :            :     {
    4686                 :  190537000 :       cfun = new_cfun;
    4687                 :  190537000 :       invoke_set_current_function_hook (new_cfun ? new_cfun->decl : NULL_TREE);
    4688                 :  190537000 :       redirect_edge_var_map_empty ();
    4689                 :            :     }
    4690                 :  858733000 : }
    4691                 :            : 
    4692                 :            : /* Initialized with NOGC, making this poisonous to the garbage collector.  */
    4693                 :            : 
    4694                 :            : static vec<function *> cfun_stack;
    4695                 :            : 
    4696                 :            : /* Push the current cfun onto the stack, and set cfun to new_cfun.  Also set
    4697                 :            :    current_function_decl accordingly.  */
    4698                 :            : 
    4699                 :            : void
    4700                 :  394471000 : push_cfun (struct function *new_cfun)
    4701                 :            : {
    4702                 :  394471000 :   gcc_assert ((!cfun && !current_function_decl)
    4703                 :            :               || (cfun && current_function_decl == cfun->decl));
    4704                 :  394471000 :   cfun_stack.safe_push (cfun);
    4705                 :  394471000 :   current_function_decl = new_cfun ? new_cfun->decl : NULL_TREE;
    4706                 :  394471000 :   set_cfun (new_cfun);
    4707                 :  394471000 : }
    4708                 :            : 
    4709                 :            : /* Pop cfun from the stack.  Also set current_function_decl accordingly.  */
    4710                 :            : 
    4711                 :            : void
    4712                 :  395074000 : pop_cfun (void)
    4713                 :            : {
    4714                 :  395074000 :   struct function *new_cfun = cfun_stack.pop ();
    4715                 :            :   /* When in_dummy_function, we do have a cfun but current_function_decl is
    4716                 :            :      NULL.  We also allow pushing NULL cfun and subsequently changing
    4717                 :            :      current_function_decl to something else and have both restored by
    4718                 :            :      pop_cfun.  */
    4719                 :  395074000 :   gcc_checking_assert (in_dummy_function
    4720                 :            :                        || !cfun
    4721                 :            :                        || current_function_decl == cfun->decl);
    4722                 :  395074000 :   set_cfun (new_cfun);
    4723                 :  395074000 :   current_function_decl = new_cfun ? new_cfun->decl : NULL_TREE;
    4724                 :  395074000 : }
    4725                 :            : 
    4726                 :            : /* Return value of funcdef and increase it.  */
    4727                 :            : int
    4728                 :   40957700 : get_next_funcdef_no (void)
    4729                 :            : {
    4730                 :   40957700 :   return funcdef_no++;
    4731                 :            : }
    4732                 :            : 
    4733                 :            : /* Return value of funcdef.  */
    4734                 :            : int
    4735                 :          0 : get_last_funcdef_no (void)
    4736                 :            : {
    4737                 :          0 :   return funcdef_no;
    4738                 :            : }
    4739                 :            : 
    4740                 :            : /* Allocate and initialize the stack usage info data structure for the
    4741                 :            :    current function.  */
    4742                 :            : static void
    4743                 :         50 : allocate_stack_usage_info (void)
    4744                 :            : {
    4745                 :         50 :   gcc_assert (!cfun->su);
    4746                 :         50 :   cfun->su = ggc_cleared_alloc<stack_usage> ();
    4747                 :         50 :   cfun->su->static_stack_size = -1;
    4748                 :         50 : }
    4749                 :            : 
    4750                 :            : /* Allocate a function structure for FNDECL and set its contents
    4751                 :            :    to the defaults.  Set cfun to the newly-allocated object.
    4752                 :            :    Some of the helper functions invoked during initialization assume
    4753                 :            :    that cfun has already been set.  Therefore, assign the new object
    4754                 :            :    directly into cfun and invoke the back end hook explicitly at the
    4755                 :            :    very end, rather than initializing a temporary and calling set_cfun
    4756                 :            :    on it.
    4757                 :            : 
    4758                 :            :    ABSTRACT_P is true if this is a function that will never be seen by
    4759                 :            :    the middle-end.  Such functions are front-end concepts (like C++
    4760                 :            :    function templates) that do not correspond directly to functions
    4761                 :            :    placed in object files.  */
    4762                 :            : 
    4763                 :            : void
    4764                 :   41109400 : allocate_struct_function (tree fndecl, bool abstract_p)
    4765                 :            : {
    4766                 :   82067100 :   tree fntype = fndecl ? TREE_TYPE (fndecl) : NULL_TREE;
    4767                 :            : 
    4768                 :   41109400 :   cfun = ggc_cleared_alloc<function> ();
    4769                 :            : 
    4770                 :   41109400 :   init_eh_for_function ();
    4771                 :            : 
    4772                 :   41109400 :   if (init_machine_status)
    4773                 :   41109400 :     cfun->machine = (*init_machine_status) ();
    4774                 :            : 
    4775                 :            : #ifdef OVERRIDE_ABI_FORMAT
    4776                 :   41109400 :   OVERRIDE_ABI_FORMAT (fndecl);
    4777                 :            : #endif
    4778                 :            : 
    4779                 :   41109400 :   if (fndecl != NULL_TREE)
    4780                 :            :     {
    4781                 :   40957700 :       DECL_STRUCT_FUNCTION (fndecl) = cfun;
    4782                 :   40957700 :       cfun->decl = fndecl;
    4783                 :   40957700 :       current_function_funcdef_no = get_next_funcdef_no ();
    4784                 :            :     }
    4785                 :            : 
    4786                 :   41109400 :   invoke_set_current_function_hook (fndecl);
    4787                 :            : 
    4788                 :   41109400 :   if (fndecl != NULL_TREE)
    4789                 :            :     {
    4790                 :   40957700 :       tree result = DECL_RESULT (fndecl);
    4791                 :            : 
    4792                 :   40957700 :       if (!abstract_p)
    4793                 :            :         {
    4794                 :            :           /* Now that we have activated any function-specific attributes
    4795                 :            :              that might affect layout, particularly vector modes, relayout
    4796                 :            :              each of the parameters and the result.  */
    4797                 :   35158200 :           relayout_decl (result);
    4798                 :  198822000 :           for (tree parm = DECL_ARGUMENTS (fndecl); parm;
    4799                 :   81832000 :                parm = DECL_CHAIN (parm))
    4800                 :   81832000 :             relayout_decl (parm);
    4801                 :            : 
    4802                 :            :           /* Similarly relayout the function decl.  */
    4803                 :   35158200 :           targetm.target_option.relayout_function (fndecl);
    4804                 :            :         }
    4805                 :            : 
    4806                 :   40957700 :       if (!abstract_p && aggregate_value_p (result, fndecl))
    4807                 :            :         {
    4808                 :            : #ifdef PCC_STATIC_STRUCT_RETURN
    4809                 :            :           cfun->returns_pcc_struct = 1;
    4810                 :            : #endif
    4811                 :     377966 :           cfun->returns_struct = 1;
    4812                 :            :         }
    4813                 :            : 
    4814                 :   40957700 :       cfun->stdarg = stdarg_p (fntype);
    4815                 :            : 
    4816                 :            :       /* Assume all registers in stdarg functions need to be saved.  */
    4817                 :   40957700 :       cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
    4818                 :   40957700 :       cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
    4819                 :            : 
    4820                 :            :       /* ??? This could be set on a per-function basis by the front-end
    4821                 :            :          but is this worth the hassle?  */
    4822                 :   40957700 :       cfun->can_throw_non_call_exceptions = flag_non_call_exceptions;
    4823                 :   40957700 :       cfun->can_delete_dead_exceptions = flag_delete_dead_exceptions;
    4824                 :            : 
    4825                 :   40957700 :       if (!profile_flag && !flag_instrument_function_entry_exit)
    4826                 :   40957400 :         DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl) = 1;
    4827                 :            : 
    4828                 :   40957700 :       if (flag_callgraph_info)
    4829                 :          0 :         allocate_stack_usage_info ();
    4830                 :            :     }
    4831                 :            : 
    4832                 :            :   /* Don't enable begin stmt markers if var-tracking at assignments is
    4833                 :            :      disabled.  The markers make little sense without the variable
    4834                 :            :      binding annotations among them.  */
    4835                 :   82218800 :   cfun->debug_nonbind_markers = lang_hooks.emits_begin_stmt
    4836                 :   41109400 :     && MAY_HAVE_DEBUG_MARKER_STMTS;
    4837                 :   41109400 : }
    4838                 :            : 
    4839                 :            : /* This is like allocate_struct_function, but pushes a new cfun for FNDECL
    4840                 :            :    instead of just setting it.  */
    4841                 :            : 
    4842                 :            : void
    4843                 :     602897 : push_struct_function (tree fndecl)
    4844                 :            : {
    4845                 :            :   /* When in_dummy_function we might be in the middle of a pop_cfun and
    4846                 :            :      current_function_decl and cfun may not match.  */
    4847                 :     602897 :   gcc_assert (in_dummy_function
    4848                 :            :               || (!cfun && !current_function_decl)
    4849                 :            :               || (cfun && current_function_decl == cfun->decl));
    4850                 :     602897 :   cfun_stack.safe_push (cfun);
    4851                 :     602897 :   current_function_decl = fndecl;
    4852                 :     602897 :   allocate_struct_function (fndecl, false);
    4853                 :     602897 : }
    4854                 :            : 
    4855                 :            : /* Reset crtl and other non-struct-function variables to defaults as
    4856                 :            :    appropriate for emitting rtl at the start of a function.  */
    4857                 :            : 
    4858                 :            : static void
    4859                 :    1101420 : prepare_function_start (void)
    4860                 :            : {
    4861                 :    1101420 :   gcc_assert (!get_last_insn ());
    4862                 :            : 
    4863                 :    1101420 :   if (in_dummy_function)
    4864                 :     151703 :     crtl->abi = &default_function_abi;
    4865                 :            :   else
    4866                 :     949715 :     crtl->abi = &fndecl_abi (cfun->decl).base_abi ();
    4867                 :            : 
    4868                 :    1101420 :   init_temp_slots ();
    4869                 :    1101420 :   init_emit ();
    4870                 :    1101420 :   init_varasm_status ();
    4871                 :    1101420 :   init_expr ();
    4872                 :    1101420 :   default_rtl_profile ();
    4873                 :            : 
    4874                 :    1101420 :   if (flag_stack_usage_info && !flag_callgraph_info)
    4875                 :         50 :     allocate_stack_usage_info ();
    4876                 :            : 
    4877                 :    1101420 :   cse_not_expected = ! optimize;
    4878                 :            : 
    4879                 :            :   /* Caller save not needed yet.  */
    4880                 :    1101420 :   caller_save_needed = 0;
    4881                 :            : 
    4882                 :            :   /* We haven't done register allocation yet.  */
    4883                 :    1101420 :   reg_renumber = 0;
    4884                 :            : 
    4885                 :            :   /* Indicate that we have not instantiated virtual registers yet.  */
    4886                 :    1101420 :   virtuals_instantiated = 0;
    4887                 :            : 
    4888                 :            :   /* Indicate that we want CONCATs now.  */
    4889                 :    1101420 :   generating_concat_p = 1;
    4890                 :            : 
    4891                 :            :   /* Indicate we have no need of a frame pointer yet.  */
    4892                 :    1101420 :   frame_pointer_needed = 0;
    4893                 :    1101420 : }
    4894                 :            : 
    4895                 :            : void
    4896                 :     151705 : push_dummy_function (bool with_decl)
    4897                 :            : {
    4898                 :     151705 :   tree fn_decl, fn_type, fn_result_decl;
    4899                 :            : 
    4900                 :     151705 :   gcc_assert (!in_dummy_function);
    4901                 :     151705 :   in_dummy_function = true;
    4902                 :            : 
    4903                 :     151705 :   if (with_decl)
    4904                 :            :     {
    4905                 :          2 :       fn_type = build_function_type_list (void_type_node, NULL_TREE);
    4906                 :          2 :       fn_decl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, NULL_TREE,
    4907                 :            :                             fn_type);
    4908                 :          2 :       fn_result_decl = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
    4909                 :            :                                          NULL_TREE, void_type_node);
    4910                 :          2 :       DECL_RESULT (fn_decl) = fn_result_decl;
    4911                 :            :     }
    4912                 :            :   else
    4913                 :            :     fn_decl = NULL_TREE;
    4914                 :            : 
    4915                 :     151705 :   push_struct_function (fn_decl);
    4916                 :     151705 : }
    4917                 :            : 
    4918                 :            : /* Initialize the rtl expansion mechanism so that we can do simple things
    4919                 :            :    like generate sequences.  This is used to provide a context during global
    4920                 :            :    initialization of some passes.  You must call expand_dummy_function_end
    4921                 :            :    to exit this context.  */
    4922                 :            : 
    4923                 :            : void
    4924                 :     151703 : init_dummy_function_start (void)
    4925                 :            : {
    4926                 :     151703 :   push_dummy_function (false);
    4927                 :     151703 :   prepare_function_start ();
    4928                 :     151703 : }
    4929                 :            : 
    4930                 :            : /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
    4931                 :            :    and initialize static variables for generating RTL for the statements
    4932                 :            :    of the function.  */
    4933                 :            : 
    4934                 :            : void
    4935                 :     949715 : init_function_start (tree subr)
    4936                 :            : {
    4937                 :            :   /* Initialize backend, if needed.  */
    4938                 :     949715 :   initialize_rtl ();
    4939                 :            : 
    4940                 :     949715 :   prepare_function_start ();
    4941                 :     949715 :   decide_function_section (subr);
    4942                 :            : 
    4943                 :            :   /* Warn if this value is an aggregate type,
    4944                 :            :      regardless of which calling convention we are using for it.  */
    4945                 :     949715 :   if (AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
    4946                 :      72777 :     warning (OPT_Waggregate_return, "function returns an aggregate");
    4947                 :     949715 : }
    4948                 :            : 
    4949                 :            : /* Expand code to verify the stack_protect_guard.  This is invoked at
    4950                 :            :    the end of a function to be protected.  */
    4951                 :            : 
    4952                 :            : void
    4953                 :        165 : stack_protect_epilogue (void)
    4954                 :            : {
    4955                 :        165 :   tree guard_decl = crtl->stack_protect_guard_decl;
    4956                 :        165 :   rtx_code_label *label = gen_label_rtx ();
    4957                 :        165 :   rtx x, y;
    4958                 :        165 :   rtx_insn *seq = NULL;
    4959                 :            : 
    4960                 :        165 :   x = expand_normal (crtl->stack_protect_guard);
    4961                 :            : 
    4962                 :        165 :   if (targetm.have_stack_protect_combined_test () && guard_decl)
    4963                 :            :     {
    4964                 :          0 :       gcc_assert (DECL_P (guard_decl));
    4965                 :          0 :       y = DECL_RTL (guard_decl);
    4966                 :            :       /* Allow the target to compute address of Y and compare it with X without
    4967                 :            :          leaking Y into a register.  This combined address + compare pattern
    4968                 :            :          allows the target to prevent spilling of any intermediate results by
    4969                 :            :          splitting it after register allocator.  */
    4970                 :          0 :       seq = targetm.gen_stack_protect_combined_test (x, y, label);
    4971                 :            :     }
    4972                 :            :   else
    4973                 :            :     {
    4974                 :        165 :       if (guard_decl)
    4975                 :        165 :         y = expand_normal (guard_decl);
    4976                 :            :       else
    4977                 :          0 :         y = const0_rtx;
    4978                 :            : 
    4979                 :            :       /* Allow the target to compare Y with X without leaking either into
    4980                 :            :          a register.  */
    4981                 :        165 :       if (targetm.have_stack_protect_test ())
    4982                 :        165 :         seq = targetm.gen_stack_protect_test (x, y, label);
    4983                 :            :     }
    4984                 :            : 
    4985                 :        165 :   if (seq)
    4986                 :        165 :     emit_insn (seq);
    4987                 :            :   else
    4988                 :          0 :     emit_cmp_and_jump_insns (x, y, EQ, NULL_RTX, ptr_mode, 1, label);
    4989                 :            : 
    4990                 :            :   /* The noreturn predictor has been moved to the tree level.  The rtl-level
    4991                 :            :      predictors estimate this branch about 20%, which isn't enough to get
    4992                 :            :      things moved out of line.  Since this is the only extant case of adding
    4993                 :            :      a noreturn function at the rtl level, it doesn't seem worth doing ought
    4994                 :            :      except adding the prediction by hand.  */
    4995                 :        165 :   rtx_insn *tmp = get_last_insn ();
    4996                 :        165 :   if (JUMP_P (tmp))
    4997                 :        165 :     predict_insn_def (tmp, PRED_NORETURN, TAKEN);
    4998                 :            : 
    4999                 :        165 :   expand_call (targetm.stack_protect_fail (), NULL_RTX, /*ignore=*/true);
    5000                 :        165 :   free_temp_slots ();
    5001                 :        165 :   emit_label (label);
    5002                 :        165 : }
    5003                 :            : 
    5004                 :            : /* Start the RTL for a new function, and set variables used for
    5005                 :            :    emitting RTL.
    5006                 :            :    SUBR is the FUNCTION_DECL node.
    5007                 :            :    PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
    5008                 :            :    the function's parameters, which must be run at any return statement.  */
    5009                 :            : 
    5010                 :            : void
    5011                 :     944512 : expand_function_start (tree subr)
    5012                 :            : {
    5013                 :            :   /* Make sure volatile mem refs aren't considered
    5014                 :            :      valid operands of arithmetic insns.  */
    5015                 :     944512 :   init_recog_no_volatile ();
    5016                 :            : 
    5017                 :     944512 :   crtl->profile
    5018                 :    1889020 :     = (profile_flag
    5019                 :     944729 :        && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
    5020                 :            : 
    5021                 :     944512 :   crtl->limit_stack
    5022                 :     944512 :     = (stack_limit_rtx != NULL_RTX && ! DECL_NO_LIMIT_STACK (subr));
    5023                 :            : 
    5024                 :            :   /* Make the label for return statements to jump to.  Do not special
    5025                 :            :      case machines with special return instructions -- they will be
    5026                 :            :      handled later during jump, ifcvt, or epilogue creation.  */
    5027                 :     944512 :   return_label = gen_label_rtx ();
    5028                 :            : 
    5029                 :            :   /* Initialize rtx used to return the value.  */
    5030                 :            :   /* Do this before assign_parms so that we copy the struct value address
    5031                 :            :      before any library calls that assign parms might generate.  */
    5032                 :            : 
    5033                 :            :   /* Decide whether to return the value in memory or in a register.  */
    5034                 :     944512 :   tree res = DECL_RESULT (subr);
    5035                 :     944512 :   if (aggregate_value_p (res, subr))
    5036                 :            :     {
    5037                 :            :       /* Returning something that won't go in a register.  */
    5038                 :      50830 :       rtx value_address = 0;
    5039                 :            : 
    5040                 :            : #ifdef PCC_STATIC_STRUCT_RETURN
    5041                 :            :       if (cfun->returns_pcc_struct)
    5042                 :            :         {
    5043                 :            :           int size = int_size_in_bytes (TREE_TYPE (res));
    5044                 :            :           value_address = assemble_static_space (size);
    5045                 :            :         }
    5046                 :            :       else
    5047                 :            : #endif
    5048                 :      50830 :         {
    5049                 :      50830 :           rtx sv = targetm.calls.struct_value_rtx (TREE_TYPE (subr), 2);
    5050                 :            :           /* Expect to be passed the address of a place to store the value.
    5051                 :            :              If it is passed as an argument, assign_parms will take care of
    5052                 :            :              it.  */
    5053                 :      50830 :           if (sv)
    5054                 :            :             {
    5055                 :          0 :               value_address = gen_reg_rtx (Pmode);
    5056                 :          0 :               emit_move_insn (value_address, sv);
    5057                 :            :             }
    5058                 :            :         }
    5059                 :          0 :       if (value_address)
    5060                 :            :         {
    5061                 :          0 :           rtx x = value_address;
    5062                 :          0 :           if (!DECL_BY_REFERENCE (res))
    5063                 :            :             {
    5064                 :          0 :               x = gen_rtx_MEM (DECL_MODE (res), x);
    5065                 :          0 :               set_mem_attributes (x, res, 1);
    5066                 :            :             }
    5067                 :          0 :           set_parm_rtl (res, x);
    5068                 :            :         }
    5069                 :            :     }
    5070                 :     893682 :   else if (DECL_MODE (res) == VOIDmode)
    5071                 :            :     /* If return mode is void, this decl rtl should not be used.  */
    5072                 :     444251 :     set_parm_rtl (res, NULL_RTX);
    5073                 :            :   else 
    5074                 :            :     {
    5075                 :            :       /* Compute the return values into a pseudo reg, which we will copy
    5076                 :            :          into the true return register after the cleanups are done.  */
    5077                 :     449431 :       tree return_type = TREE_TYPE (res);
    5078                 :            : 
    5079                 :            :       /* If we may coalesce this result, make sure it has the expected mode
    5080                 :            :          in case it was promoted.  But we need not bother about BLKmode.  */
    5081                 :     449431 :       machine_mode promoted_mode
    5082                 :     337220 :         = flag_tree_coalesce_vars && is_gimple_reg (res)
    5083                 :     761619 :           ? promote_ssa_mode (ssa_default_def (cfun, res), NULL)
    5084                 :     449459 :           : BLKmode;
    5085                 :            : 
    5086                 :     312188 :       if (promoted_mode != BLKmode)
    5087                 :     312160 :         set_parm_rtl (res, gen_reg_rtx (promoted_mode));
    5088                 :     137271 :       else if (TYPE_MODE (return_type) != BLKmode
    5089                 :     137271 :                && targetm.calls.return_in_msb (return_type))
    5090                 :            :         /* expand_function_end will insert the appropriate padding in
    5091                 :            :            this case.  Use the return value's natural (unpadded) mode
    5092                 :            :            within the function proper.  */
    5093                 :          0 :         set_parm_rtl (res, gen_reg_rtx (TYPE_MODE (return_type)));
    5094                 :            :       else
    5095                 :            :         {
    5096                 :            :           /* In order to figure out what mode to use for the pseudo, we
    5097                 :            :              figure out what the mode of the eventual return register will
    5098                 :            :              actually be, and use that.  */
    5099                 :     137271 :           rtx hard_reg = hard_function_value (return_type, subr, 0, 1);
    5100                 :            : 
    5101                 :            :           /* Structures that are returned in registers are not
    5102                 :            :              aggregate_value_p, so we may see a PARALLEL or a REG.  */
    5103                 :     137271 :           if (REG_P (hard_reg))
    5104                 :     135555 :             set_parm_rtl (res, gen_reg_rtx (GET_MODE (hard_reg)));
    5105                 :            :           else
    5106                 :            :             {
    5107                 :       1716 :               gcc_assert (GET_CODE (hard_reg) == PARALLEL);
    5108                 :       1716 :               set_parm_rtl (res, gen_group_rtx (hard_reg));
    5109                 :            :             }
    5110                 :            :         }
    5111                 :            : 
    5112                 :            :       /* Set DECL_REGISTER flag so that expand_function_end will copy the
    5113                 :            :          result to the real return register(s).  */
    5114                 :     449431 :       DECL_REGISTER (res) = 1;
    5115                 :            :     }
    5116                 :            : 
    5117                 :            :   /* Initialize rtx for parameters and local variables.
    5118                 :            :      In some cases this requires emitting insns.  */
    5119                 :     944512 :   assign_parms (subr);
    5120                 :            : 
    5121                 :            :   /* If function gets a static chain arg, store it.  */
    5122                 :     944512 :   if (cfun->static_chain_decl)
    5123                 :            :     {
    5124                 :      14292 :       tree parm = cfun->static_chain_decl;
    5125                 :      14292 :       rtx local, chain;
    5126                 :      14292 :       rtx_insn *insn;
    5127                 :      14292 :       int unsignedp;
    5128                 :            : 
    5129                 :      14292 :       local = gen_reg_rtx (promote_decl_mode (parm, &unsignedp));
    5130                 :      14292 :       chain = targetm.calls.static_chain (current_function_decl, true);
    5131                 :            : 
    5132                 :      14292 :       set_decl_incoming_rtl (parm, chain, false);
    5133                 :      14292 :       set_parm_rtl (parm, local);
    5134                 :      14292 :       mark_reg_pointer (local, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))));
    5135                 :            : 
    5136                 :      14292 :       if (GET_MODE (local) != GET_MODE (chain))
    5137                 :            :         {
    5138                 :          1 :           convert_move (local, chain, unsignedp);
    5139                 :          1 :           insn = get_last_insn ();
    5140                 :            :         }
    5141                 :            :       else
    5142                 :      14291 :         insn = emit_move_insn (local, chain);
    5143                 :            : 
    5144                 :            :       /* Mark the register as eliminable, similar to parameters.  */
    5145                 :      14292 :       if (MEM_P (chain)
    5146                 :      14292 :           && reg_mentioned_p (arg_pointer_rtx, XEXP (chain, 0)))
    5147                 :          0 :         set_dst_reg_note (insn, REG_EQUIV, chain, local);
    5148                 :            : 
    5149                 :            :       /* If we aren't optimizing, save the static chain onto the stack.  */
    5150                 :      14292 :       if (!optimize)
    5151                 :            :         {
    5152                 :       2074 :           tree saved_static_chain_decl
    5153                 :       6222 :             = build_decl (DECL_SOURCE_LOCATION (parm), VAR_DECL,
    5154                 :       2074 :                           DECL_NAME (parm), TREE_TYPE (parm));
    5155                 :       2074 :           rtx saved_static_chain_rtx
    5156                 :       4148 :             = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
    5157                 :       2074 :           SET_DECL_RTL (saved_static_chain_decl, saved_static_chain_rtx);
    5158                 :       2074 :           emit_move_insn (saved_static_chain_rtx, chain);
    5159                 :       2074 :           SET_DECL_VALUE_EXPR (parm, saved_static_chain_decl);
    5160                 :       4148 :           DECL_HAS_VALUE_EXPR_P (parm) = 1;
    5161                 :            :         }
    5162                 :            :     }
    5163                 :            : 
    5164                 :            :   /* The following was moved from init_function_start.
    5165                 :            :      The move was supposed to make sdb output more accurate.  */
    5166                 :            :   /* Indicate the beginning of the function body,
    5167                 :            :      as opposed to parm setup.  */
    5168                 :     944512 :   emit_note (NOTE_INSN_FUNCTION_BEG);
    5169                 :            : 
    5170                 :     944512 :   gcc_assert (NOTE_P (get_last_insn ()));
    5171                 :            : 
    5172                 :     944512 :   parm_birth_insn = get_last_insn ();
    5173                 :            : 
    5174                 :            :   /* If the function receives a non-local goto, then store the
    5175                 :            :      bits we need to restore the frame pointer.  */
    5176                 :     944512 :   if (cfun->nonlocal_goto_save_area)
    5177                 :            :     {
    5178                 :        391 :       tree t_save;
    5179                 :        391 :       rtx r_save;
    5180                 :            : 
    5181                 :        391 :       tree var = TREE_OPERAND (cfun->nonlocal_goto_save_area, 0);
    5182                 :        391 :       gcc_assert (DECL_RTL_SET_P (var));
    5183                 :            : 
    5184                 :       1173 :       t_save = build4 (ARRAY_REF,
    5185                 :        391 :                        TREE_TYPE (TREE_TYPE (cfun->nonlocal_goto_save_area)),
    5186                 :            :                        cfun->nonlocal_goto_save_area,
    5187                 :            :                        integer_zero_node, NULL_TREE, NULL_TREE);
    5188                 :        391 :       r_save = expand_expr (t_save, NULL_RTX, VOIDmode, EXPAND_WRITE);
    5189                 :        391 :       gcc_assert (GET_MODE (r_save) == Pmode);
    5190                 :            : 
    5191                 :        391 :       emit_move_insn (r_save, hard_frame_pointer_rtx);
    5192                 :        391 :       update_nonlocal_goto_save_area ();
    5193                 :            :     }
    5194                 :            : 
    5195                 :     944512 :   if (crtl->profile)
    5196                 :            :     {
    5197                 :            : #ifdef PROFILE_HOOK
    5198                 :            :       PROFILE_HOOK (current_function_funcdef_no);
    5199                 :            : #endif
    5200                 :            :     }
    5201                 :            : 
    5202                 :            :   /* If we are doing generic stack checking, the probe should go here.  */
    5203                 :     944512 :   if (flag_stack_check == GENERIC_STACK_CHECK)
    5204                 :          8 :     stack_check_probe_note = emit_note (NOTE_INSN_DELETED);
    5205                 :     944512 : }
    5206                 :            : 
    5207                 :            : void
    5208                 :     151705 : pop_dummy_function (void)
    5209                 :            : {
    5210                 :     151705 :   pop_cfun ();
    5211                 :     151705 :   in_dummy_function = false;
    5212                 :     151705 : }
    5213                 :            : 
    5214                 :            : /* Undo the effects of init_dummy_function_start.  */
    5215                 :            : void
    5216                 :     151703 : expand_dummy_function_end (void)
    5217                 :            : {
    5218                 :     151703 :   gcc_assert (in_dummy_function);
    5219                 :            : 
    5220                 :            :   /* End any sequences that failed to be closed due to syntax errors.  */
    5221                 :     151703 :   while (in_sequence_p ())
    5222                 :          0 :     end_sequence ();
    5223                 :            : 
    5224                 :            :   /* Outside function body, can't compute type's actual size
    5225                 :            :      until next function's body starts.  */
    5226                 :            : 
    5227                 :     151703 :   free_after_parsing (cfun);
    5228                 :     151703 :   free_after_compilation (cfun);
    5229                 :     151703 :   pop_dummy_function ();
    5230                 :     151703 : }
    5231                 :            : 
    5232                 :            : /* Helper for diddle_return_value.  */
    5233                 :            : 
    5234                 :            : void
    5235                 :   11791000 : diddle_return_value_1 (void (*doit) (rtx, void *), void *arg, rtx outgoing)
    5236                 :            : {
    5237                 :   11791000 :   if (! outgoing)
    5238                 :            :     return;
    5239                 :            : 
    5240                 :    6111830 :   if (REG_P (outgoing))
    5241                 :    6084360 :     (*doit) (outgoing, arg);
    5242                 :      27472 :   else if (GET_CODE (outgoing) == PARALLEL)
    5243                 :            :     {
    5244                 :            :       int i;
    5245                 :            : 
    5246                 :      65625 :       for (i = 0; i < XVECLEN (outgoing, 0); i++)
    5247                 :            :         {
    5248                 :      39530 :           rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
    5249                 :            : 
    5250                 :      39530 :           if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
    5251                 :      39530 :             (*doit) (x, arg);
    5252                 :            :         }
    5253                 :            :     }
    5254                 :            : }
    5255                 :            : 
    5256                 :            : /* Call DOIT for each hard register used as a return value from
    5257                 :            :    the current function.  */
    5258                 :            : 
    5259                 :            : void
    5260                 :   11791000 : diddle_return_value (void (*doit) (rtx, void *), void *arg)
    5261                 :            : {
    5262                 :   11791000 :   diddle_return_value_1 (doit, arg, crtl->return_rtx);
    5263                 :   11791000 : }
    5264                 :            : 
    5265                 :            : static void
    5266                 :      12529 : do_clobber_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
    5267                 :            : {
    5268                 :       6285 :   emit_clobber (reg);
    5269                 :       6244 : }
    5270                 :            : 
    5271                 :            : void
    5272                 :     401197 : clobber_return_register (void)
    5273                 :            : {
    5274                 :     401197 :   diddle_return_value (do_clobber_return_reg, NULL);
    5275                 :            : 
    5276                 :            :   /* In case we do use pseudo to return value, clobber it too.  */
    5277                 :     401197 :   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
    5278                 :            :     {
    5279                 :       6293 :       tree decl_result = DECL_RESULT (current_function_decl);
    5280                 :       6293 :       rtx decl_rtl = DECL_RTL (decl_result);
    5281                 :       6293 :       if (REG_P (decl_rtl) && REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER)
    5282                 :            :         {
    5283                 :       6244 :           do_clobber_return_reg (decl_rtl, NULL);
    5284                 :            :         }
    5285                 :            :     }
    5286                 :     401197 : }
    5287                 :            : 
    5288                 :            : static void
    5289                 :     501244 : do_use_return_reg (rtx reg, void *arg ATTRIBUTE_UNUSED)
    5290                 :            : {
    5291                 :     501244 :   emit_use (reg);
    5292                 :     501244 : }
    5293                 :            : 
    5294                 :            : static void
    5295                 :     944512 : use_return_register (void)
    5296                 :            : {
    5297                 :          0 :   diddle_return_value (do_use_return_reg, NULL);
    5298                 :          0 : }
    5299                 :            : 
    5300                 :            : /* Generate RTL for the end of the current function.  */
    5301                 :            : 
    5302                 :            : void
    5303                 :     944512 : expand_function_end (void)
    5304                 :            : {
    5305                 :            :   /* If arg_pointer_save_area was referenced only from a nested
    5306                 :            :      function, we will not have initialized it yet.  Do that now.  */
    5307                 :     944512 :   if (arg_pointer_save_area && ! crtl->arg_pointer_save_area_init)
    5308                 :          0 :     get_arg_pointer_save_area ();
    5309                 :            : 
    5310                 :            :   /* If we are doing generic stack checking and this function makes calls,
    5311                 :            :      do a stack probe at the start of the function to ensure we have enough
    5312                 :            :      space for another stack frame.  */
    5313                 :     944512 :   if (flag_stack_check == GENERIC_STACK_CHECK)
    5314                 :            :     {
    5315                 :          8 :       rtx_insn *insn, *seq;
    5316                 :            : 
    5317                 :        622 :       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
    5318                 :        309 :         if (CALL_P (insn))
    5319                 :            :           {
    5320                 :          2 :             rtx max_frame_size = GEN_INT (STACK_CHECK_MAX_FRAME_SIZE);
    5321                 :          2 :             start_sequence ();
    5322                 :          2 :             if (STACK_CHECK_MOVING_SP)
    5323                 :          2 :               anti_adjust_stack_and_probe (max_frame_size, true);
    5324                 :            :             else
    5325                 :            :               probe_stack_range (STACK_OLD_CHECK_PROTECT, max_frame_size);
    5326                 :          2 :             seq = get_insns ();
    5327                 :          2 :             end_sequence ();
    5328                 :          2 :             set_insn_locations (seq, prologue_location);
    5329                 :          2 :             emit_insn_before (seq, stack_check_probe_note);
    5330                 :          2 :             break;
    5331                 :            :           }
    5332                 :            :     }
    5333                 :            : 
    5334                 :            :   /* End any sequences that failed to be closed due to syntax errors.  */
    5335                 :     944512 :   while (in_sequence_p ())
    5336                 :          0 :     end_sequence ();
    5337                 :            : 
    5338                 :     944512 :   clear_pending_stack_adjust ();
    5339                 :     944512 :   do_pending_stack_adjust ();
    5340                 :            : 
    5341                 :            :   /* Output a linenumber for the end of the function.
    5342                 :            :      SDB depended on this.  */
    5343                 :     944512 :   set_curr_insn_location (input_location);
    5344                 :            : 
    5345                 :            :   /* Before the return label (if any), clobber the return
    5346                 :            :      registers so that they are not propagated live to the rest of
    5347                 :            :      the function.  This can only happen with functions that drop
    5348                 :            :      through; if there had been a return statement, there would
    5349                 :            :      have either been a return rtx, or a jump to the return label.
    5350                 :            : 
    5351                 :            :      We delay actual code generation after the current_function_value_rtx
    5352                 :            :      is computed.  */
    5353                 :     944512 :   rtx_insn *clobber_after = get_last_insn ();
    5354                 :            : 
    5355                 :            :   /* Output the label for the actual return from the function.  */
    5356                 :     944512 :   emit_label (return_label);
    5357                 :            : 
    5358                 :     944512 :   if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
    5359                 :            :     {
    5360                 :            :       /* Let except.c know where it should emit the call to unregister
    5361                 :            :          the function context for sjlj exceptions.  */
    5362                 :          0 :       if (flag_exceptions)
    5363                 :          0 :         sjlj_emit_function_exit_after (get_last_insn ());
    5364                 :            :     }
    5365                 :            : 
    5366                 :            :   /* If this is an implementation of throw, do what's necessary to
    5367                 :            :      communicate between __builtin_eh_return and the epilogue.  */
    5368                 :     944512 :   expand_eh_return ();
    5369                 :            : 
    5370                 :            :   /* If stack protection is enabled for this function, check the guard.  */
    5371                 :     944512 :   if (crtl->stack_protect_guard
    5372                 :        165 :       && targetm.stack_protect_runtime_enabled_p ()
    5373                 :     944677 :       && naked_return_label == NULL_RTX)
    5374                 :        165 :     stack_protect_epilogue ();
    5375                 :            : 
    5376                 :            :   /* If scalar return value was computed in a pseudo-reg, or was a named
    5377                 :            :      return value that got dumped to the stack, copy that to the hard
    5378                 :            :      return register.  */
    5379                 :     944512 :   if (DECL_RTL_SET_P (DECL_RESULT (current_function_decl)))
    5380                 :            :     {
    5381                 :     500261 :       tree decl_result = DECL_RESULT (current_function_decl);
    5382                 :     500261 :       rtx decl_rtl = DECL_RTL (decl_result);
    5383                 :            : 
    5384                 :     500261 :       if (REG_P (decl_rtl)
    5385                 :     500261 :           ? REGNO (decl_rtl) >= FIRST_PSEUDO_REGISTER
    5386                 :      48481 :           : DECL_REGISTER (decl_result))
    5387                 :            :         {
    5388                 :     454297 :           rtx real_decl_rtl = crtl->return_rtx;
    5389                 :     454297 :           complex_mode cmode;
    5390                 :            : 
    5391                 :            :           /* This should be set in assign_parms.  */
    5392                 :     454297 :           gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl));
    5393                 :            : 
    5394                 :            :           /* If this is a BLKmode structure being returned in registers,
    5395                 :            :              then use the mode computed in expand_return.  Note that if
    5396                 :            :              decl_rtl is memory, then its mode may have been changed,
    5397                 :            :              but that crtl->return_rtx has not.  */
    5398                 :     454297 :           if (GET_MODE (real_decl_rtl) == BLKmode)
    5399                 :       1088 :             PUT_MODE (real_decl_rtl, GET_MODE (decl_rtl));
    5400                 :            : 
    5401                 :            :           /* If a non-BLKmode return value should be padded at the least
    5402                 :            :              significant end of the register, shift it left by the appropriate
    5403                 :            :              amount.  BLKmode results are handled using the group load/store
    5404                 :            :              machinery.  */
    5405                 :     454297 :           if (TYPE_MODE (TREE_TYPE (decl_result)) != BLKmode
    5406                 :     453206 :               && REG_P (real_decl_rtl)
    5407                 :     905986 :               && targetm.calls.return_in_msb (TREE_TYPE (decl_result)))
    5408                 :            :             {
    5409                 :          0 :               emit_move_insn (gen_rtx_REG (GET_MODE (decl_rtl),
    5410                 :            :                                            REGNO (real_decl_rtl)),
    5411                 :            :                               decl_rtl);
    5412                 :          0 :               shift_return_value (GET_MODE (decl_rtl), true, real_decl_rtl);
    5413                 :            :             }
    5414                 :     454297 :           else if (GET_CODE (real_decl_rtl) == PARALLEL)
    5415                 :            :             {
    5416                 :            :               /* If expand_function_start has created a PARALLEL for decl_rtl,
    5417                 :            :                  move the result to the real return registers.  Otherwise, do
    5418                 :            :                  a group load from decl_rtl for a named return.  */
    5419                 :       2223 :               if (GET_CODE (decl_rtl) == PARALLEL)
    5420                 :       1716 :                 emit_group_move (real_decl_rtl, decl_rtl);
    5421                 :            :               else
    5422                 :       1521 :                 emit_group_load (real_decl_rtl, decl_rtl,
    5423                 :        507 :                                  TREE_TYPE (decl_result),
    5424                 :        507 :                                  int_size_in_bytes (TREE_TYPE (decl_result)));
    5425                 :            :             }
    5426                 :            :           /* In the case of complex integer modes smaller than a word, we'll
    5427                 :            :              need to generate some non-trivial bitfield insertions.  Do that
    5428                 :            :              on a pseudo and not the hard register.  */
    5429                 :     452074 :           else if (GET_CODE (decl_rtl) == CONCAT
    5430                 :        294 :                    && is_complex_int_mode (GET_MODE (decl_rtl), &cmode)
    5431                 :     452185 :                    && GET_MODE_BITSIZE (cmode) <= BITS_PER_WORD)
    5432                 :            :             {
    5433                 :         73 :               int old_generating_concat_p;
    5434                 :         73 :               rtx tmp;
    5435                 :            : 
    5436                 :         73 :               old_generating_concat_p = generating_concat_p;
    5437                 :         73 :               generating_concat_p = 0;
    5438                 :         73 :               tmp = gen_reg_rtx (GET_MODE (decl_rtl));
    5439                 :         73 :               generating_concat_p = old_generating_concat_p;
    5440                 :            : 
    5441                 :         73 :               emit_move_insn (tmp, decl_rtl);
    5442                 :         73 :               emit_move_insn (real_decl_rtl, tmp);
    5443                 :            :             }
    5444                 :            :           /* If a named return value dumped decl_return to memory, then
    5445                 :            :              we may need to re-do the PROMOTE_MODE signed/unsigned
    5446                 :            :              extension.  */
    5447                 :     452001 :           else if (GET_MODE (real_decl_rtl) != GET_MODE (decl_rtl))
    5448                 :            :             {
    5449                 :          0 :               int unsignedp = TYPE_UNSIGNED (TREE_TYPE (decl_result));
    5450                 :          0 :               promote_function_mode (TREE_TYPE (decl_result),
    5451                 :          0 :                                      GET_MODE (decl_rtl), &unsignedp,
    5452                 :          0 :                                      TREE_TYPE (current_function_decl), 1);
    5453                 :            : 
    5454                 :          0 :               convert_move (real_decl_rtl, decl_rtl, unsignedp);
    5455                 :            :             }
    5456                 :            :           else
    5457                 :     452001 :             emit_move_insn (real_decl_rtl, decl_rtl);
    5458                 :            :         }
    5459                 :            :     }
    5460                 :            : 
    5461                 :            :   /* If returning a structure, arrange to return the address of the value
    5462                 :            :      in a place where debuggers expect to find it.
    5463                 :            : 
    5464                 :            :      If returning a structure PCC style,
    5465                 :            :      the caller also depends on this value.
    5466                 :            :      And cfun->returns_pcc_struct is not necessarily set.  */
    5467                 :     944512 :   if ((cfun->returns_struct || cfun->returns_pcc_struct)
    5468                 :      50705 :       && !targetm.calls.omit_struct_return_reg)
    5469                 :            :     {
    5470                 :      50705 :       rtx value_address = DECL_RTL (DECL_RESULT (current_function_decl));
    5471                 :      50705 :       tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
    5472                 :      50705 :       rtx outgoing;
    5473                 :            : 
    5474                 :     101410 :       if (DECL_BY_REFERENCE (DECL_RESULT (current_function_decl)))
    5475                 :       6367 :         type = TREE_TYPE (type);
    5476                 :            :       else
    5477                 :      44338 :         value_address = XEXP (value_address, 0);
    5478                 :            : 
    5479                 :      50705 :       outgoing = targetm.calls.function_value (build_pointer_type (type),
    5480                 :            :                                                current_function_decl, true);
    5481                 :            : 
    5482                 :            :       /* Mark this as a function return value so integrate will delete the
    5483                 :            :          assignment and USE below when inlining this function.  */
    5484                 :      50705 :       REG_FUNCTION_VALUE_P (outgoing) = 1;
    5485                 :            : 
    5486                 :            :       /* The address may be ptr_mode and OUTGOING may be Pmode.  */
    5487                 :      50705 :       scalar_int_mode mode = as_a <scalar_int_mode> (GET_MODE (outgoing));
    5488                 :      50705 :       value_address = convert_memory_address (mode, value_address);
    5489                 :            : 
    5490                 :      50705 :       emit_move_insn (outgoing, value_address);
    5491                 :            : 
    5492                 :            :       /* Show return register used to hold result (in this case the address
    5493                 :            :          of the result.  */
    5494                 :      50705 :       crtl->return_rtx = outgoing;
    5495                 :            :     }
    5496                 :            : 
    5497                 :            :   /* Emit the actual code to clobber return register.  Don't emit
    5498                 :            :      it if clobber_after is a barrier, then the previous basic block
    5499                 :            :      certainly doesn't fall thru into the exit block.  */
    5500                 :     944512 :   if (!BARRIER_P (clobber_after))
    5501                 :            :     {
    5502                 :     350202 :       start_sequence ();
    5503                 :     350202 :       clobber_return_register ();
    5504                 :     350202 :       rtx_insn *seq = get_insns ();
    5505                 :     350202 :       end_sequence ();
    5506                 :            : 
    5507                 :     350202 :       emit_insn_after (seq, clobber_after);
    5508                 :            :     }
    5509                 :            : 
    5510                 :            :   /* Output the label for the naked return from the function.  */
    5511                 :     944512 :   if (naked_return_label)
    5512                 :        106 :     emit_label (naked_return_label);
    5513                 :            : 
    5514                 :            :   /* @@@ This is a kludge.  We want to ensure that instructions that
    5515                 :            :      may trap are not moved into the epilogue by scheduling, because
    5516                 :            :      we don't always emit unwind information for the epilogue.  */
    5517                 :     944512 :   if (cfun->can_throw_non_call_exceptions
    5518                 :     944512 :       && targetm_common.except_unwind_info (&global_options) != UI_SJLJ)
    5519                 :     181960 :     emit_insn (gen_blockage ());
    5520                 :            : 
    5521                 :            :   /* If stack protection is enabled for this function, check the guard.  */
    5522                 :     944512 :   if (crtl->stack_protect_guard
    5523                 :        165 :       && targetm.stack_protect_runtime_enabled_p ()
    5524                 :     944677 :       && naked_return_label)
    5525                 :          0 :     stack_protect_epilogue ();
    5526                 :            : 
    5527                 :            :   /* If we had calls to alloca, and this machine needs
    5528                 :            :      an accurate stack pointer to exit the function,
    5529                 :            :      insert some code to save and restore the stack pointer.  */
    5530                 :     944512 :   if (! EXIT_IGNORE_STACK
    5531                 :            :       && cfun->calls_alloca)
    5532                 :            :     {
    5533                 :            :       rtx tem = 0;
    5534                 :            : 
    5535                 :            :       start_sequence ();
    5536                 :            :       emit_stack_save (SAVE_FUNCTION, &tem);
    5537                 :            :       rtx_insn *seq = get_insns ();
    5538                 :            :       end_sequence ();
    5539                 :            :       emit_insn_before (seq, parm_birth_insn);
    5540                 :            : 
    5541                 :            :       emit_stack_restore (SAVE_FUNCTION, tem);
    5542                 :            :     }
    5543                 :            : 
    5544                 :            :   /* ??? This should no longer be necessary since stupid is no longer with
    5545                 :            :      us, but there are some parts of the compiler (eg reload_combine, and
    5546                 :            :      sh mach_dep_reorg) that still try and compute their own lifetime info
    5547                 :            :      instead of using the general framework.  */
    5548                 :     944512 :   use_return_register ();
    5549                 :     944512 : }
    5550                 :            : 
    5551                 :            : rtx
    5552                 :          0 : get_arg_pointer_save_area (void)
    5553                 :            : {
    5554                 :          0 :   rtx ret = arg_pointer_save_area;
    5555                 :            : 
    5556                 :          0 :   if (! ret)
    5557                 :            :     {
    5558                 :          0 :       ret = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
    5559                 :          0 :       arg_pointer_save_area = ret;
    5560                 :            :     }
    5561                 :            : 
    5562                 :          0 :   if (! crtl->arg_pointer_save_area_init)
    5563                 :            :     {
    5564                 :            :       /* Save the arg pointer at the beginning of the function.  The
    5565                 :            :          generated stack slot may not be a valid memory address, so we
    5566                 :            :          have to check it and fix it if necessary.  */
    5567                 :          0 :       start_sequence ();
    5568                 :          0 :       emit_move_insn (validize_mem (copy_rtx (ret)),
    5569                 :            :                       crtl->args.internal_arg_pointer);
    5570                 :          0 :       rtx_insn *seq = get_insns ();
    5571                 :          0 :       end_sequence ();
    5572                 :            : 
    5573                 :          0 :       push_topmost_sequence ();
    5574                 :          0 :       emit_insn_after (seq, entry_of_function ());
    5575                 :          0 :       pop_topmost_sequence ();
    5576                 :            : 
    5577                 :          0 :       crtl->arg_pointer_save_area_init = true;
    5578                 :            :     }
    5579                 :            : 
    5580                 :          0 :   return ret;
    5581                 :            : }
    5582                 :            : 
    5583                 :            : 
    5584                 :            : /* If debugging dumps are requested, dump information about how the
    5585                 :            :    target handled -fstack-check=clash for the prologue.
    5586                 :            : 
    5587                 :            :    PROBES describes what if any probes were emitted.
    5588                 :            : 
    5589                 :            :    RESIDUALS indicates if the prologue had any residual allocation
    5590                 :            :    (i.e. total allocation was not a multiple of PROBE_INTERVAL).  */
    5591                 :            : 
    5592                 :            : void
    5593                 :         63 : dump_stack_clash_frame_info (enum stack_clash_probes probes, bool residuals)
    5594                 :            : {
    5595                 :         63 :   if (!dump_file)
    5596                 :            :     return;
    5597                 :            : 
    5598                 :         17 :   switch (probes)
    5599                 :            :     {
    5600                 :          1 :     case NO_PROBE_NO_FRAME:
    5601                 :          1 :       fprintf (dump_file,
    5602                 :            :                "Stack clash no probe no stack adjustment in prologue.\n");
    5603                 :          1 :       break;
    5604                 :         11 :     case NO_PROBE_SMALL_FRAME:
    5605                 :         11 :       fprintf (dump_file,
    5606                 :            :                "Stack clash no probe small stack adjustment in prologue.\n");
    5607                 :         11 :       break;
    5608                 :          3 :     case PROBE_INLINE:
    5609                 :          3 :       fprintf (dump_file, "Stack clash inline probes in prologue.\n");
    5610                 :          3 :       break;
    5611                 :          2 :     case PROBE_LOOP:
    5612                 :          2 :       fprintf (dump_file, "Stack clash probe loop in prologue.\n");
    5613                 :          2 :       break;
    5614                 :            :     }
    5615                 :            : 
    5616                 :         17 :   if (residuals)
    5617                 :         16 :     fprintf (dump_file, "Stack clash residual allocation in prologue.\n");
    5618                 :            :   else
    5619                 :          1 :     fprintf (dump_file, "Stack clash no residual allocation in prologue.\n");
    5620                 :            : 
    5621                 :         17 :   if (frame_pointer_needed)
    5622                 :          0 :     fprintf (dump_file, "Stack clash frame pointer needed.\n");
    5623                 :            :   else
    5624                 :         17 :     fprintf (dump_file, "Stack clash no frame pointer needed.\n");
    5625                 :            : 
    5626                 :         17 :   if (TREE_THIS_VOLATILE (cfun->decl))
    5627                 :          1 :     fprintf (dump_file,
    5628                 :            :              "Stack clash noreturn prologue, assuming no implicit"
    5629                 :            :              " probes in caller.\n");
    5630                 :            :   else
    5631                 :         16 :     fprintf (dump_file,
    5632                 :            :              "Stack clash not noreturn prologue.\n");
    5633                 :            : }
    5634                 :            : 
    5635                 :            : /* Add a list of INSNS to the hash HASHP, possibly allocating HASHP
    5636                 :            :    for the first time.  */
    5637                 :            : 
    5638                 :            : static void
    5639                 :    2108100 : record_insns (rtx_insn *insns, rtx end, hash_table<insn_cache_hasher> **hashp)
    5640                 :            : {
    5641                 :    2108100 :   rtx_insn *tmp;
    5642                 :    2108100 :   hash_table<insn_cache_hasher> *hash = *hashp;
    5643                 :            : 
    5644                 :    2108100 :   if (hash == NULL)
    5645                 :    1888190 :     *hashp = hash = hash_table<insn_cache_hasher>::create_ggc (17);
    5646                 :            : 
    5647                 :    8377060 :   for (tmp = insns; tmp != end; tmp = NEXT_INSN (tmp))
    5648                 :            :     {
    5649                 :    6268960 :       rtx *slot = hash->find_slot (tmp, INSERT);
    5650                 :    6268960 :       gcc_assert (*slot == NULL);
    5651                 :    6268960 :       *slot = tmp;
    5652                 :            :     }
    5653                 :    2108100 : }
    5654                 :            : 
    5655                 :            : /* INSN has been duplicated or replaced by as COPY, perhaps by duplicating a
    5656                 :            :    basic block, splitting or peepholes.  If INSN is a prologue or epilogue
    5657                 :            :    insn, then record COPY as well.  */
    5658                 :            : 
    5659                 :            : void
    5660                 :    1942460 : maybe_copy_prologue_epilogue_insn (rtx insn, rtx copy)
    5661                 :            : {
    5662                 :    1942460 :   hash_table<insn_cache_hasher> *hash;
    5663                 :    1942460 :   rtx *slot;
    5664                 :            : 
    5665                 :    1942460 :   hash = epilogue_insn_hash;
    5666                 :    1942460 :   if (!hash || !hash->find (insn))
    5667                 :            :     {
    5668                 :    1597650 :       hash = prologue_insn_hash;
    5669                 :    1597650 :       if (!hash || !hash->find (insn))
    5670                 :    1580940 :         return;
    5671                 :            :     }
    5672                 :            : 
    5673                 :     361518 :   slot = hash->find_slot (copy, INSERT);
    5674                 :     361518 :   gcc_assert (*slot == NULL);
    5675                 :     361518 :   *slot = copy;
    5676                 :            : }
    5677                 :            : 
    5678                 :            : /* Determine if any INSNs in HASH are, or are part of, INSN.  Because
    5679                 :            :    we can be running after reorg, SEQUENCE rtl is possible.  */
    5680                 :            : 
    5681                 :            : static bool
    5682                 :  805382000 : contains (const rtx_insn *insn, hash_table<insn_cache_hasher> *hash)
    5683                 :            : {
    5684                 :  805382000 :   if (hash == NULL)
    5685                 :            :     return false;
    5686                 :            : 
    5687                 :  497116000 :   if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
    5688                 :            :     {
    5689                 :          0 :       rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (insn));
    5690                 :          0 :       int i;
    5691                 :          0 :       for (i = seq->len () - 1; i >= 0; i--)
    5692                 :          0 :         if (hash->find (seq->element (i)))
    5693                 :            :           return true;
    5694                 :            :       return false;
    5695                 :            :     }
    5696                 :            : 
    5697                 :  497116000 :   return hash->find (const_cast<rtx_insn *> (insn)) != NULL;
    5698                 :            : }
    5699                 :            : 
    5700                 :            : int
    5701                 :   67309200 : prologue_contains (const rtx_insn *insn)
    5702                 :            : {
    5703                 :   67309200 :   return contains (insn, prologue_insn_hash);
    5704                 :            : }
    5705                 :            : 
    5706                 :            : int
    5707                 :   67309200 : epilogue_contains (const rtx_insn *insn)
    5708                 :            : {
    5709                 :   67309200 :   return contains (insn, epilogue_insn_hash);
    5710                 :            : }
    5711                 :            : 
    5712                 :            : int
    5713                 :  323313000 : prologue_epilogue_contains (const rtx_insn *insn)
    5714                 :            : {
    5715                 :  323313000 :   if (contains (insn, prologue_insn_hash))
    5716                 :            :     return 1;
    5717                 :  314076000 :   if (contains (insn, epilogue_insn_hash))
    5718                 :    8231520 :     return 1;
    5719                 :            :   return 0;
    5720                 :            : }
    5721                 :            : 
    5722                 :            : void
    5723                 :          0 : record_prologue_seq (rtx_insn *seq)
    5724                 :            : {
    5725                 :          0 :   record_insns (seq, NULL, &prologue_insn_hash);
    5726                 :          0 : }
    5727                 :            : 
    5728                 :            : void
    5729                 :          0 : record_epilogue_seq (rtx_insn *seq)
    5730                 :            : {
    5731                 :          0 :   record_insns (seq, NULL, &epilogue_insn_hash);
    5732                 :          0 : }
    5733                 :            : 
    5734                 :            : /* Set JUMP_LABEL for a return insn.  */
    5735                 :            : 
    5736                 :            : void
    5737                 :     944021 : set_return_jump_label (rtx_insn *returnjump)
    5738                 :            : {
    5739                 :     944021 :   rtx pat = PATTERN (returnjump);
    5740                 :     944021 :   if (GET_CODE (pat) == PARALLEL)
    5741                 :      23694 :     pat = XVECEXP (pat, 0, 0);
    5742                 :     944021 :   if (ANY_RETURN_P (pat))
    5743                 :     944021 :     JUMP_LABEL (returnjump) = pat;
    5744                 :            :   else
    5745                 :          0 :     JUMP_LABEL (returnjump) = ret_rtx;
    5746                 :     944021 : }
    5747                 :            : 
    5748                 :            : /* Return a sequence to be used as the split prologue for the current
    5749                 :            :    function, or NULL.  */
    5750                 :            : 
    5751                 :            : static rtx_insn *
    5752                 :     944097 : make_split_prologue_seq (void)
    5753                 :            : {
    5754                 :     944097 :   if (!flag_split_stack
    5755                 :     944097 :       || lookup_attribute ("no_split_stack", DECL_ATTRIBUTES (cfun->decl)))
    5756                 :     764612 :     return NULL;
    5757                 :            : 
    5758                 :     179485 :   start_sequence ();
    5759                 :     179485 :   emit_insn (targetm.gen_split_stack_prologue ());
    5760                 :     179485 :   rtx_insn *seq = get_insns ();
    5761                 :     179485 :   end_sequence ();
    5762                 :            : 
    5763                 :     179485 :   record_insns (seq, NULL, &prologue_insn_hash);
    5764                 :     179485 :   set_insn_locations (seq, prologue_location);
    5765                 :            : 
    5766                 :     179485 :   return seq;
    5767                 :            : }
    5768                 :            : 
    5769                 :            : /* Return a sequence to be used as the prologue for the current function,
    5770                 :            :    or NULL.  */
    5771                 :            : 
    5772                 :            : static rtx_insn *
    5773                 :     944097 : make_prologue_seq (void)
    5774                 :            : {
    5775                 :     944097 :   if (!targetm.have_prologue ())
    5776                 :            :     return NULL;
    5777                 :            : 
    5778                 :     944097 :   start_sequence ();
    5779                 :     944097 :   rtx_insn *seq = targetm.gen_prologue ();
    5780                 :     944097 :   emit_insn (seq);
    5781                 :            : 
    5782                 :            :   /* Insert an explicit USE for the frame pointer
    5783                 :            :      if the profiling is on and the frame pointer is required.  */
    5784                 :     944097 :   if (crtl->profile && frame_pointer_needed)
    5785                 :        209 :     emit_use (hard_frame_pointer_rtx);
    5786                 :            : 
    5787                 :            :   /* Retain a map of the prologue insns.  */
    5788                 :     944097 :   record_insns (seq, NULL, &prologue_insn_hash);
    5789                 :     944097 :   emit_note (NOTE_INSN_PROLOGUE_END);
    5790                 :            : 
    5791                 :            :   /* Ensure that instructions are not moved into the prologue when
    5792                 :            :      profiling is on.  The call to the profiling routine can be
    5793                 :            :      emitted within the live range of a call-clobbered register.  */
    5794                 :     944097 :   if (!targetm.profile_before_prologue () && crtl->profile)
    5795                 :        194 :     emit_insn (gen_blockage ());
    5796                 :            : 
    5797                 :     944097 :   seq = get_insns ();
    5798                 :     944097 :   end_sequence ();
    5799                 :     944097 :   set_insn_locations (seq, prologue_location);
    5800                 :            : 
    5801                 :     944097 :   return seq;
    5802                 :            : }
    5803                 :            : 
    5804                 :            : /* Return a sequence to be used as the epilogue for the current function,
    5805                 :            :    or NULL.  */
    5806                 :            : 
    5807                 :            : static rtx_insn *
    5808                 :     944097 : make_epilogue_seq (void)
    5809                 :            : {
    5810                 :     944097 :   if (!targetm.have_epilogue ())
    5811                 :            :     return NULL;
    5812                 :            : 
    5813                 :     944097 :   start_sequence ();
    5814                 :     944097 :   emit_note (NOTE_INSN_EPILOGUE_BEG);
    5815                 :     944097 :   rtx_insn *seq = targetm.gen_epilogue ();
    5816                 :     944097 :   if (seq)
    5817                 :     944097 :     emit_jump_insn (seq);
    5818                 :            : 
    5819                 :            :   /* Retain a map of the epilogue insns.  */
    5820                 :     944097 :   record_insns (seq, NULL, &epilogue_insn_hash);
    5821                 :     944097 :   set_insn_locations (seq, epilogue_location);
    5822                 :            : 
    5823                 :     944097 :   seq = get_insns ();
    5824                 :     944097 :   rtx_insn *returnjump = get_last_insn ();
    5825                 :     944097 :   end_sequence ();
    5826                 :            : 
    5827                 :     944097 :   if (JUMP_P (returnjump))
    5828                 :     944021 :     set_return_jump_label (returnjump);
    5829                 :            : 
    5830                 :            :   return seq;
    5831                 :            : }
    5832                 :            : 
    5833                 :            : 
    5834                 :            : /* Generate the prologue and epilogue RTL if the machine supports it.  Thread
    5835                 :            :    this into place with notes indicating where the prologue ends and where
    5836                 :            :    the epilogue begins.  Update the basic block information when possible.
    5837                 :            : 
    5838                 :            :    Notes on epilogue placement:
    5839                 :            :    There are several kinds of edges to the exit block:
    5840                 :            :    * a single fallthru edge from LAST_BB
    5841                 :            :    * possibly, edges from blocks containing sibcalls
    5842                 :            :    * possibly, fake edges from infinite loops
    5843                 :            : 
    5844                 :            :    The epilogue is always emitted on the fallthru edge from the last basic
    5845                 :            :    block in the function, LAST_BB, into the exit block.
    5846                 :            : 
    5847                 :            :    If LAST_BB is empty except for a label, it is the target of every
    5848                 :            :    other basic block in the function that ends in a return.  If a
    5849                 :            :    target has a return or simple_return pattern (possibly with
    5850                 :            :    conditional variants), these basic blocks can be changed so that a
    5851                 :            :    return insn is emitted into them, and their target is adjusted to
    5852                 :            :    the real exit block.
    5853                 :            : 
    5854                 :            :    Notes on shrink wrapping: We implement a fairly conservative
    5855                 :            :    version of shrink-wrapping rather than the textbook one.  We only
    5856                 :            :    generate a single prologue and a single epilogue.  This is
    5857                 :            :    sufficient to catch a number of interesting cases involving early
    5858                 :            :    exits.
    5859                 :            : 
    5860                 :            :    First, we identify the blocks that require the prologue to occur before
    5861                 :            :    them.  These are the ones that modify a call-saved register, or reference
    5862                 :            :    any of the stack or frame pointer registers.  To simplify things, we then
    5863                 :            :    mark everything reachable from these blocks as also requiring a prologue.
    5864                 :            :    This takes care of loops automatically, and avoids the need to examine
    5865                 :            :    whether MEMs reference the frame, since it is sufficient to check for
    5866                 :            :    occurrences of the stack or frame pointer.
    5867                 :            : 
    5868                 :            :    We then compute the set of blocks for which the need for a prologue
    5869                 :            :    is anticipatable (borrowing terminology from the shrink-wrapping
    5870                 :            :    description in Muchnick's book).  These are the blocks which either
    5871                 :            :    require a prologue themselves, or those that have only successors
    5872                 :            :    where the prologue is anticipatable.  The prologue needs to be
    5873                 :            :    inserted on all edges from BB1->BB2 where BB2 is in ANTIC and BB1
    5874                 :            :    is not.  For the moment, we ensure that only one such edge exists.
    5875                 :            : 
    5876                 :            :    The epilogue is placed as described above, but we make a
    5877                 :            :    distinction between inserting return and simple_return patterns
    5878                 :            :    when modifying other blocks that end in a return.  Blocks that end
    5879                 :            :    in a sibcall omit the sibcall_epilogue if the block is not in
    5880                 :            :    ANTIC.  */
    5881                 :            : 
    5882                 :            : void
    5883                 :     944097 : thread_prologue_and_epilogue_insns (void)
    5884                 :            : {
    5885                 :     944097 :   df_analyze ();
    5886                 :            : 
    5887                 :            :   /* Can't deal with multiple successors of the entry block at the
    5888                 :            :      moment.  Function should always have at least one entry
    5889                 :            :      point.  */
    5890                 :     944097 :   gcc_assert (single_succ_p (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
    5891                 :            : 
    5892                 :     944097 :   edge entry_edge = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
    5893                 :     944097 :   edge orig_entry_edge = entry_edge;
    5894                 :            : 
    5895                 :     944097 :   rtx_insn *split_prologue_seq = make_split_prologue_seq ();
    5896                 :     944097 :   rtx_insn *prologue_seq = make_prologue_seq ();
    5897                 :     944097 :   rtx_insn *epilogue_seq = make_epilogue_seq ();
    5898                 :            : 
    5899                 :            :   /* Try to perform a kind of shrink-wrapping, making sure the
    5900                 :            :      prologue/epilogue is emitted only around those parts of the
    5901                 :            :      function that require it.  */
    5902                 :     944097 :   try_shrink_wrapping (&entry_edge, prologue_seq);
    5903                 :            : 
    5904                 :            :   /* If the target can handle splitting the prologue/epilogue into separate
    5905                 :            :      components, try to shrink-wrap these components separately.  */
    5906                 :     944097 :   try_shrink_wrapping_separate (entry_edge->dest);
    5907                 :            : 
    5908                 :            :   /* If that did anything for any component we now need the generate the
    5909                 :            :      "main" prologue again.  Because some targets require some of these
    5910                 :            :      to be called in a specific order (i386 requires the split prologue
    5911                 :            :      to be first, for example), we create all three sequences again here.
    5912                 :            :      If this does not work for some target, that target should not enable
    5913                 :            :      separate shrink-wrapping.  */
    5914                 :     944097 :   if (crtl->shrink_wrapped_separate)
    5915                 :            :     {
    5916                 :          0 :       split_prologue_seq = make_split_prologue_seq ();
    5917                 :          0 :       prologue_seq = make_prologue_seq ();
    5918                 :          0 :       epilogue_seq = make_epilogue_seq ();
    5919                 :            :     }
    5920                 :            : 
    5921                 :     944097 :   rtl_profile_for_bb (EXIT_BLOCK_PTR_FOR_FN (cfun));
    5922                 :            : 
    5923                 :            :   /* A small fib -- epilogue is not yet completed, but we wish to re-use
    5924                 :            :      this marker for the splits of EH_RETURN patterns, and nothing else
    5925                 :            :      uses the flag in the meantime.  */
    5926                 :     944097 :   epilogue_completed = 1;
    5927                 :            : 
    5928                 :            :   /* Find non-fallthru edges that end with EH_RETURN instructions.  On
    5929                 :            :      some targets, these get split to a special version of the epilogue
    5930                 :            :      code.  In order to be able to properly annotate these with unwind
    5931                 :            :      info, try to split them now.  If we get a valid split, drop an
    5932                 :            :      EPILOGUE_BEG note and mark the insns as epilogue insns.  */
    5933                 :     944097 :   edge e;
    5934                 :     944097 :   edge_iterator ei;
    5935                 :    1924010 :   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
    5936                 :            :     {
    5937                 :     979909 :       rtx_insn *prev, *last, *trial;
    5938                 :            : 
    5939                 :     979909 :       if (e->flags & EDGE_FALLTHRU)
    5940                 :     860735 :         continue;
    5941                 :     119174 :       last = BB_END (e->src);
    5942                 :     119174 :       if (!eh_returnjump_p (last))
    5943                 :     119150 :         continue;
    5944                 :            : 
    5945                 :         24 :       prev = PREV_INSN (last);
    5946                 :         24 :       trial = try_split (PATTERN (last), last, 1);
    5947                 :         24 :       if (trial == last)
    5948                 :          0 :         continue;
    5949                 :            : 
    5950                 :         24 :       record_insns (NEXT_INSN (prev), NEXT_INSN (trial), &epilogue_insn_hash);
    5951                 :         24 :       emit_note_after (NOTE_INSN_EPILOGUE_BEG, prev);
    5952                 :            :     }
    5953                 :            : 
    5954                 :     944097 :   edge exit_fallthru_edge = find_fallthru_edge (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds);
    5955                 :            : 
    5956                 :     944097 :   if (exit_fallthru_edge)
    5957                 :            :     {
    5958                 :     860735 :       if (epilogue_seq)
    5959                 :            :         {
    5960                 :     860735 :           insert_insn_on_edge (epilogue_seq, exit_fallthru_edge);
    5961                 :     860735 :           commit_edge_insertions ();
    5962                 :            : 
    5963                 :            :           /* The epilogue insns we inserted may cause the exit edge to no longer
    5964                 :            :              be fallthru.  */
    5965                 :    1776650 :           FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
    5966                 :            :             {
    5967                 :     915915 :               if (((e->flags & EDGE_FALLTHRU) != 0)
    5968                 :     915915 :                   && returnjump_p (BB_END (e->src)))
    5969                 :          0 :                 e->flags &= ~EDGE_FALLTHRU;
    5970                 :            :             }
    5971                 :            :         }
    5972                 :          0 :       else if (next_active_insn (BB_END (exit_fallthru_edge->src)))
    5973                 :            :         {
    5974                 :            :           /* We have a fall-through edge to the exit block, the source is not
    5975                 :            :              at the end of the function, and there will be an assembler epilogue
    5976                 :            :              at the end of the function.
    5977                 :            :              We can't use force_nonfallthru here, because that would try to
    5978                 :            :              use return.  Inserting a jump 'by hand' is extremely messy, so
    5979                 :            :              we take advantage of cfg_layout_finalize using
    5980                 :            :              fixup_fallthru_exit_predecessor.  */
    5981                 :          0 :           cfg_layout_initialize (0);
    5982                 :          0 :           basic_block cur_bb;
    5983                 :          0 :           FOR_EACH_BB_FN (cur_bb, cfun)
    5984                 :          0 :             if (cur_bb->index >= NUM_FIXED_BLOCKS
    5985                 :          0 :                 && cur_bb->next_bb->index >= NUM_FIXED_BLOCKS)
    5986                 :          0 :               cur_bb->aux = cur_bb->next_bb;
    5987                 :          0 :           cfg_layout_finalize ();
    5988                 :            :         }
    5989                 :            :     }
    5990                 :            : 
    5991                 :            :   /* Insert the prologue.  */
    5992                 :            : 
    5993                 :     944097 :   rtl_profile_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun));
    5994                 :            : 
    5995                 :     944097 :   if (split_prologue_seq || prologue_seq)
    5996                 :            :     {
    5997                 :     944097 :       rtx_insn *split_prologue_insn = split_prologue_seq;
    5998                 :     944097 :       if (split_prologue_seq)
    5999                 :            :         {
    6000                 :     179485 :           while (split_prologue_insn && !NONDEBUG_INSN_P (split_prologue_insn))
    6001                 :          0 :             split_prologue_insn = NEXT_INSN (split_prologue_insn);
    6002                 :     179485 :           insert_insn_on_edge (split_prologue_seq, orig_entry_edge);
    6003                 :            :         }
    6004                 :            : 
    6005                 :     944097 :       rtx_insn *prologue_insn = prologue_seq;
    6006                 :     944097 :       if (prologue_seq)
    6007                 :            :         {
    6008                 :    1209970 :           while (prologue_insn && !NONDEBUG_INSN_P (prologue_insn))
    6009                 :     265877 :             prologue_insn = NEXT_INSN (prologue_insn);
    6010                 :     944097 :           insert_insn_on_edge (prologue_seq, entry_edge);
    6011                 :            :         }
    6012                 :            : 
    6013                 :     944097 :       commit_edge_insertions ();
    6014                 :            : 
    6015                 :            :       /* Look for basic blocks within the prologue insns.  */
    6016                 :     944097 :       if (split_prologue_insn
    6017                 :     944097 :           && BLOCK_FOR_INSN (split_prologue_insn) == NULL)
    6018                 :            :         split_prologue_insn = NULL;
    6019                 :     944097 :       if (prologue_insn
    6020                 :     944097 :           && BLOCK_FOR_INSN (prologue_insn) == NULL)
    6021                 :            :         prologue_insn = NULL;
    6022                 :     944097 :       if (split_prologue_insn || prologue_insn)
    6023                 :            :         {
    6024                 :    1393860 :           auto_sbitmap blocks (last_basic_block_for_fn (cfun));
    6025                 :     696929 :           bitmap_clear (blocks);
    6026                 :     696929 :           if (split_prologue_insn)
    6027                 :     179485 :             bitmap_set_bit (blocks,
    6028                 :     179485 :                             BLOCK_FOR_INSN (split_prologue_insn)->index);
    6029                 :     696929 :           if (prologue_insn)
    6030                 :     678220 :             bitmap_set_bit (blocks, BLOCK_FOR_INSN (prologue_insn)->index);
    6031                 :     696929 :           find_many_sub_basic_blocks (blocks);
    6032                 :            :         }
    6033                 :            :     }
    6034                 :            : 
    6035                 :     944097 :   default_rtl_profile ();
    6036                 :            : 
    6037                 :            :   /* Emit sibling epilogues before any sibling call sites.  */
    6038                 :    1924010 :   for (ei = ei_start (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds);
    6039                 :    1924010 :        (e = ei_safe_edge (ei));
    6040                 :     979909 :        ei_next (&ei))
    6041                 :            :     {
    6042                 :            :       /* Skip those already handled, the ones that run without prologue.  */
    6043                 :     979909 :       if (e->flags & EDGE_IGNORE)
    6044                 :            :         {
    6045                 :       1873 :           e->flags &= ~EDGE_IGNORE;
    6046                 :       1873 :           continue;
    6047                 :            :         }
    6048                 :            : 
    6049                 :     978036 :       rtx_insn *insn = BB_END (e->src);
    6050                 :            : 
    6051                 :     978036 :       if (!(CALL_P (insn) && SIBLING_CALL_P (insn)))
    6052                 :     888367 :         continue;
    6053                 :            : 
    6054                 :      89669 :       if (rtx_insn *ep_seq = targetm.gen_sibcall_epilogue ())
    6055                 :            :         {
    6056                 :      40394 :           start_sequence ();
    6057                 :      40394 :           emit_note (NOTE_INSN_EPILOGUE_BEG);
    6058                 :      40394 :           emit_insn (ep_seq);
    6059                 :      40394 :           rtx_insn *seq = get_insns ();
    6060                 :      40394 :           end_sequence ();
    6061                 :            : 
    6062                 :            :           /* Retain a map of the epilogue insns.  Used in life analysis to
    6063                 :            :              avoid getting rid of sibcall epilogue insns.  Do this before we
    6064                 :            :              actually emit the sequence.  */
    6065                 :      40394 :           record_insns (seq, NULL, &epilogue_insn_hash);
    6066                 :      40394 :           set_insn_locations (seq, epilogue_location);
    6067                 :            : 
    6068                 :      40394 :           emit_insn_before (seq, insn);
    6069                 :            :         }
    6070                 :            :     }
    6071                 :            : 
    6072                 :     944097 :   if (epilogue_seq)
    6073                 :            :     {
    6074                 :            :       rtx_insn *insn, *next;
    6075                 :            : 
    6076                 :            :       /* Similarly, move any line notes that appear after the epilogue.
    6077                 :            :          There is no need, however, to be quite so anal about the existence
    6078                 :            :          of such a note.  Also possibly move
    6079                 :            :          NOTE_INSN_FUNCTION_BEG notes, as those can be relevant for debug
    6080                 :            :          info generation.  */
    6081                 :    7046490 :       for (insn = epilogue_seq; insn; insn = next)
    6082                 :            :         {
    6083                 :    6102400 :           next = NEXT_INSN (insn);
    6084                 :    6102400 :           if (NOTE_P (insn)
    6085                 :    1950000 :               && (NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG))
    6086                 :          0 :             reorder_insns (insn, insn, PREV_INSN (epilogue_seq));
    6087                 :            :         }
    6088                 :            :     }
    6089                 :            : 
    6090                 :            :   /* Threading the prologue and epilogue changes the artificial refs
    6091                 :            :      in the entry and exit blocks.  */
    6092                 :     944097 :   epilogue_completed = 1;
    6093                 :     944097 :   df_update_entry_exit_and_calls ();
    6094                 :     944097 : }
    6095                 :            : 
    6096                 :            : /* Reposition the prologue-end and epilogue-begin notes after
    6097                 :            :    instruction scheduling.  */
    6098                 :            : 
    6099                 :            : void
    6100                 :     645397 : reposition_prologue_and_epilogue_notes (void)
    6101                 :            : {
    6102                 :     645397 :   if (!targetm.have_prologue ()
    6103                 :          0 :       && !targetm.have_epilogue ()
    6104                 :     645397 :       && !targetm.have_sibcall_epilogue ())
    6105                 :            :     return;
    6106                 :            : 
    6107                 :            :   /* Since the hash table is created on demand, the fact that it is
    6108                 :            :      non-null is a signal that it is non-empty.  */
    6109                 :     645397 :   if (prologue_insn_hash != NULL)
    6110                 :            :     {
    6111                 :     645397 :       size_t len = prologue_insn_hash->elements ();
    6112                 :     645397 :       rtx_insn *insn, *last = NULL, *note = NULL;
    6113                 :            : 
    6114                 :            :       /* Scan from the beginning until we reach the last prologue insn.  */
    6115                 :            :       /* ??? While we do have the CFG intact, there are two problems:
    6116                 :            :          (1) The prologue can contain loops (typically probing the stack),
    6117                 :            :              which means that the end of the prologue isn't in the first bb.
    6118                 :            :          (2) Sometimes the PROLOGUE_END note gets pushed into the next bb.  */
    6119                 :   66169400 :       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
    6120                 :            :         {
    6121                 :   33086000 :           if (NOTE_P (insn))
    6122                 :            :             {
    6123                 :    7598940 :               if (NOTE_KIND (insn) == NOTE_INSN_PROLOGUE_END)
    6124                 :     642850 :                 note = insn;
    6125                 :            :             }
    6126                 :   25487000 :           else if (contains (insn, prologue_insn_hash))
    6127                 :            :             {
    6128                 :    2330830 :               last = insn;
    6129                 :    2330830 :               if (--len == 0)
    6130                 :            :                 break;
    6131                 :            :             }
    6132                 :            :         }
    6133                 :            : 
    6134                 :     645397 :       if (last)
    6135                 :            :         {
    6136                 :     415857 :           if (note == NULL)
    6137                 :            :             {
    6138                 :            :               /* Scan forward looking for the PROLOGUE_END note.  It should
    6139                 :            :                  be right at the beginning of the block, possibly with other
    6140                 :            :                  insn notes that got moved there.  */
    6141                 :       4893 :               for (note = NEXT_INSN (last); ; note = NEXT_INSN (note))
    6142                 :            :                 {
    6143                 :       4893 :                   if (NOTE_P (note)
    6144                 :       4600 :                       && NOTE_KIND (note) == NOTE_INSN_PROLOGUE_END)
    6145                 :            :                     break;
    6146                 :            :                 }
    6147                 :            :             }
    6148                 :            : 
    6149                 :            :           /* Avoid placing note between CODE_LABEL and BASIC_BLOCK note.  */
    6150                 :     415857 :           if (LABEL_P (last))
    6151                 :       4001 :             last = NEXT_INSN (last);
    6152                 :     415857 :           reorder_insns (note, note, last);
    6153                 :            :         }
    6154                 :            :     }
    6155                 :            : 
    6156                 :     645397 :   if (epilogue_insn_hash != NULL)
    6157                 :            :     {
    6158                 :     645397 :       edge_iterator ei;
    6159                 :     645397 :       edge e;
    6160                 :            : 
    6161                 :    1437140 :       FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
    6162                 :            :         {
    6163                 :     791739 :           rtx_insn *insn, *first = NULL, *note = NULL;
    6164                 :     791739 :           basic_block bb = e->src;
    6165                 :            : 
    6166                 :            :           /* Scan from the beginning until we reach the first epilogue insn. */
    6167                 :   20087600 :           FOR_BB_INSNS (bb, insn)
    6168                 :            :             {
    6169                 :   10352100 :               if (NOTE_P (insn))
    6170                 :            :                 {
    6171                 :    2464170 :                   if (NOTE_KIND (insn) == NOTE_INSN_EPILOGUE_BEG)
    6172                 :            :                     {
    6173                 :     704156 :                       note = insn;
    6174                 :     704156 :                       if (first != NULL)
    6175                 :            :                         break;
    6176                 :            :                     }
    6177                 :            :                 }
    6178                 :    7887920 :               else if (first == NULL && contains (insn, epilogue_insn_hash))
    6179                 :            :                 {
    6180                 :     704160 :                   first = insn;
    6181                 :     704160 :                   if (note != NULL)
    6182                 :            :                     break;
    6183                 :            :                 }
    6184                 :            :             }
    6185                 :            : 
    6186                 :     791739 :           if (note)
    6187                 :            :             {
    6188                 :            :               /* If the function has a single basic block, and no real
    6189                 :            :                  epilogue insns (e.g. sibcall with no cleanup), the
    6190                 :            :                  epilogue note can get scheduled before the prologue
    6191                 :            :                  note.  If we have frame related prologue insns, having
    6192                 :            :                  them scanned during the epilogue will result in a crash.
    6193                 :            :                  In this case re-order the epilogue note to just before
    6194                 :            :                  the last insn in the block.  */
    6195                 :     704156 :               if (first == NULL)
    6196                 :          0 :                 first = BB_END (bb);
    6197                 :            : 
    6198                 :     704156 :               if (PREV_INSN (first) != note)
    6199                 :      14614 :                 reorder_insns (note, note, PREV_INSN (first));
    6200                 :            :             }
    6201                 :            :         }
    6202                 :            :     }
    6203                 :            : }
    6204                 :            : 
    6205                 :            : /* Returns the name of function declared by FNDECL.  */
    6206                 :            : const char *
    6207                 :      72339 : fndecl_name (tree fndecl)
    6208                 :            : {
    6209                 :      72339 :   if (fndecl == NULL)
    6210                 :            :     return "(nofn)";
    6211                 :      72324 :   return lang_hooks.decl_printable_name (fndecl, 1);
    6212                 :            : }
    6213                 :            : 
    6214                 :            : /* Returns the name of function FN.  */
    6215                 :            : const char *
    6216                 :      72303 : function_name (struct function *fn)
    6217                 :            : {
    6218                 :      72303 :   tree fndecl = (fn == NULL) ? NULL : fn->decl;
    6219                 :      72303 :   return fndecl_name (fndecl);
    6220                 :            : }
    6221                 :            : 
    6222                 :            : /* Returns the name of the current function.  */
    6223                 :            : const char *
    6224                 :      36532 : current_function_name (void)
    6225                 :            : {
    6226                 :      36532 :   return function_name (cfun);
    6227                 :            : }
    6228                 :            : 
    6229                 :            : 
    6230                 :            : static unsigned int
    6231                 :     944097 : rest_of_handle_check_leaf_regs (void)
    6232                 :            : {
    6233                 :            : #ifdef LEAF_REGISTERS
    6234                 :            :   crtl->uses_only_leaf_regs
    6235                 :            :     = optimize > 0 && only_leaf_regs_used () && leaf_function_p ();
    6236                 :            : #endif
    6237                 :     944097 :   return 0;
    6238                 :            : }
    6239                 :            : 
    6240                 :            : /* Insert a TYPE into the used types hash table of CFUN.  */
    6241                 :            : 
    6242                 :            : static void
    6243                 :    8214390 : used_types_insert_helper (tree type, struct function *func)
    6244                 :            : {
    6245                 :    8214390 :   if (type != NULL && func != NULL)
    6246                 :            :     {
    6247                 :    8214390 :       if (func->used_types_hash == NULL)
    6248                 :    2654050 :         func->used_types_hash = hash_set<tree>::create_ggc (37);
    6249                 :            : 
    6250                 :    8214390 :       func->used_types_hash->add (type);
    6251                 :            :     }
    6252                 :    8214390 : }
    6253                 :            : 
    6254                 :            : /* Given a type, insert it into the used hash table in cfun.  */
    6255                 :            : void
    6256                 :   84142600 : used_types_insert (tree t)
    6257                 :            : {
    6258                 :   86883200 :   while (POINTER_TYPE_P (t) || TREE_CODE (t) == ARRAY_TYPE)
    6259                 :    2831530 :     if (TYPE_NAME (t))
    6260                 :            :       break;
    6261                 :            :     else
    6262                 :    2740620 :       t = TREE_TYPE (t);
    6263                 :   84142600 :   if (TREE_CODE (t) == ERROR_MARK)
    6264                 :            :     return;
    6265                 :   84142600 :   if (TYPE_NAME (t) == NULL_TREE
    6266                 :   84142600 :       || TYPE_NAME (t) == TYPE_NAME (TYPE_MAIN_VARIANT (t)))
    6267                 :   10040600 :     t = TYPE_MAIN_VARIANT (t);
    6268                 :   84142600 :   if (debug_info_level > DINFO_LEVEL_NONE)
    6269                 :            :     {
    6270                 :   10703000 :       if (cfun)
    6271                 :    8214390 :         used_types_insert_helper (t, cfun);
    6272                 :            :       else
    6273                 :            :         {
    6274                 :            :           /* So this might be a type referenced by a global variable.
    6275                 :            :              Record that type so that we can later decide to emit its
    6276                 :            :              debug information.  */
    6277                 :    2488610 :           vec_safe_push (types_used_by_cur_var_decl, t);
    6278                 :            :         }
    6279                 :            :     }
    6280                 :            : }
    6281                 :            : 
    6282                 :            : /* Helper to Hash a struct types_used_by_vars_entry.  */
    6283                 :            : 
    6284                 :            : static hashval_t
    6285                 :   14160900 : hash_types_used_by_vars_entry (const struct types_used_by_vars_entry *entry)
    6286                 :            : {
    6287                 :   14160900 :   gcc_assert (entry && entry->var_decl && entry->type);
    6288                 :            : 
    6289                 :   14160900 :   return iterative_hash_object (entry->type,
    6290                 :            :                                 iterative_hash_object (entry->var_decl, 0));
    6291                 :            : }
    6292                 :            : 
    6293                 :            : /* Hash function of the types_used_by_vars_entry hash table.  */
    6294                 :            : 
    6295                 :            : hashval_t
    6296                 :   14160900 : used_type_hasher::hash (types_used_by_vars_entry *entry)
    6297                 :            : {
    6298                 :   14160900 :   return hash_types_used_by_vars_entry (entry);
    6299                 :            : }
    6300                 :            : 
    6301                 :            : /*Equality function of the types_used_by_vars_entry hash table.  */
    6302                 :            : 
    6303                 :            : bool
    6304                 :   15751900 : used_type_hasher::equal (types_used_by_vars_entry *e1,
    6305                 :            :                          types_used_by_vars_entry *e2)
    6306                 :            : {
    6307                 :   15751900 :   return (e1->var_decl == e2->var_decl && e1->type == e2->type);
    6308                 :            : }
    6309                 :            : 
    6310                 :            : /* Inserts an entry into the types_used_by_vars_hash hash table. */
    6311                 :            : 
    6312                 :            : void
    6313                 :    2330660 : types_used_by_var_decl_insert (tree type, tree var_decl)
    6314                 :            : {
    6315                 :    2330660 :   if (type != NULL && var_decl != NULL)
    6316                 :            :     {
    6317                 :    2330660 :       types_used_by_vars_entry **slot;
    6318                 :    2330660 :       struct types_used_by_vars_entry e;
    6319                 :    2330660 :       e.var_decl = var_decl;
    6320                 :    2330660 :       e.type = type;
    6321                 :    2330660 :       if (types_used_by_vars_hash == NULL)
    6322                 :       4597 :         types_used_by_vars_hash
    6323                 :       4597 :           = hash_table<used_type_hasher>::create_ggc (37);
    6324                 :            : 
    6325                 :    2330660 :       slot = types_used_by_vars_hash->find_slot (&e, INSERT);
    6326                 :    2330660 :       if (*slot == NULL)
    6327                 :            :         {
    6328                 :     501297 :           struct types_used_by_vars_entry *entry;
    6329                 :     501297 :           entry = ggc_alloc<types_used_by_vars_entry> ();
    6330                 :     501297 :           entry->type = type;
    6331                 :     501297 :           entry->var_decl = var_decl;
    6332                 :     501297 :           *slot = entry;
    6333                 :            :         }
    6334                 :            :     }
    6335                 :    2330660 : }
    6336                 :            : 
    6337                 :            : namespace {
    6338                 :            : 
    6339                 :            : const pass_data pass_data_leaf_regs =
    6340                 :            : {
    6341                 :            :   RTL_PASS, /* type */
    6342                 :            :   "*leaf_regs", /* name */
    6343                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    6344                 :            :   TV_NONE, /* tv_id */
    6345                 :            :   0, /* properties_required */
    6346                 :            :   0, /* properties_provided */
    6347                 :            :   0, /* properties_destroyed */
    6348                 :            :   0, /* todo_flags_start */
    6349                 :            :   0, /* todo_flags_finish */
    6350                 :            : };
    6351                 :            : 
    6352                 :            : class pass_leaf_regs : public rtl_opt_pass
    6353                 :            : {
    6354                 :            : public:
    6355                 :     200773 :   pass_leaf_regs (gcc::context *ctxt)
    6356                 :     401546 :     : rtl_opt_pass (pass_data_leaf_regs, ctxt)
    6357                 :            :   {}
    6358                 :            : 
    6359                 :            :   /* opt_pass methods: */
    6360                 :     944097 :   virtual unsigned int execute (function *)
    6361                 :            :     {
    6362                 :     944097 :       return rest_of_handle_check_leaf_regs ();
    6363                 :            :     }
    6364                 :            : 
    6365                 :            : }; // class pass_leaf_regs
    6366                 :            : 
    6367                 :            : } // anon namespace
    6368                 :            : 
    6369                 :            : rtl_opt_pass *
    6370                 :     200773 : make_pass_leaf_regs (gcc::context *ctxt)
    6371                 :            : {
    6372                 :     200773 :   return new pass_leaf_regs (ctxt);
    6373                 :            : }
    6374                 :            : 
    6375                 :            : static unsigned int
    6376                 :     944097 : rest_of_handle_thread_prologue_and_epilogue (void)
    6377                 :            : {
    6378                 :            :   /* prepare_shrink_wrap is sensitive to the block structure of the control
    6379                 :            :      flow graph, so clean it up first.  */
    6380                 :     944097 :   if (optimize)
    6381                 :     688548 :     cleanup_cfg (0);
    6382                 :            : 
    6383                 :            :   /* On some machines, the prologue and epilogue code, or parts thereof,
    6384                 :            :      can be represented as RTL.  Doing so lets us schedule insns between
    6385                 :            :      it and the rest of the code and also allows delayed branch
    6386                 :            :      scheduling to operate in the epilogue.  */
    6387                 :     944097 :   thread_prologue_and_epilogue_insns ();
    6388                 :            : 
    6389                 :            :   /* Some non-cold blocks may now be only reachable from cold blocks.
    6390                 :            :      Fix that up.  */
    6391                 :     944097 :   fixup_partitions ();
    6392                 :            : 
    6393                 :            :   /* Shrink-wrapping can result in unreachable edges in the epilogue,
    6394                 :            :      see PR57320.  */
    6395                 :    1199650 :   cleanup_cfg (optimize ? CLEANUP_EXPENSIVE : 0);
    6396                 :            : 
    6397                 :            :   /* The stack usage info is finalized during prologue expansion.  */
    6398                 :     944097 :   if (flag_stack_usage_info || flag_callgraph_info)
    6399                 :         34 :     output_stack_usage ();
    6400                 :            : 
    6401                 :     944097 :   return 0;
    6402                 :            : }
    6403                 :            : 
    6404                 :            : /* Record a final call to CALLEE at LOCATION.  */
    6405                 :            : 
    6406                 :            : void
    6407                 :          0 : record_final_call (tree callee, location_t location)
    6408                 :            : {
    6409                 :          0 :   struct callinfo_callee datum = { location, callee };
    6410                 :          0 :   vec_safe_push (cfun->su->callees, datum);
    6411                 :          0 : }
    6412                 :            : 
    6413                 :            : /* Record a dynamic allocation made for DECL_OR_EXP.  */
    6414                 :            : 
    6415                 :            : void
    6416                 :          0 : record_dynamic_alloc (tree decl_or_exp)
    6417                 :            : {
    6418                 :          0 :   struct callinfo_dalloc datum;
    6419                 :            : 
    6420                 :          0 :   if (DECL_P (decl_or_exp))
    6421                 :            :     {
    6422                 :          0 :       datum.location = DECL_SOURCE_LOCATION (decl_or_exp);
    6423                 :          0 :       const char *name = lang_hooks.decl_printable_name (decl_or_exp, 2);
    6424                 :          0 :       const char *dot = strrchr (name, '.');
    6425                 :          0 :       if (dot)
    6426                 :          0 :         name = dot + 1;
    6427                 :          0 :       datum.name = ggc_strdup (name);
    6428                 :            :     }
    6429                 :            :   else
    6430                 :            :     {
    6431                 :          0 :       datum.location = EXPR_LOCATION (decl_or_exp);
    6432                 :          0 :       datum.name = NULL;
    6433                 :            :     }
    6434                 :            : 
    6435                 :          0 :   vec_safe_push (cfun->su->dallocs, datum);
    6436                 :          0 : }
    6437                 :            : 
    6438                 :            : namespace {
    6439                 :            : 
    6440                 :            : const pass_data pass_data_thread_prologue_and_epilogue =
    6441                 :            : {
    6442                 :            :   RTL_PASS, /* type */
    6443                 :            :   "pro_and_epilogue", /* name */
    6444                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    6445                 :            :   TV_THREAD_PROLOGUE_AND_EPILOGUE, /* tv_id */
    6446                 :            :   0, /* properties_required */
    6447                 :            :   0, /* properties_provided */
    6448                 :            :   0, /* properties_destroyed */
    6449                 :            :   0, /* todo_flags_start */
    6450                 :            :   ( TODO_df_verify | TODO_df_finish ), /* todo_flags_finish */
    6451                 :            : };
    6452                 :            : 
    6453                 :            : class pass_thread_prologue_and_epilogue : public rtl_opt_pass
    6454                 :            : {
    6455                 :            : public:
    6456                 :     200773 :   pass_thread_prologue_and_epilogue (gcc::context *ctxt)
    6457                 :     401546 :     : rtl_opt_pass (pass_data_thread_prologue_and_epilogue, ctxt)
    6458                 :            :   {}
    6459                 :            : 
    6460                 :            :   /* opt_pass methods: */
    6461                 :     944097 :   virtual unsigned int execute (function *)
    6462                 :            :     {
    6463                 :     944097 :       return rest_of_handle_thread_prologue_and_epilogue ();
    6464                 :            :     }
    6465                 :            : 
    6466                 :            : }; // class pass_thread_prologue_and_epilogue
    6467                 :            : 
    6468                 :            : } // anon namespace
    6469                 :            : 
    6470                 :            : rtl_opt_pass *
    6471                 :     200773 : make_pass_thread_prologue_and_epilogue (gcc::context *ctxt)
    6472                 :            : {
    6473                 :     200773 :   return new pass_thread_prologue_and_epilogue (ctxt);
    6474                 :            : }
    6475                 :            : 
    6476                 :            : 
    6477                 :            : /* If CONSTRAINT is a matching constraint, then return its number.
    6478                 :            :    Otherwise, return -1.  */
    6479                 :            : 
    6480                 :            : static int
    6481                 :      35626 : matching_constraint_num (const char *constraint)
    6482                 :            : {
    6483                 :      35626 :   if (*constraint == '%')
    6484                 :        938 :     constraint++;
    6485                 :            : 
    6486                 :      35626 :   if (IN_RANGE (*constraint, '0', '9'))
    6487                 :      30123 :     return strtoul (constraint, NULL, 10);
    6488                 :            : 
    6489                 :            :   return -1;
    6490                 :            : }
    6491                 :            : 
    6492                 :            : /* This mini-pass fixes fall-out from SSA in asm statements that have
    6493                 :            :    in-out constraints.  Say you start with
    6494                 :            : 
    6495                 :            :      orig = inout;
    6496                 :            :      asm ("": "+mr" (inout));
    6497                 :            :      use (orig);
    6498                 :            : 
    6499                 :            :    which is transformed very early to use explicit output and match operands:
    6500                 :            : 
    6501                 :            :      orig = inout;
    6502                 :            :      asm ("": "=mr" (inout) : "0" (inout));
    6503                 :            :      use (orig);
    6504                 :            : 
    6505                 :            :    Or, after SSA and copyprop,
    6506                 :            : 
    6507                 :            :      asm ("": "=mr" (inout_2) : "0" (inout_1));
    6508                 :            :      use (inout_1);
    6509                 :            : 
    6510                 :            :    Clearly inout_2 and inout_1 can't be coalesced easily anymore, as
    6511                 :            :    they represent two separate values, so they will get different pseudo
    6512                 :            :    registers during expansion.  Then, since the two operands need to match
    6513                 :            :    per the constraints, but use different pseudo registers, reload can
    6514                 :            :    only register a reload for these operands.  But reloads can only be
    6515                 :            :    satisfied by hardregs, not by memory, so we need a register for this
    6516                 :            :    reload, just because we are presented with non-matching operands.
    6517                 :            :    So, even though we allow memory for this operand, no memory can be
    6518                 :            :    used for it, just because the two operands don't match.  This can
    6519                 :            :    cause reload failures on register-starved targets.
    6520                 :            : 
    6521                 :            :    So it's a symptom of reload not being able to use memory for reloads
    6522                 :            :    or, alternatively it's also a symptom of both operands not coming into
    6523                 :            :    reload as matching (in which case the pseudo could go to memory just
    6524                 :            :    fine, as the alternative allows it, and no reload would be necessary).
    6525                 :            :    We fix the latter problem here, by transforming
    6526                 :            : 
    6527                 :            :      asm ("": "=mr" (inout_2) : "0" (inout_1));
    6528                 :            : 
    6529                 :            :    back to
    6530                 :            : 
    6531                 :            :      inout_2 = inout_1;
    6532                 :            :      asm ("": "=mr" (inout_2) : "0" (inout_2));  */
    6533                 :            : 
    6534                 :            : static void
    6535                 :      28336 : match_asm_constraints_1 (rtx_insn *insn, rtx *p_sets, int noutputs)
    6536                 :            : {
    6537                 :      28336 :   int i;
    6538                 :      28336 :   bool changed = false;
    6539                 :      28336 :   rtx op = SET_SRC (p_sets[0]);
    6540                 :      28336 :   int ninputs = ASM_OPERANDS_INPUT_LENGTH (op);
    6541                 :      28336 :   rtvec inputs = ASM_OPERANDS_INPUT_VEC (op);
    6542                 :      28336 :   bool *output_matched = XALLOCAVEC (bool, noutputs);
    6543                 :            : 
    6544                 :      28336 :   memset (output_matched, 0, noutputs * sizeof (bool));
    6545                 :      63191 :   for (i = 0; i < ninputs; i++)
    6546                 :            :     {
    6547                 :      34855 :       rtx input, output;
    6548                 :      34855 :       rtx_insn *insns;
    6549                 :      34855 :       const char *constraint = ASM_OPERANDS_INPUT_CONSTRAINT (op, i);
    6550                 :      34855 :       int match, j;
    6551                 :            : 
    6552                 :      34855 :       match = matching_constraint_num (constraint);
    6553                 :      34855 :       if (match < 0)
    6554                 :       5501 :         continue;
    6555                 :            : 
    6556                 :      29354 :       gcc_assert (match < noutputs);
    6557                 :      29354 :       output = SET_DEST (p_sets[match]);
    6558                 :      29354 :       input = RTVEC_ELT (inputs, i);
    6559                 :            :       /* Only do the transformation for pseudos.  */
    6560                 :      30235 :       if (! REG_P (output)
    6561                 :      29190 :           || rtx_equal_p (output, input)
    6562                 :      28633 :           || !(REG_P (input) || SUBREG_P (input)
    6563                 :       7221 :                || MEM_P (input) || CONSTANT_P (input))
    6564                 :      57986 :           || !general_operand (input, GET_MODE (output)))
    6565                 :        881 :         continue;
    6566                 :            : 
    6567                 :            :       /* We can't do anything if the output is also used as input,
    6568                 :            :          as we're going to overwrite it.  */
    6569                 :      73465 :       for (j = 0; j < ninputs; j++)
    6570                 :      44992 :         if (reg_overlap_mentioned_p (output, RTVEC_ELT (inputs, j)))
    6571                 :            :           break;
    6572                 :      28473 :       if (j != ninputs)
    6573                 :          0 :         continue;
    6574                 :            : 
    6575                 :            :       /* Avoid changing the same input several times.  For
    6576                 :            :          asm ("" : "=mr" (out1), "=mr" (out2) : "0" (in), "1" (in));
    6577                 :            :          only change it once (to out1), rather than changing it
    6578                 :            :          first to out1 and afterwards to out2.  */
    6579                 :      28473 :       if (i > 0)
    6580                 :            :         {
    6581                 :      27423 :           for (j = 0; j < noutputs; j++)
    6582                 :      21954 :             if (output_matched[j] && input == SET_DEST (p_sets[j]))
    6583                 :            :               break;
    6584                 :       5524 :           if (j != noutputs)
    6585                 :         55 :             continue;
    6586                 :            :         }
    6587                 :      28418 :       output_matched[match] = true;
    6588                 :            : 
    6589                 :      28418 :       start_sequence ();
    6590                 :      28418 :       emit_move_insn (output, copy_rtx (input));
    6591                 :      28418 :       insns = get_insns ();
    6592                 :      28418 :       end_sequence ();
    6593                 :      28418 :       emit_insn_before (insns, insn);
    6594                 :            : 
    6595                 :      28418 :       constraint = ASM_OPERANDS_OUTPUT_CONSTRAINT(SET_SRC(p_sets[match]));
    6596                 :      28418 :       bool early_clobber_p = strchr (constraint, '&') != NULL;
    6597                 :            : 
    6598                 :            :       /* Now replace all mentions of the input with output.  We can't
    6599                 :            :          just replace the occurrence in inputs[i], as the register might
    6600                 :            :          also be used in some other input (or even in an address of an
    6601                 :            :          output), which would mean possibly increasing the number of
    6602                 :            :          inputs by one (namely 'output' in addition), which might pose
    6603                 :            :          a too complicated problem for reload to solve.  E.g. this situation:
    6604                 :            : 
    6605                 :            :            asm ("" : "=r" (output), "=m" (input) : "0" (input))
    6606                 :            : 
    6607                 :            :          Here 'input' is used in two occurrences as input (once for the
    6608                 :            :          input operand, once for the address in the second output operand).
    6609                 :            :          If we would replace only the occurrence of the input operand (to
    6610                 :            :          make the matching) we would be left with this:
    6611                 :            : 
    6612                 :            :            output = input
    6613                 :            :            asm ("" : "=r" (output), "=m" (input) : "0" (output))
    6614                 :            : 
    6615                 :            :          Now we suddenly have two different input values (containing the same
    6616                 :            :          value, but different pseudos) where we formerly had only one.
    6617                 :            :          With more complicated asms this might lead to reload failures
    6618                 :            :          which wouldn't have happen without this pass.  So, iterate over
    6619                 :            :          all operands and replace all occurrences of the register used.
    6620                 :            : 
    6621                 :            :          However, if one or more of the 'input' uses have a non-matching
    6622                 :            :          constraint and the matched output operand is an early clobber
    6623                 :            :          operand, then do not replace the input operand, since by definition
    6624                 :            :          it conflicts with the output operand and cannot share the same
    6625                 :            :          register.  See PR89313 for details.  */
    6626                 :            : 
    6627                 :     135828 :       for (j = 0; j < noutputs; j++)
    6628                 :     107410 :         if (!rtx_equal_p (SET_DEST (p_sets[j]), input)
    6629                 :     107410 :             && reg_overlap_mentioned_p (input, SET_DEST (p_sets[j])))
    6630                 :         19 :           SET_DEST (p_sets[j]) = replace_rtx (SET_DEST (p_sets[j]),
    6631                 :            :                                               input, output);
    6632                 :      73196 :       for (j = 0; j < ninputs; j++)
    6633                 :      44778 :         if (reg_overlap_mentioned_p (input, RTVEC_ELT (inputs, j)))
    6634                 :            :           {
    6635                 :      22603 :             if (!early_clobber_p
    6636                 :      23374 :                 || match == matching_constraint_num
    6637                 :        771 :                               (ASM_OPERANDS_INPUT_CONSTRAINT (op, j)))
    6638                 :      22601 :               RTVEC_ELT (inputs, j) = replace_rtx (RTVEC_ELT (inputs, j),
    6639                 :            :                                                    input, output);
    6640                 :            :           }
    6641                 :            : 
    6642                 :            :       changed = true;
    6643                 :            :     }
    6644                 :            : 
    6645                 :      28336 :   if (changed)
    6646                 :      23192 :     df_insn_rescan (insn);
    6647                 :      28336 : }
    6648                 :            : 
    6649                 :            : /* Add the decl D to the local_decls list of FUN.  */
    6650                 :            : 
    6651                 :            : void
    6652                 :   23208700 : add_local_decl (struct function *fun, tree d)
    6653                 :            : {
    6654                 :   23208700 :   gcc_assert (VAR_P (d));
    6655                 :   23208700 :   vec_safe_push (fun->local_decls, d);
    6656                 :   23208700 : }
    6657                 :            : 
    6658                 :            : namespace {
    6659                 :            : 
    6660                 :            : const pass_data pass_data_match_asm_constraints =
    6661                 :            : {
    6662                 :            :   RTL_PASS, /* type */
    6663                 :            :   "asmcons", /* name */
    6664                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    6665                 :            :   TV_NONE, /* tv_id */
    6666                 :            :   0, /* properties_required */
    6667                 :            :   0, /* properties_provided */
    6668                 :            :   0, /* properties_destroyed */
    6669                 :            :   0, /* todo_flags_start */
    6670                 :            :   0, /* todo_flags_finish */
    6671                 :            : };
    6672                 :            : 
    6673                 :            : class pass_match_asm_constraints : public rtl_opt_pass
    6674                 :            : {
    6675                 :            : public:
    6676                 :     200773 :   pass_match_asm_constraints (gcc::context *ctxt)
    6677                 :     401546 :     : rtl_opt_pass (pass_data_match_asm_constraints, ctxt)
    6678                 :            :   {}
    6679                 :            : 
    6680                 :            :   /* opt_pass methods: */
    6681                 :            :   virtual unsigned int execute (function *);
    6682                 :            : 
    6683                 :            : }; // class pass_match_asm_constraints
    6684                 :            : 
    6685                 :            : unsigned
    6686                 :     944095 : pass_match_asm_constraints::execute (function *fun)
    6687                 :            : {
    6688                 :     944095 :   basic_block bb;
    6689                 :     944095 :   rtx_insn *insn;
    6690                 :     944095 :   rtx pat, *p_sets;
    6691                 :     944095 :   int noutputs;
    6692                 :            : 
    6693                 :     944095 :   if (!crtl->has_asm_statement)
    6694                 :            :     return 0;
    6695                 :            : 
    6696                 :      29087 :   df_set_flags (DF_DEFER_INSN_RESCAN);
    6697                 :     232489 :   FOR_EACH_BB_FN (bb, fun)
    6698                 :            :     {
    6699                 :    5498570 :       FOR_BB_INSNS (bb, insn)
    6700                 :            :         {
    6701                 :    2647580 :           if (!INSN_P (insn))
    6702                 :     419620 :             continue;
    6703                 :            : 
    6704                 :    2227960 :           pat = PATTERN (insn);
    6705                 :    2227960 :           if (GET_CODE (pat) == PARALLEL)
    6706                 :     309590 :             p_sets = &XVECEXP (pat, 0, 0), noutputs = XVECLEN (pat, 0);
    6707                 :    1918370 :           else if (GET_CODE (pat) == SET)
    6708                 :    1374310 :             p_sets = &PATTERN (insn), noutputs = 1;
    6709                 :            :           else
    6710                 :     544062 :             continue;
    6711                 :            : 
    6712                 :    1683900 :           if (GET_CODE (*p_sets) == SET
    6713                 :    1621270 :               && GET_CODE (SET_SRC (*p_sets)) == ASM_OPERANDS)
    6714                 :      28336 :             match_asm_constraints_1 (insn, p_sets, noutputs);
    6715                 :            :          }
    6716                 :            :     }
    6717                 :            : 
    6718                 :            :   return TODO_df_finish;
    6719                 :            : }
    6720                 :            : 
    6721                 :            : } // anon namespace
    6722                 :            : 
    6723                 :            : rtl_opt_pass *
    6724                 :     200773 : make_pass_match_asm_constraints (gcc::context *ctxt)
    6725                 :            : {
    6726                 :     200773 :   return new pass_match_asm_constraints (ctxt);
    6727                 :            : }
    6728                 :            : 
    6729                 :            : 
    6730                 :            : #include "gt-function.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.