LCOV - code coverage report
Current view: top level - gcc - gimplify.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 7040 7491 94.0 %
Date: 2020-04-04 11:58:09 Functions: 161 171 94.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Tree lowering pass.  This pass converts the GENERIC functions-as-trees
       2                 :            :    tree representation into the GIMPLE form.
       3                 :            :    Copyright (C) 2002-2020 Free Software Foundation, Inc.
       4                 :            :    Major work done by Sebastian Pop <s.pop@laposte.net>,
       5                 :            :    Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
       6                 :            : 
       7                 :            : This file is part of GCC.
       8                 :            : 
       9                 :            : GCC is free software; you can redistribute it and/or modify it under
      10                 :            : the terms of the GNU General Public License as published by the Free
      11                 :            : Software Foundation; either version 3, or (at your option) any later
      12                 :            : version.
      13                 :            : 
      14                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      15                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      16                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      17                 :            : for more details.
      18                 :            : 
      19                 :            : You should have received a copy of the GNU General Public License
      20                 :            : along with GCC; see the file COPYING3.  If not see
      21                 :            : <http://www.gnu.org/licenses/>.  */
      22                 :            : 
      23                 :            : #include "config.h"
      24                 :            : #include "system.h"
      25                 :            : #include "coretypes.h"
      26                 :            : #include "backend.h"
      27                 :            : #include "target.h"
      28                 :            : #include "rtl.h"
      29                 :            : #include "tree.h"
      30                 :            : #include "memmodel.h"
      31                 :            : #include "tm_p.h"
      32                 :            : #include "gimple.h"
      33                 :            : #include "gimple-predict.h"
      34                 :            : #include "tree-pass.h"                /* FIXME: only for PROP_gimple_any */
      35                 :            : #include "ssa.h"
      36                 :            : #include "cgraph.h"
      37                 :            : #include "tree-pretty-print.h"
      38                 :            : #include "diagnostic-core.h"
      39                 :            : #include "alias.h"
      40                 :            : #include "fold-const.h"
      41                 :            : #include "calls.h"
      42                 :            : #include "varasm.h"
      43                 :            : #include "stmt.h"
      44                 :            : #include "expr.h"
      45                 :            : #include "gimple-fold.h"
      46                 :            : #include "tree-eh.h"
      47                 :            : #include "gimplify.h"
      48                 :            : #include "gimple-iterator.h"
      49                 :            : #include "stor-layout.h"
      50                 :            : #include "print-tree.h"
      51                 :            : #include "tree-iterator.h"
      52                 :            : #include "tree-inline.h"
      53                 :            : #include "langhooks.h"
      54                 :            : #include "tree-cfg.h"
      55                 :            : #include "tree-ssa.h"
      56                 :            : #include "omp-general.h"
      57                 :            : #include "omp-low.h"
      58                 :            : #include "gimple-low.h"
      59                 :            : #include "gomp-constants.h"
      60                 :            : #include "splay-tree.h"
      61                 :            : #include "gimple-walk.h"
      62                 :            : #include "langhooks-def.h"    /* FIXME: for lhd_set_decl_assembler_name */
      63                 :            : #include "builtins.h"
      64                 :            : #include "stringpool.h"
      65                 :            : #include "attribs.h"
      66                 :            : #include "asan.h"
      67                 :            : #include "dbgcnt.h"
      68                 :            : #include "omp-offload.h"
      69                 :            : #include "context.h"
      70                 :            : 
      71                 :            : /* Hash set of poisoned variables in a bind expr.  */
      72                 :            : static hash_set<tree> *asan_poisoned_variables = NULL;
      73                 :            : 
      74                 :            : enum gimplify_omp_var_data
      75                 :            : {
      76                 :            :   GOVD_SEEN = 0x000001,
      77                 :            :   GOVD_EXPLICIT = 0x000002,
      78                 :            :   GOVD_SHARED = 0x000004,
      79                 :            :   GOVD_PRIVATE = 0x000008,
      80                 :            :   GOVD_FIRSTPRIVATE = 0x000010,
      81                 :            :   GOVD_LASTPRIVATE = 0x000020,
      82                 :            :   GOVD_REDUCTION = 0x000040,
      83                 :            :   GOVD_LOCAL = 0x00080,
      84                 :            :   GOVD_MAP = 0x000100,
      85                 :            :   GOVD_DEBUG_PRIVATE = 0x000200,
      86                 :            :   GOVD_PRIVATE_OUTER_REF = 0x000400,
      87                 :            :   GOVD_LINEAR = 0x000800,
      88                 :            :   GOVD_ALIGNED = 0x001000,
      89                 :            : 
      90                 :            :   /* Flag for GOVD_MAP: don't copy back.  */
      91                 :            :   GOVD_MAP_TO_ONLY = 0x002000,
      92                 :            : 
      93                 :            :   /* Flag for GOVD_LINEAR or GOVD_LASTPRIVATE: no outer reference.  */
      94                 :            :   GOVD_LINEAR_LASTPRIVATE_NO_OUTER = 0x004000,
      95                 :            : 
      96                 :            :   GOVD_MAP_0LEN_ARRAY = 0x008000,
      97                 :            : 
      98                 :            :   /* Flag for GOVD_MAP, if it is always, to or always, tofrom mapping.  */
      99                 :            :   GOVD_MAP_ALWAYS_TO = 0x010000,
     100                 :            : 
     101                 :            :   /* Flag for shared vars that are or might be stored to in the region.  */
     102                 :            :   GOVD_WRITTEN = 0x020000,
     103                 :            : 
     104                 :            :   /* Flag for GOVD_MAP, if it is a forced mapping.  */
     105                 :            :   GOVD_MAP_FORCE = 0x040000,
     106                 :            : 
     107                 :            :   /* Flag for GOVD_MAP: must be present already.  */
     108                 :            :   GOVD_MAP_FORCE_PRESENT = 0x080000,
     109                 :            : 
     110                 :            :   /* Flag for GOVD_MAP: only allocate.  */
     111                 :            :   GOVD_MAP_ALLOC_ONLY = 0x100000,
     112                 :            : 
     113                 :            :   /* Flag for GOVD_MAP: only copy back.  */
     114                 :            :   GOVD_MAP_FROM_ONLY = 0x200000,
     115                 :            : 
     116                 :            :   GOVD_NONTEMPORAL = 0x400000,
     117                 :            : 
     118                 :            :   /* Flag for GOVD_LASTPRIVATE: conditional modifier.  */
     119                 :            :   GOVD_LASTPRIVATE_CONDITIONAL = 0x800000,
     120                 :            : 
     121                 :            :   GOVD_CONDTEMP = 0x1000000,
     122                 :            : 
     123                 :            :   /* Flag for GOVD_REDUCTION: inscan seen in {in,ex}clusive clause.  */
     124                 :            :   GOVD_REDUCTION_INSCAN = 0x2000000,
     125                 :            : 
     126                 :            :   /* Flag for GOVD_MAP: (struct) vars that have pointer attachments for
     127                 :            :      fields.  */
     128                 :            :   GOVD_MAP_HAS_ATTACHMENTS = 8388608,
     129                 :            : 
     130                 :            :   GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
     131                 :            :                            | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LINEAR
     132                 :            :                            | GOVD_LOCAL)
     133                 :            : };
     134                 :            : 
     135                 :            : 
     136                 :            : enum omp_region_type
     137                 :            : {
     138                 :            :   ORT_WORKSHARE = 0x00,
     139                 :            :   ORT_TASKGROUP = 0x01,
     140                 :            :   ORT_SIMD      = 0x04,
     141                 :            : 
     142                 :            :   ORT_PARALLEL  = 0x08,
     143                 :            :   ORT_COMBINED_PARALLEL = ORT_PARALLEL | 1,
     144                 :            : 
     145                 :            :   ORT_TASK      = 0x10,
     146                 :            :   ORT_UNTIED_TASK = ORT_TASK | 1,
     147                 :            :   ORT_TASKLOOP  = ORT_TASK | 2,
     148                 :            :   ORT_UNTIED_TASKLOOP = ORT_UNTIED_TASK | 2,
     149                 :            : 
     150                 :            :   ORT_TEAMS     = 0x20,
     151                 :            :   ORT_COMBINED_TEAMS = ORT_TEAMS | 1,
     152                 :            :   ORT_HOST_TEAMS = ORT_TEAMS | 2,
     153                 :            :   ORT_COMBINED_HOST_TEAMS = ORT_COMBINED_TEAMS | 2,
     154                 :            : 
     155                 :            :   /* Data region.  */
     156                 :            :   ORT_TARGET_DATA = 0x40,
     157                 :            : 
     158                 :            :   /* Data region with offloading.  */
     159                 :            :   ORT_TARGET    = 0x80,
     160                 :            :   ORT_COMBINED_TARGET = ORT_TARGET | 1,
     161                 :            :   ORT_IMPLICIT_TARGET = ORT_TARGET | 2,
     162                 :            : 
     163                 :            :   /* OpenACC variants.  */
     164                 :            :   ORT_ACC       = 0x100,  /* A generic OpenACC region.  */
     165                 :            :   ORT_ACC_DATA  = ORT_ACC | ORT_TARGET_DATA, /* Data construct.  */
     166                 :            :   ORT_ACC_PARALLEL = ORT_ACC | ORT_TARGET,  /* Parallel construct */
     167                 :            :   ORT_ACC_KERNELS  = ORT_ACC | ORT_TARGET | 2,  /* Kernels construct.  */
     168                 :            :   ORT_ACC_SERIAL   = ORT_ACC | ORT_TARGET | 4,  /* Serial construct.  */
     169                 :            :   ORT_ACC_HOST_DATA = ORT_ACC | ORT_TARGET_DATA | 2,  /* Host data.  */
     170                 :            : 
     171                 :            :   /* Dummy OpenMP region, used to disable expansion of
     172                 :            :      DECL_VALUE_EXPRs in taskloop pre body.  */
     173                 :            :   ORT_NONE      = 0x200
     174                 :            : };
     175                 :            : 
     176                 :            : /* Gimplify hashtable helper.  */
     177                 :            : 
     178                 :            : struct gimplify_hasher : free_ptr_hash <elt_t>
     179                 :            : {
     180                 :            :   static inline hashval_t hash (const elt_t *);
     181                 :            :   static inline bool equal (const elt_t *, const elt_t *);
     182                 :            : };
     183                 :            : 
     184                 :            : struct gimplify_ctx
     185                 :            : {
     186                 :            :   struct gimplify_ctx *prev_context;
     187                 :            : 
     188                 :            :   vec<gbind *> bind_expr_stack;
     189                 :            :   tree temps;
     190                 :            :   gimple_seq conditional_cleanups;
     191                 :            :   tree exit_label;
     192                 :            :   tree return_temp;
     193                 :            : 
     194                 :            :   vec<tree> case_labels;
     195                 :            :   hash_set<tree> *live_switch_vars;
     196                 :            :   /* The formal temporary table.  Should this be persistent?  */
     197                 :            :   hash_table<gimplify_hasher> *temp_htab;
     198                 :            : 
     199                 :            :   int conditions;
     200                 :            :   unsigned into_ssa : 1;
     201                 :            :   unsigned allow_rhs_cond_expr : 1;
     202                 :            :   unsigned in_cleanup_point_expr : 1;
     203                 :            :   unsigned keep_stack : 1;
     204                 :            :   unsigned save_stack : 1;
     205                 :            :   unsigned in_switch_expr : 1;
     206                 :            : };
     207                 :            : 
     208                 :            : enum gimplify_defaultmap_kind
     209                 :            : {
     210                 :            :   GDMK_SCALAR,
     211                 :            :   GDMK_AGGREGATE,
     212                 :            :   GDMK_ALLOCATABLE,
     213                 :            :   GDMK_POINTER
     214                 :            : };
     215                 :            : 
     216                 :            : struct gimplify_omp_ctx
     217                 :            : {
     218                 :            :   struct gimplify_omp_ctx *outer_context;
     219                 :            :   splay_tree variables;
     220                 :            :   hash_set<tree> *privatized_types;
     221                 :            :   tree clauses;
     222                 :            :   /* Iteration variables in an OMP_FOR.  */
     223                 :            :   vec<tree> loop_iter_var;
     224                 :            :   location_t location;
     225                 :            :   enum omp_clause_default_kind default_kind;
     226                 :            :   enum omp_region_type region_type;
     227                 :            :   enum tree_code code;
     228                 :            :   bool combined_loop;
     229                 :            :   bool distribute;
     230                 :            :   bool target_firstprivatize_array_bases;
     231                 :            :   bool add_safelen1;
     232                 :            :   bool order_concurrent;
     233                 :            :   int defaultmap[4];
     234                 :            : };
     235                 :            : 
     236                 :            : static struct gimplify_ctx *gimplify_ctxp;
     237                 :            : static struct gimplify_omp_ctx *gimplify_omp_ctxp;
     238                 :            : static bool in_omp_construct;
     239                 :            : 
     240                 :            : /* Forward declaration.  */
     241                 :            : static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
     242                 :            : static hash_map<tree, tree> *oacc_declare_returns;
     243                 :            : static enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
     244                 :            :                                            bool (*) (tree), fallback_t, bool);
     245                 :            : 
     246                 :            : /* Shorter alias name for the above function for use in gimplify.c
     247                 :            :    only.  */
     248                 :            : 
     249                 :            : static inline void
     250                 :   60354400 : gimplify_seq_add_stmt (gimple_seq *seq_p, gimple *gs)
     251                 :            : {
     252                 :   60354400 :   gimple_seq_add_stmt_without_update (seq_p, gs);
     253                 :    4021590 : }
     254                 :            : 
     255                 :            : /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
     256                 :            :    NULL, a new sequence is allocated.   This function is
     257                 :            :    similar to gimple_seq_add_seq, but does not scan the operands.
     258                 :            :    During gimplification, we need to manipulate statement sequences
     259                 :            :    before the def/use vectors have been constructed.  */
     260                 :            : 
     261                 :            : static void
     262                 :    5856040 : gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
     263                 :            : {
     264                 :    5856040 :   gimple_stmt_iterator si;
     265                 :            : 
     266                 :    5856040 :   if (src == NULL)
     267                 :    2542240 :     return;
     268                 :            : 
     269                 :    3313800 :   si = gsi_last (*dst_p);
     270                 :    3313800 :   gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
     271                 :            : }
     272                 :            : 
     273                 :            : 
     274                 :            : /* Pointer to a list of allocated gimplify_ctx structs to be used for pushing
     275                 :            :    and popping gimplify contexts.  */
     276                 :            : 
     277                 :            : static struct gimplify_ctx *ctx_pool = NULL;
     278                 :            : 
     279                 :            : /* Return a gimplify context struct from the pool.  */
     280                 :            : 
     281                 :            : static inline struct gimplify_ctx *
     282                 :    5538020 : ctx_alloc (void)
     283                 :            : {
     284                 :    5538020 :   struct gimplify_ctx * c = ctx_pool;
     285                 :            : 
     286                 :    5538020 :   if (c)
     287                 :    5346540 :     ctx_pool = c->prev_context;
     288                 :            :   else
     289                 :     191479 :     c = XNEW (struct gimplify_ctx);
     290                 :            : 
     291                 :    5538020 :   memset (c, '\0', sizeof (*c));
     292                 :    5538020 :   return c;
     293                 :            : }
     294                 :            : 
     295                 :            : /* Put gimplify context C back into the pool.  */
     296                 :            : 
     297                 :            : static inline void
     298                 :    5538020 : ctx_free (struct gimplify_ctx *c)
     299                 :            : {
     300                 :    5538020 :   c->prev_context = ctx_pool;
     301                 :    5538020 :   ctx_pool = c;
     302                 :            : }
     303                 :            : 
     304                 :            : /* Free allocated ctx stack memory.  */
     305                 :            : 
     306                 :            : void
     307                 :     164036 : free_gimplify_stack (void)
     308                 :            : {
     309                 :     333491 :   struct gimplify_ctx *c;
     310                 :            : 
     311                 :     333491 :   while ((c = ctx_pool))
     312                 :            :     {
     313                 :     169455 :       ctx_pool = c->prev_context;
     314                 :     169455 :       free (c);
     315                 :            :     }
     316                 :     164036 : }
     317                 :            : 
     318                 :            : 
     319                 :            : /* Set up a context for the gimplifier.  */
     320                 :            : 
     321                 :            : void
     322                 :    5538020 : push_gimplify_context (bool in_ssa, bool rhs_cond_ok)
     323                 :            : {
     324                 :    5538020 :   struct gimplify_ctx *c = ctx_alloc ();
     325                 :            : 
     326                 :    5538020 :   c->prev_context = gimplify_ctxp;
     327                 :    5538020 :   gimplify_ctxp = c;
     328                 :    5538020 :   gimplify_ctxp->into_ssa = in_ssa;
     329                 :    5538020 :   gimplify_ctxp->allow_rhs_cond_expr = rhs_cond_ok;
     330                 :    5538020 : }
     331                 :            : 
     332                 :            : /* Tear down a context for the gimplifier.  If BODY is non-null, then
     333                 :            :    put the temporaries into the outer BIND_EXPR.  Otherwise, put them
     334                 :            :    in the local_decls.
     335                 :            : 
     336                 :            :    BODY is not a sequence, but the first tuple in a sequence.  */
     337                 :            : 
     338                 :            : void
     339                 :    5538020 : pop_gimplify_context (gimple *body)
     340                 :            : {
     341                 :    5538020 :   struct gimplify_ctx *c = gimplify_ctxp;
     342                 :            : 
     343                 :    5538020 :   gcc_assert (c
     344                 :            :               && (!c->bind_expr_stack.exists ()
     345                 :            :                   || c->bind_expr_stack.is_empty ()));
     346                 :    5538020 :   c->bind_expr_stack.release ();
     347                 :    5538020 :   gimplify_ctxp = c->prev_context;
     348                 :            : 
     349                 :    5538020 :   if (body)
     350                 :    1950530 :     declare_vars (c->temps, body, false);
     351                 :            :   else
     352                 :    3587490 :     record_vars (c->temps);
     353                 :            : 
     354                 :    5538020 :   delete c->temp_htab;
     355                 :    5538020 :   c->temp_htab = NULL;
     356                 :    5538020 :   ctx_free (c);
     357                 :    5538020 : }
     358                 :            : 
     359                 :            : /* Push a GIMPLE_BIND tuple onto the stack of bindings.  */
     360                 :            : 
     361                 :            : static void
     362                 :    4014900 : gimple_push_bind_expr (gbind *bind_stmt)
     363                 :            : {
     364                 :    4014900 :   gimplify_ctxp->bind_expr_stack.reserve (8);
     365                 :    4014900 :   gimplify_ctxp->bind_expr_stack.safe_push (bind_stmt);
     366                 :    4014900 : }
     367                 :            : 
     368                 :            : /* Pop the first element off the stack of bindings.  */
     369                 :            : 
     370                 :            : static void
     371                 :    4014900 : gimple_pop_bind_expr (void)
     372                 :            : {
     373                 :    4014900 :   gimplify_ctxp->bind_expr_stack.pop ();
     374                 :    4014900 : }
     375                 :            : 
     376                 :            : /* Return the first element of the stack of bindings.  */
     377                 :            : 
     378                 :            : gbind *
     379                 :          0 : gimple_current_bind_expr (void)
     380                 :            : {
     381                 :          0 :   return gimplify_ctxp->bind_expr_stack.last ();
     382                 :            : }
     383                 :            : 
     384                 :            : /* Return the stack of bindings created during gimplification.  */
     385                 :            : 
     386                 :            : vec<gbind *>
     387                 :          0 : gimple_bind_expr_stack (void)
     388                 :            : {
     389                 :          0 :   return gimplify_ctxp->bind_expr_stack;
     390                 :            : }
     391                 :            : 
     392                 :            : /* Return true iff there is a COND_EXPR between us and the innermost
     393                 :            :    CLEANUP_POINT_EXPR.  This info is used by gimple_push_cleanup.  */
     394                 :            : 
     395                 :            : static bool
     396                 :    1628080 : gimple_conditional_context (void)
     397                 :            : {
     398                 :    1628080 :   return gimplify_ctxp->conditions > 0;
     399                 :            : }
     400                 :            : 
     401                 :            : /* Note that we've entered a COND_EXPR.  */
     402                 :            : 
     403                 :            : static void
     404                 :    3824600 : gimple_push_condition (void)
     405                 :            : {
     406                 :            : #ifdef ENABLE_GIMPLE_CHECKING
     407                 :    3824600 :   if (gimplify_ctxp->conditions == 0)
     408                 :    2495030 :     gcc_assert (gimple_seq_empty_p (gimplify_ctxp->conditional_cleanups));
     409                 :            : #endif
     410                 :    3824600 :   ++(gimplify_ctxp->conditions);
     411                 :    3824600 : }
     412                 :            : 
     413                 :            : /* Note that we've left a COND_EXPR.  If we're back at unconditional scope
     414                 :            :    now, add any conditional cleanups we've seen to the prequeue.  */
     415                 :            : 
     416                 :            : static void
     417                 :    3824600 : gimple_pop_condition (gimple_seq *pre_p)
     418                 :            : {
     419                 :    3824600 :   int conds = --(gimplify_ctxp->conditions);
     420                 :            : 
     421                 :    3824600 :   gcc_assert (conds >= 0);
     422                 :    3824600 :   if (conds == 0)
     423                 :            :     {
     424                 :    2495030 :       gimplify_seq_add_seq (pre_p, gimplify_ctxp->conditional_cleanups);
     425                 :    2495030 :       gimplify_ctxp->conditional_cleanups = NULL;
     426                 :            :     }
     427                 :    3824600 : }
     428                 :            : 
     429                 :            : /* A stable comparison routine for use with splay trees and DECLs.  */
     430                 :            : 
     431                 :            : static int
     432                 :   13736700 : splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
     433                 :            : {
     434                 :   13736700 :   tree a = (tree) xa;
     435                 :   13736700 :   tree b = (tree) xb;
     436                 :            : 
     437                 :   13736700 :   return DECL_UID (a) - DECL_UID (b);
     438                 :            : }
     439                 :            : 
     440                 :            : /* Create a new omp construct that deals with variable remapping.  */
     441                 :            : 
     442                 :            : static struct gimplify_omp_ctx *
     443                 :      94968 : new_omp_context (enum omp_region_type region_type)
     444                 :            : {
     445                 :      94968 :   struct gimplify_omp_ctx *c;
     446                 :            : 
     447                 :      94968 :   c = XCNEW (struct gimplify_omp_ctx);
     448                 :      94968 :   c->outer_context = gimplify_omp_ctxp;
     449                 :      94968 :   c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
     450                 :      94968 :   c->privatized_types = new hash_set<tree>;
     451                 :      94968 :   c->location = input_location;
     452                 :      94968 :   c->region_type = region_type;
     453                 :      94968 :   if ((region_type & ORT_TASK) == 0)
     454                 :      91604 :     c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
     455                 :            :   else
     456                 :       3364 :     c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
     457                 :      94968 :   c->defaultmap[GDMK_SCALAR] = GOVD_MAP;
     458                 :      94968 :   c->defaultmap[GDMK_AGGREGATE] = GOVD_MAP;
     459                 :      94968 :   c->defaultmap[GDMK_ALLOCATABLE] = GOVD_MAP;
     460                 :      94968 :   c->defaultmap[GDMK_POINTER] = GOVD_MAP;
     461                 :            : 
     462                 :      94968 :   return c;
     463                 :            : }
     464                 :            : 
     465                 :            : /* Destroy an omp construct that deals with variable remapping.  */
     466                 :            : 
     467                 :            : static void
     468                 :      94968 : delete_omp_context (struct gimplify_omp_ctx *c)
     469                 :            : {
     470                 :      94968 :   splay_tree_delete (c->variables);
     471                 :     189936 :   delete c->privatized_types;
     472                 :      94968 :   c->loop_iter_var.release ();
     473                 :      94968 :   XDELETE (c);
     474                 :      94968 : }
     475                 :            : 
     476                 :            : static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
     477                 :            : static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
     478                 :            : 
     479                 :            : /* Both gimplify the statement T and append it to *SEQ_P.  This function
     480                 :            :    behaves exactly as gimplify_stmt, but you don't have to pass T as a
     481                 :            :    reference.  */
     482                 :            : 
     483                 :            : void
     484                 :   25586400 : gimplify_and_add (tree t, gimple_seq *seq_p)
     485                 :            : {
     486                 :   25586400 :   gimplify_stmt (&t, seq_p);
     487                 :   25586400 : }
     488                 :            : 
     489                 :            : /* Gimplify statement T into sequence *SEQ_P, and return the first
     490                 :            :    tuple in the sequence of generated tuples for this statement.
     491                 :            :    Return NULL if gimplifying T produced no tuples.  */
     492                 :            : 
     493                 :            : static gimple *
     494                 :      77147 : gimplify_and_return_first (tree t, gimple_seq *seq_p)
     495                 :            : {
     496                 :      19962 :   gimple_stmt_iterator last = gsi_last (*seq_p);
     497                 :            : 
     498                 :      77147 :   gimplify_and_add (t, seq_p);
     499                 :            : 
     500                 :      77147 :   if (!gsi_end_p (last))
     501                 :            :     {
     502                 :       3305 :       gsi_next (&last);
     503                 :       3305 :       return gsi_stmt (last);
     504                 :            :     }
     505                 :            :   else
     506                 :      73842 :     return gimple_seq_first_stmt (*seq_p);
     507                 :            : }
     508                 :            : 
     509                 :            : /* Returns true iff T is a valid RHS for an assignment to an un-renamed
     510                 :            :    LHS, or for a call argument.  */
     511                 :            : 
     512                 :            : static bool
     513                 :     178462 : is_gimple_mem_rhs (tree t)
     514                 :            : {
     515                 :            :   /* If we're dealing with a renamable type, either source or dest must be
     516                 :            :      a renamed variable.  */
     517                 :     178462 :   if (is_gimple_reg_type (TREE_TYPE (t)))
     518                 :     171530 :     return is_gimple_val (t);
     519                 :            :   else
     520                 :       6932 :     return is_gimple_val (t) || is_gimple_lvalue (t);
     521                 :            : }
     522                 :            : 
     523                 :            : /* Return true if T is a CALL_EXPR or an expression that can be
     524                 :            :    assigned to a temporary.  Note that this predicate should only be
     525                 :            :    used during gimplification.  See the rationale for this in
     526                 :            :    gimplify_modify_expr.  */
     527                 :            : 
     528                 :            : static bool
     529                 :   62904500 : is_gimple_reg_rhs_or_call (tree t)
     530                 :            : {
     531                 :   45965200 :   return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
     532                 :   62904500 :           || TREE_CODE (t) == CALL_EXPR);
     533                 :            : }
     534                 :            : 
     535                 :            : /* Return true if T is a valid memory RHS or a CALL_EXPR.  Note that
     536                 :            :    this predicate should only be used during gimplification.  See the
     537                 :            :    rationale for this in gimplify_modify_expr.  */
     538                 :            : 
     539                 :            : static bool
     540                 :    9713710 : is_gimple_mem_rhs_or_call (tree t)
     541                 :            : {
     542                 :            :   /* If we're dealing with a renamable type, either source or dest must be
     543                 :            :      a renamed variable.  */
     544                 :    9713710 :   if (is_gimple_reg_type (TREE_TYPE (t)))
     545                 :    7301290 :     return is_gimple_val (t);
     546                 :            :   else
     547                 :    2412420 :     return (is_gimple_val (t)
     548                 :    1009480 :             || is_gimple_lvalue (t)
     549                 :     655489 :             || TREE_CLOBBER_P (t)
     550                 :    3067860 :             || TREE_CODE (t) == CALL_EXPR);
     551                 :            : }
     552                 :            : 
     553                 :            : /* Create a temporary with a name derived from VAL.  Subroutine of
     554                 :            :    lookup_tmp_var; nobody else should call this function.  */
     555                 :            : 
     556                 :            : static inline tree
     557                 :    1545600 : create_tmp_from_val (tree val)
     558                 :            : {
     559                 :            :   /* Drop all qualifiers and address-space information from the value type.  */
     560                 :    1545600 :   tree type = TYPE_MAIN_VARIANT (TREE_TYPE (val));
     561                 :    1545600 :   tree var = create_tmp_var (type, get_name (val));
     562                 :    1545600 :   if (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
     563                 :    1545600 :       || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
     564                 :      91886 :     DECL_GIMPLE_REG_P (var) = 1;
     565                 :    1545600 :   return var;
     566                 :            : }
     567                 :            : 
     568                 :            : /* Create a temporary to hold the value of VAL.  If IS_FORMAL, try to reuse
     569                 :            :    an existing expression temporary.  */
     570                 :            : 
     571                 :            : static tree
     572                 :    1665010 : lookup_tmp_var (tree val, bool is_formal)
     573                 :            : {
     574                 :    1665010 :   tree ret;
     575                 :            : 
     576                 :            :   /* If not optimizing, never really reuse a temporary.  local-alloc
     577                 :            :      won't allocate any variable that is used in more than one basic
     578                 :            :      block, which means it will go into memory, causing much extra
     579                 :            :      work in reload and final and poorer code generation, outweighing
     580                 :            :      the extra memory allocation here.  */
     581                 :    2799550 :   if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
     582                 :     709423 :     ret = create_tmp_from_val (val);
     583                 :            :   else
     584                 :            :     {
     585                 :     955588 :       elt_t elt, *elt_p;
     586                 :     955588 :       elt_t **slot;
     587                 :            : 
     588                 :     955588 :       elt.val = val;
     589                 :     955588 :       if (!gimplify_ctxp->temp_htab)
     590                 :     289864 :         gimplify_ctxp->temp_htab = new hash_table<gimplify_hasher> (1000);
     591                 :     955588 :       slot = gimplify_ctxp->temp_htab->find_slot (&elt, INSERT);
     592                 :     955588 :       if (*slot == NULL)
     593                 :            :         {
     594                 :     836179 :           elt_p = XNEW (elt_t);
     595                 :     836179 :           elt_p->val = val;
     596                 :     836179 :           elt_p->temp = ret = create_tmp_from_val (val);
     597                 :     836179 :           *slot = elt_p;
     598                 :            :         }
     599                 :            :       else
     600                 :            :         {
     601                 :     119409 :           elt_p = *slot;
     602                 :     119409 :           ret = elt_p->temp;
     603                 :            :         }
     604                 :            :     }
     605                 :            : 
     606                 :    1665010 :   return ret;
     607                 :            : }
     608                 :            : 
     609                 :            : /* Helper for get_formal_tmp_var and get_initialized_tmp_var.  */
     610                 :            : 
     611                 :            : static tree
     612                 :   17187600 : internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
     613                 :            :                       bool is_formal, bool allow_ssa)
     614                 :            : {
     615                 :   17187600 :   tree t, mod;
     616                 :            : 
     617                 :            :   /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
     618                 :            :      can create an INIT_EXPR and convert it into a GIMPLE_CALL below.  */
     619                 :   17187600 :   gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
     620                 :            :                  fb_rvalue);
     621                 :            : 
     622                 :   17187600 :   if (allow_ssa
     623                 :   17011400 :       && gimplify_ctxp->into_ssa
     624                 :   33205300 :       && is_gimple_reg_type (TREE_TYPE (val)))
     625                 :            :     {
     626                 :   15522600 :       t = make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val)));
     627                 :   15522600 :       if (! gimple_in_ssa_p (cfun))
     628                 :            :         {
     629                 :   13390700 :           const char *name = get_name (val);
     630                 :   13390700 :           if (name)
     631                 :    2166250 :             SET_SSA_NAME_VAR_OR_IDENTIFIER (t, create_tmp_var_name (name));
     632                 :            :         }
     633                 :            :     }
     634                 :            :   else
     635                 :    1665010 :     t = lookup_tmp_var (val, is_formal);
     636                 :            : 
     637                 :   17187600 :   mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
     638                 :            : 
     639                 :   17187600 :   SET_EXPR_LOCATION (mod, EXPR_LOC_OR_LOC (val, input_location));
     640                 :            : 
     641                 :            :   /* gimplify_modify_expr might want to reduce this further.  */
     642                 :   17187600 :   gimplify_and_add (mod, pre_p);
     643                 :   17187600 :   ggc_free (mod);
     644                 :            : 
     645                 :   17187600 :   return t;
     646                 :            : }
     647                 :            : 
     648                 :            : /* Return a formal temporary variable initialized with VAL.  PRE_P is as
     649                 :            :    in gimplify_expr.  Only use this function if:
     650                 :            : 
     651                 :            :    1) The value of the unfactored expression represented by VAL will not
     652                 :            :       change between the initialization and use of the temporary, and
     653                 :            :    2) The temporary will not be otherwise modified.
     654                 :            : 
     655                 :            :    For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
     656                 :            :    and #2 means it is inappropriate for && temps.
     657                 :            : 
     658                 :            :    For other cases, use get_initialized_tmp_var instead.  */
     659                 :            : 
     660                 :            : tree
     661                 :   16971900 : get_formal_tmp_var (tree val, gimple_seq *pre_p)
     662                 :            : {
     663                 :   16971900 :   return internal_get_tmp_var (val, pre_p, NULL, true, true);
     664                 :            : }
     665                 :            : 
     666                 :            : /* Return a temporary variable initialized with VAL.  PRE_P and POST_P
     667                 :            :    are as in gimplify_expr.  */
     668                 :            : 
     669                 :            : tree
     670                 :     215641 : get_initialized_tmp_var (tree val, gimple_seq *pre_p,
     671                 :            :                          gimple_seq *post_p /* = NULL */,
     672                 :            :                          bool allow_ssa /* = true */)
     673                 :            : {
     674                 :     215641 :   return internal_get_tmp_var (val, pre_p, post_p, false, allow_ssa);
     675                 :            : }
     676                 :            : 
     677                 :            : /* Declare all the variables in VARS in SCOPE.  If DEBUG_INFO is true,
     678                 :            :    generate debug info for them; otherwise don't.  */
     679                 :            : 
     680                 :            : void
     681                 :    1956820 : declare_vars (tree vars, gimple *gs, bool debug_info)
     682                 :            : {
     683                 :    1956820 :   tree last = vars;
     684                 :    1956820 :   if (last)
     685                 :            :     {
     686                 :    1266070 :       tree temps, block;
     687                 :            : 
     688                 :    1266070 :       gbind *scope = as_a <gbind *> (gs);
     689                 :            : 
     690                 :    1266070 :       temps = nreverse (last);
     691                 :            : 
     692                 :    1266070 :       block = gimple_bind_block (scope);
     693                 :    1266070 :       gcc_assert (!block || TREE_CODE (block) == BLOCK);
     694                 :    1266070 :       if (!block || !debug_info)
     695                 :            :         {
     696                 :    1263290 :           DECL_CHAIN (last) = gimple_bind_vars (scope);
     697                 :    1263290 :           gimple_bind_set_vars (scope, temps);
     698                 :            :         }
     699                 :            :       else
     700                 :            :         {
     701                 :            :           /* We need to attach the nodes both to the BIND_EXPR and to its
     702                 :            :              associated BLOCK for debugging purposes.  The key point here
     703                 :            :              is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
     704                 :            :              is a subchain of the BIND_EXPR_VARS of the BIND_EXPR.  */
     705                 :       2786 :           if (BLOCK_VARS (block))
     706                 :       2609 :             BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
     707                 :            :           else
     708                 :            :             {
     709                 :        177 :               gimple_bind_set_vars (scope,
     710                 :            :                                     chainon (gimple_bind_vars (scope), temps));
     711                 :        177 :               BLOCK_VARS (block) = temps;
     712                 :            :             }
     713                 :            :         }
     714                 :            :     }
     715                 :    1956820 : }
     716                 :            : 
     717                 :            : /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
     718                 :            :    for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly.  Abort if
     719                 :            :    no such upper bound can be obtained.  */
     720                 :            : 
     721                 :            : static void
     722                 :          0 : force_constant_size (tree var)
     723                 :            : {
     724                 :            :   /* The only attempt we make is by querying the maximum size of objects
     725                 :            :      of the variable's type.  */
     726                 :            : 
     727                 :          0 :   HOST_WIDE_INT max_size;
     728                 :            : 
     729                 :          0 :   gcc_assert (VAR_P (var));
     730                 :            : 
     731                 :          0 :   max_size = max_int_size_in_bytes (TREE_TYPE (var));
     732                 :            : 
     733                 :          0 :   gcc_assert (max_size >= 0);
     734                 :            : 
     735                 :          0 :   DECL_SIZE_UNIT (var)
     736                 :          0 :     = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
     737                 :          0 :   DECL_SIZE (var)
     738                 :          0 :     = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
     739                 :          0 : }
     740                 :            : 
     741                 :            : /* Push the temporary variable TMP into the current binding.  */
     742                 :            : 
     743                 :            : void
     744                 :       4972 : gimple_add_tmp_var_fn (struct function *fn, tree tmp)
     745                 :            : {
     746                 :       9944 :   gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
     747                 :            : 
     748                 :            :   /* Later processing assumes that the object size is constant, which might
     749                 :            :      not be true at this point.  Force the use of a constant upper bound in
     750                 :            :      this case.  */
     751                 :       4972 :   if (!tree_fits_poly_uint64_p (DECL_SIZE_UNIT (tmp)))
     752                 :          0 :     force_constant_size (tmp);
     753                 :            : 
     754                 :       4972 :   DECL_CONTEXT (tmp) = fn->decl;
     755                 :       4972 :   DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
     756                 :            : 
     757                 :       4972 :   record_vars_into (tmp, fn->decl);
     758                 :       4972 : }
     759                 :            : 
     760                 :            : /* Push the temporary variable TMP into the current binding.  */
     761                 :            : 
     762                 :            : void
     763                 :   11629700 : gimple_add_tmp_var (tree tmp)
     764                 :            : {
     765                 :   23259500 :   gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
     766                 :            : 
     767                 :            :   /* Later processing assumes that the object size is constant, which might
     768                 :            :      not be true at this point.  Force the use of a constant upper bound in
     769                 :            :      this case.  */
     770                 :   11629700 :   if (!tree_fits_poly_uint64_p (DECL_SIZE_UNIT (tmp)))
     771                 :          0 :     force_constant_size (tmp);
     772                 :            : 
     773                 :   11629700 :   DECL_CONTEXT (tmp) = current_function_decl;
     774                 :   11629700 :   DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
     775                 :            : 
     776                 :   11629700 :   if (gimplify_ctxp)
     777                 :            :     {
     778                 :    3867810 :       DECL_CHAIN (tmp) = gimplify_ctxp->temps;
     779                 :    3867810 :       gimplify_ctxp->temps = tmp;
     780                 :            : 
     781                 :            :       /* Mark temporaries local within the nearest enclosing parallel.  */
     782                 :    3867810 :       if (gimplify_omp_ctxp)
     783                 :            :         {
     784                 :            :           struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
     785                 :     385196 :           int flag = GOVD_LOCAL;
     786                 :     385196 :           while (ctx
     787                 :     385196 :                  && (ctx->region_type == ORT_WORKSHARE
     788                 :            :                      || ctx->region_type == ORT_TASKGROUP
     789                 :     376827 :                      || ctx->region_type == ORT_SIMD
     790                 :     258290 :                      || ctx->region_type == ORT_ACC))
     791                 :            :             {
     792                 :     149183 :               if (ctx->region_type == ORT_SIMD
     793                 :            :                   && TREE_ADDRESSABLE (tmp)
     794                 :      26988 :                   && !TREE_STATIC (tmp))
     795                 :            :                 {
     796                 :         84 :                   if (TREE_CODE (DECL_SIZE_UNIT (tmp)) != INTEGER_CST)
     797                 :          0 :                     ctx->add_safelen1 = true;
     798                 :            :                   else
     799                 :            :                     flag = GOVD_PRIVATE;
     800                 :            :                   break;
     801                 :            :                 }
     802                 :     149099 :               ctx = ctx->outer_context;
     803                 :            :             }
     804                 :     236097 :           if (ctx)
     805                 :     227728 :             omp_add_variable (ctx, tmp, flag | GOVD_SEEN);
     806                 :            :         }
     807                 :            :     }
     808                 :    7761920 :   else if (cfun)
     809                 :    7761920 :     record_vars (tmp);
     810                 :            :   else
     811                 :            :     {
     812                 :          0 :       gimple_seq body_seq;
     813                 :            : 
     814                 :            :       /* This case is for nested functions.  We need to expose the locals
     815                 :            :          they create.  */
     816                 :          0 :       body_seq = gimple_body (current_function_decl);
     817                 :          0 :       declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
     818                 :            :     }
     819                 :   11629700 : }
     820                 :            : 
     821                 :            : 
     822                 :            : 
     823                 :            : /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
     824                 :            :    nodes that are referenced more than once in GENERIC functions.  This is
     825                 :            :    necessary because gimplification (translation into GIMPLE) is performed
     826                 :            :    by modifying tree nodes in-place, so gimplication of a shared node in a
     827                 :            :    first context could generate an invalid GIMPLE form in a second context.
     828                 :            : 
     829                 :            :    This is achieved with a simple mark/copy/unmark algorithm that walks the
     830                 :            :    GENERIC representation top-down, marks nodes with TREE_VISITED the first
     831                 :            :    time it encounters them, duplicates them if they already have TREE_VISITED
     832                 :            :    set, and finally removes the TREE_VISITED marks it has set.
     833                 :            : 
     834                 :            :    The algorithm works only at the function level, i.e. it generates a GENERIC
     835                 :            :    representation of a function with no nodes shared within the function when
     836                 :            :    passed a GENERIC function (except for nodes that are allowed to be shared).
     837                 :            : 
     838                 :            :    At the global level, it is also necessary to unshare tree nodes that are
     839                 :            :    referenced in more than one function, for the same aforementioned reason.
     840                 :            :    This requires some cooperation from the front-end.  There are 2 strategies:
     841                 :            : 
     842                 :            :      1. Manual unsharing.  The front-end needs to call unshare_expr on every
     843                 :            :         expression that might end up being shared across functions.
     844                 :            : 
     845                 :            :      2. Deep unsharing.  This is an extension of regular unsharing.  Instead
     846                 :            :         of calling unshare_expr on expressions that might be shared across
     847                 :            :         functions, the front-end pre-marks them with TREE_VISITED.  This will
     848                 :            :         ensure that they are unshared on the first reference within functions
     849                 :            :         when the regular unsharing algorithm runs.  The counterpart is that
     850                 :            :         this algorithm must look deeper than for manual unsharing, which is
     851                 :            :         specified by LANG_HOOKS_DEEP_UNSHARING.
     852                 :            : 
     853                 :            :   If there are only few specific cases of node sharing across functions, it is
     854                 :            :   probably easier for a front-end to unshare the expressions manually.  On the
     855                 :            :   contrary, if the expressions generated at the global level are as widespread
     856                 :            :   as expressions generated within functions, deep unsharing is very likely the
     857                 :            :   way to go.  */
     858                 :            : 
     859                 :            : /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
     860                 :            :    These nodes model computations that must be done once.  If we were to
     861                 :            :    unshare something like SAVE_EXPR(i++), the gimplification process would
     862                 :            :    create wrong code.  However, if DATA is non-null, it must hold a pointer
     863                 :            :    set that is used to unshare the subtrees of these nodes.  */
     864                 :            : 
     865                 :            : static tree
     866                 :  384088000 : mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
     867                 :            : {
     868                 :  384088000 :   tree t = *tp;
     869                 :  384088000 :   enum tree_code code = TREE_CODE (t);
     870                 :            : 
     871                 :            :   /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
     872                 :            :      copy their subtrees if we can make sure to do it only once.  */
     873                 :  384088000 :   if (code == SAVE_EXPR || code == TARGET_EXPR || code == BIND_EXPR)
     874                 :            :     {
     875                 :     378128 :       if (data && !((hash_set<tree> *)data)->add (t))
     876                 :            :         ;
     877                 :            :       else
     878                 :     378128 :         *walk_subtrees = 0;
     879                 :            :     }
     880                 :            : 
     881                 :            :   /* Stop at types, decls, constants like copy_tree_r.  */
     882                 :  383710000 :   else if (TREE_CODE_CLASS (code) == tcc_type
     883                 :            :            || TREE_CODE_CLASS (code) == tcc_declaration
     884                 :  383710000 :            || TREE_CODE_CLASS (code) == tcc_constant)
     885                 :  219139000 :     *walk_subtrees = 0;
     886                 :            : 
     887                 :            :   /* Cope with the statement expression extension.  */
     888                 :  164571000 :   else if (code == STATEMENT_LIST)
     889                 :            :     ;
     890                 :            : 
     891                 :            :   /* Leave the bulk of the work to copy_tree_r itself.  */
     892                 :            :   else
     893                 :  164529000 :     copy_tree_r (tp, walk_subtrees, NULL);
     894                 :            : 
     895                 :  384088000 :   return NULL_TREE;
     896                 :            : }
     897                 :            : 
     898                 :            : /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
     899                 :            :    If *TP has been visited already, then *TP is deeply copied by calling
     900                 :            :    mostly_copy_tree_r.  DATA is passed to mostly_copy_tree_r unmodified.  */
     901                 :            : 
     902                 :            : static tree
     903                 :  169880000 : copy_if_shared_r (tree *tp, int *walk_subtrees, void *data)
     904                 :            : {
     905                 :  169880000 :   tree t = *tp;
     906                 :  169880000 :   enum tree_code code = TREE_CODE (t);
     907                 :            : 
     908                 :            :   /* Skip types, decls, and constants.  But we do want to look at their
     909                 :            :      types and the bounds of types.  Mark them as visited so we properly
     910                 :            :      unmark their subtrees on the unmark pass.  If we've already seen them,
     911                 :            :      don't look down further.  */
     912                 :  169880000 :   if (TREE_CODE_CLASS (code) == tcc_type
     913                 :            :       || TREE_CODE_CLASS (code) == tcc_declaration
     914                 :  169880000 :       || TREE_CODE_CLASS (code) == tcc_constant)
     915                 :            :     {
     916                 :   78931000 :       if (TREE_VISITED (t))
     917                 :   46748900 :         *walk_subtrees = 0;
     918                 :            :       else
     919                 :   32182000 :         TREE_VISITED (t) = 1;
     920                 :            :     }
     921                 :            : 
     922                 :            :   /* If this node has been visited already, unshare it and don't look
     923                 :            :      any deeper.  */
     924                 :   90949400 :   else if (TREE_VISITED (t))
     925                 :            :     {
     926                 :    1231280 :       walk_tree (tp, mostly_copy_tree_r, data, NULL);
     927                 :    1231280 :       *walk_subtrees = 0;
     928                 :            :     }
     929                 :            : 
     930                 :            :   /* Otherwise, mark the node as visited and keep looking.  */
     931                 :            :   else
     932                 :   89718100 :     TREE_VISITED (t) = 1;
     933                 :            : 
     934                 :  169880000 :   return NULL_TREE;
     935                 :            : }
     936                 :            : 
     937                 :            : /* Unshare most of the shared trees rooted at *TP.  DATA is passed to the
     938                 :            :    copy_if_shared_r callback unmodified.  */
     939                 :            : 
     940                 :            : void
     941                 :    5632520 : copy_if_shared (tree *tp, void *data)
     942                 :            : {
     943                 :    5632520 :   walk_tree (tp, copy_if_shared_r, data, NULL);
     944                 :    5632520 : }
     945                 :            : 
     946                 :            : /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
     947                 :            :    any nested functions.  */
     948                 :            : 
     949                 :            : static void
     950                 :    1877350 : unshare_body (tree fndecl)
     951                 :            : {
     952                 :    1877350 :   struct cgraph_node *cgn = cgraph_node::get (fndecl);
     953                 :            :   /* If the language requires deep unsharing, we need a pointer set to make
     954                 :            :      sure we don't repeatedly unshare subtrees of unshareable nodes.  */
     955                 :    1877350 :   hash_set<tree> *visited
     956                 :    1877350 :     = lang_hooks.deep_unsharing ? new hash_set<tree> : NULL;
     957                 :            : 
     958                 :    1877350 :   copy_if_shared (&DECL_SAVED_TREE (fndecl), visited);
     959                 :    1877350 :   copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl)), visited);
     960                 :    1877350 :   copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)), visited);
     961                 :            : 
     962                 :    1877350 :   delete visited;
     963                 :            : 
     964                 :    1877350 :   if (cgn)
     965                 :    1888690 :     for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
     966                 :      13807 :       unshare_body (cgn->decl);
     967                 :    1877350 : }
     968                 :            : 
     969                 :            : /* Callback for walk_tree to unmark the visited trees rooted at *TP.
     970                 :            :    Subtrees are walked until the first unvisited node is encountered.  */
     971                 :            : 
     972                 :            : static tree
     973                 :  169845000 : unmark_visited_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
     974                 :            : {
     975                 :  169845000 :   tree t = *tp;
     976                 :            : 
     977                 :            :   /* If this node has been visited, unmark it and keep looking.  */
     978                 :  169845000 :   if (TREE_VISITED (t))
     979                 :  121874000 :     TREE_VISITED (t) = 0;
     980                 :            : 
     981                 :            :   /* Otherwise, don't look any deeper.  */
     982                 :            :   else
     983                 :   47971700 :     *walk_subtrees = 0;
     984                 :            : 
     985                 :  169845000 :   return NULL_TREE;
     986                 :            : }
     987                 :            : 
     988                 :            : /* Unmark the visited trees rooted at *TP.  */
     989                 :            : 
     990                 :            : static inline void
     991                 :    5632050 : unmark_visited (tree *tp)
     992                 :            : {
     993                 :    5632050 :   walk_tree (tp, unmark_visited_r, NULL, NULL);
     994                 :            : }
     995                 :            : 
     996                 :            : /* Likewise, but mark all trees as not visited.  */
     997                 :            : 
     998                 :            : static void
     999                 :    1877350 : unvisit_body (tree fndecl)
    1000                 :            : {
    1001                 :    1877350 :   struct cgraph_node *cgn = cgraph_node::get (fndecl);
    1002                 :            : 
    1003                 :    1877350 :   unmark_visited (&DECL_SAVED_TREE (fndecl));
    1004                 :    1877350 :   unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl)));
    1005                 :    1877350 :   unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)));
    1006                 :            : 
    1007                 :    1877350 :   if (cgn)
    1008                 :    1888690 :     for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
    1009                 :      13807 :       unvisit_body (cgn->decl);
    1010                 :    1877350 : }
    1011                 :            : 
    1012                 :            : /* Unconditionally make an unshared copy of EXPR.  This is used when using
    1013                 :            :    stored expressions which span multiple functions, such as BINFO_VTABLE,
    1014                 :            :    as the normal unsharing process can't tell that they're shared.  */
    1015                 :            : 
    1016                 :            : tree
    1017                 :  248394000 : unshare_expr (tree expr)
    1018                 :            : {
    1019                 :  248394000 :   walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
    1020                 :  248394000 :   return expr;
    1021                 :            : }
    1022                 :            : 
    1023                 :            : /* Worker for unshare_expr_without_location.  */
    1024                 :            : 
    1025                 :            : static tree
    1026                 :    3154740 : prune_expr_location (tree *tp, int *walk_subtrees, void *)
    1027                 :            : {
    1028                 :    3154740 :   if (EXPR_P (*tp))
    1029                 :    1293660 :     SET_EXPR_LOCATION (*tp, UNKNOWN_LOCATION);
    1030                 :            :   else
    1031                 :    1861080 :     *walk_subtrees = 0;
    1032                 :    3154740 :   return NULL_TREE;
    1033                 :            : }
    1034                 :            : 
    1035                 :            : /* Similar to unshare_expr but also prune all expression locations
    1036                 :            :    from EXPR.  */
    1037                 :            : 
    1038                 :            : tree
    1039                 :    9600910 : unshare_expr_without_location (tree expr)
    1040                 :            : {
    1041                 :    9600910 :   walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
    1042                 :    9600910 :   if (EXPR_P (expr))
    1043                 :    1005900 :     walk_tree (&expr, prune_expr_location, NULL, NULL);
    1044                 :    9600910 :   return expr;
    1045                 :            : }
    1046                 :            : 
    1047                 :            : /* Return the EXPR_LOCATION of EXPR, if it (maybe recursively) has
    1048                 :            :    one, OR_ELSE otherwise.  The location of a STATEMENT_LISTs
    1049                 :            :    comprising at least one DEBUG_BEGIN_STMT followed by exactly one
    1050                 :            :    EXPR is the location of the EXPR.  */
    1051                 :            : 
    1052                 :            : static location_t
    1053                 :     786172 : rexpr_location (tree expr, location_t or_else = UNKNOWN_LOCATION)
    1054                 :            : {
    1055                 :     786172 :   if (!expr)
    1056                 :            :     return or_else;
    1057                 :            : 
    1058                 :     786172 :   if (EXPR_HAS_LOCATION (expr))
    1059                 :     557655 :     return EXPR_LOCATION (expr);
    1060                 :            : 
    1061                 :     228517 :   if (TREE_CODE (expr) != STATEMENT_LIST)
    1062                 :            :     return or_else;
    1063                 :            : 
    1064                 :          0 :   tree_stmt_iterator i = tsi_start (expr);
    1065                 :            : 
    1066                 :          0 :   bool found = false;
    1067                 :          0 :   while (!tsi_end_p (i) && TREE_CODE (tsi_stmt (i)) == DEBUG_BEGIN_STMT)
    1068                 :            :     {
    1069                 :          0 :       found = true;
    1070                 :          0 :       tsi_next (&i);
    1071                 :            :     }
    1072                 :            : 
    1073                 :          0 :   if (!found || !tsi_one_before_end_p (i))
    1074                 :            :     return or_else;
    1075                 :            : 
    1076                 :          0 :   return rexpr_location (tsi_stmt (i), or_else);
    1077                 :            : }
    1078                 :            : 
    1079                 :            : /* Return TRUE iff EXPR (maybe recursively) has a location; see
    1080                 :            :    rexpr_location for the potential recursion.  */
    1081                 :            : 
    1082                 :            : static inline bool
    1083                 :     315975 : rexpr_has_location (tree expr)
    1084                 :            : {
    1085                 :     186133 :   return rexpr_location (expr) != UNKNOWN_LOCATION;
    1086                 :            : }
    1087                 :            : 
    1088                 :            : 
    1089                 :            : /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
    1090                 :            :    contain statements and have a value.  Assign its value to a temporary
    1091                 :            :    and give it void_type_node.  Return the temporary, or NULL_TREE if
    1092                 :            :    WRAPPER was already void.  */
    1093                 :            : 
    1094                 :            : tree
    1095                 :   13517200 : voidify_wrapper_expr (tree wrapper, tree temp)
    1096                 :            : {
    1097                 :   13517200 :   tree type = TREE_TYPE (wrapper);
    1098                 :   13517200 :   if (type && !VOID_TYPE_P (type))
    1099                 :            :     {
    1100                 :            :       tree *p;
    1101                 :            : 
    1102                 :            :       /* Set p to point to the body of the wrapper.  Loop until we find
    1103                 :            :          something that isn't a wrapper.  */
    1104                 :     527494 :       for (p = &wrapper; p && *p; )
    1105                 :            :         {
    1106                 :     527494 :           switch (TREE_CODE (*p))
    1107                 :            :             {
    1108                 :       3471 :             case BIND_EXPR:
    1109                 :       3471 :               TREE_SIDE_EFFECTS (*p) = 1;
    1110                 :       3471 :               TREE_TYPE (*p) = void_type_node;
    1111                 :            :               /* For a BIND_EXPR, the body is operand 1.  */
    1112                 :       3471 :               p = &BIND_EXPR_BODY (*p);
    1113                 :       3471 :               break;
    1114                 :            : 
    1115                 :     241973 :             case CLEANUP_POINT_EXPR:
    1116                 :     241973 :             case TRY_FINALLY_EXPR:
    1117                 :     241973 :             case TRY_CATCH_EXPR:
    1118                 :     241973 :               TREE_SIDE_EFFECTS (*p) = 1;
    1119                 :     241973 :               TREE_TYPE (*p) = void_type_node;
    1120                 :     241973 :               p = &TREE_OPERAND (*p, 0);
    1121                 :     241973 :               break;
    1122                 :            : 
    1123                 :      11916 :             case STATEMENT_LIST:
    1124                 :      11916 :               {
    1125                 :      11916 :                 tree_stmt_iterator i = tsi_last (*p);
    1126                 :      11916 :                 TREE_SIDE_EFFECTS (*p) = 1;
    1127                 :      11916 :                 TREE_TYPE (*p) = void_type_node;
    1128                 :      11916 :                 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
    1129                 :            :               }
    1130                 :      11916 :               break;
    1131                 :            : 
    1132                 :      44016 :             case COMPOUND_EXPR:
    1133                 :            :               /* Advance to the last statement.  Set all container types to
    1134                 :            :                  void.  */
    1135                 :      44016 :               for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
    1136                 :            :                 {
    1137                 :      22008 :                   TREE_SIDE_EFFECTS (*p) = 1;
    1138                 :      22008 :                   TREE_TYPE (*p) = void_type_node;
    1139                 :            :                 }
    1140                 :            :               break;
    1141                 :            : 
    1142                 :         80 :             case TRANSACTION_EXPR:
    1143                 :         80 :               TREE_SIDE_EFFECTS (*p) = 1;
    1144                 :         80 :               TREE_TYPE (*p) = void_type_node;
    1145                 :         80 :               p = &TRANSACTION_EXPR_BODY (*p);
    1146                 :         80 :               break;
    1147                 :            : 
    1148                 :     248046 :             default:
    1149                 :            :               /* Assume that any tree upon which voidify_wrapper_expr is
    1150                 :            :                  directly called is a wrapper, and that its body is op0.  */
    1151                 :     248046 :               if (p == &wrapper)
    1152                 :            :                 {
    1153                 :         33 :                   TREE_SIDE_EFFECTS (*p) = 1;
    1154                 :         33 :                   TREE_TYPE (*p) = void_type_node;
    1155                 :         33 :                   p = &TREE_OPERAND (*p, 0);
    1156                 :         33 :                   break;
    1157                 :            :                 }
    1158                 :     248013 :               goto out;
    1159                 :            :             }
    1160                 :            :         }
    1161                 :            : 
    1162                 :          0 :     out:
    1163                 :     248013 :       if (p == NULL || IS_EMPTY_STMT (*p))
    1164                 :            :         temp = NULL_TREE;
    1165                 :     248013 :       else if (temp)
    1166                 :            :         {
    1167                 :            :           /* The wrapper is on the RHS of an assignment that we're pushing
    1168                 :            :              down.  */
    1169                 :        619 :           gcc_assert (TREE_CODE (temp) == INIT_EXPR
    1170                 :            :                       || TREE_CODE (temp) == MODIFY_EXPR);
    1171                 :        619 :           TREE_OPERAND (temp, 1) = *p;
    1172                 :        619 :           *p = temp;
    1173                 :            :         }
    1174                 :            :       else
    1175                 :            :         {
    1176                 :     247394 :           temp = create_tmp_var (type, "retval");
    1177                 :     247394 :           *p = build2 (INIT_EXPR, type, temp, *p);
    1178                 :            :         }
    1179                 :            : 
    1180                 :     248013 :       return temp;
    1181                 :            :     }
    1182                 :            : 
    1183                 :            :   return NULL_TREE;
    1184                 :            : }
    1185                 :            : 
    1186                 :            : /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
    1187                 :            :    a temporary through which they communicate.  */
    1188                 :            : 
    1189                 :            : static void
    1190                 :       7287 : build_stack_save_restore (gcall **save, gcall **restore)
    1191                 :            : {
    1192                 :       7287 :   tree tmp_var;
    1193                 :            : 
    1194                 :      14574 :   *save = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE), 0);
    1195                 :       7287 :   tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
    1196                 :       7287 :   gimple_call_set_lhs (*save, tmp_var);
    1197                 :            : 
    1198                 :       7287 :   *restore
    1199                 :       7287 :     = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE),
    1200                 :            :                          1, tmp_var);
    1201                 :       7287 : }
    1202                 :            : 
    1203                 :            : /* Generate IFN_ASAN_MARK call that poisons shadow of a for DECL variable.  */
    1204                 :            : 
    1205                 :            : static tree
    1206                 :        420 : build_asan_poison_call_expr (tree decl)
    1207                 :            : {
    1208                 :            :   /* Do not poison variables that have size equal to zero.  */
    1209                 :        420 :   tree unit_size = DECL_SIZE_UNIT (decl);
    1210                 :        420 :   if (zerop (unit_size))
    1211                 :            :     return NULL_TREE;
    1212                 :            : 
    1213                 :        420 :   tree base = build_fold_addr_expr (decl);
    1214                 :            : 
    1215                 :        420 :   return build_call_expr_internal_loc (UNKNOWN_LOCATION, IFN_ASAN_MARK,
    1216                 :            :                                        void_type_node, 3,
    1217                 :            :                                        build_int_cst (integer_type_node,
    1218                 :        420 :                                                       ASAN_MARK_POISON),
    1219                 :            :                                        base, unit_size);
    1220                 :            : }
    1221                 :            : 
    1222                 :            : /* Generate IFN_ASAN_MARK call that would poison or unpoison, depending
    1223                 :            :    on POISON flag, shadow memory of a DECL variable.  The call will be
    1224                 :            :    put on location identified by IT iterator, where BEFORE flag drives
    1225                 :            :    position where the stmt will be put.  */
    1226                 :            : 
    1227                 :            : static void
    1228                 :       3203 : asan_poison_variable (tree decl, bool poison, gimple_stmt_iterator *it,
    1229                 :            :                       bool before)
    1230                 :            : {
    1231                 :       3203 :   tree unit_size = DECL_SIZE_UNIT (decl);
    1232                 :       3203 :   tree base = build_fold_addr_expr (decl);
    1233                 :            : 
    1234                 :            :   /* Do not poison variables that have size equal to zero.  */
    1235                 :       3203 :   if (zerop (unit_size))
    1236                 :       3203 :     return;
    1237                 :            : 
    1238                 :            :   /* It's necessary to have all stack variables aligned to ASAN granularity
    1239                 :            :      bytes.  */
    1240                 :       3189 :   if (DECL_ALIGN_UNIT (decl) <= ASAN_SHADOW_GRANULARITY)
    1241                 :       3071 :     SET_DECL_ALIGN (decl, BITS_PER_UNIT * ASAN_SHADOW_GRANULARITY);
    1242                 :            : 
    1243                 :       3189 :   HOST_WIDE_INT flags = poison ? ASAN_MARK_POISON : ASAN_MARK_UNPOISON;
    1244                 :            : 
    1245                 :       3189 :   gimple *g
    1246                 :       3189 :     = gimple_build_call_internal (IFN_ASAN_MARK, 3,
    1247                 :            :                                   build_int_cst (integer_type_node, flags),
    1248                 :            :                                   base, unit_size);
    1249                 :            : 
    1250                 :       3189 :   if (before)
    1251                 :       1618 :     gsi_insert_before (it, g, GSI_NEW_STMT);
    1252                 :            :   else
    1253                 :       1571 :     gsi_insert_after (it, g, GSI_NEW_STMT);
    1254                 :            : }
    1255                 :            : 
    1256                 :            : /* Generate IFN_ASAN_MARK internal call that depending on POISON flag
    1257                 :            :    either poisons or unpoisons a DECL.  Created statement is appended
    1258                 :            :    to SEQ_P gimple sequence.  */
    1259                 :            : 
    1260                 :            : static void
    1261                 :       2783 : asan_poison_variable (tree decl, bool poison, gimple_seq *seq_p)
    1262                 :            : {
    1263                 :       2783 :   gimple_stmt_iterator it = gsi_last (*seq_p);
    1264                 :       2783 :   bool before = false;
    1265                 :            : 
    1266                 :       2783 :   if (gsi_end_p (it))
    1267                 :       1480 :     before = true;
    1268                 :            : 
    1269                 :       2783 :   asan_poison_variable (decl, poison, &it, before);
    1270                 :       2783 : }
    1271                 :            : 
    1272                 :            : /* Sort pair of VAR_DECLs A and B by DECL_UID.  */
    1273                 :            : 
    1274                 :            : static int
    1275                 :        135 : sort_by_decl_uid (const void *a, const void *b)
    1276                 :            : {
    1277                 :        135 :   const tree *t1 = (const tree *)a;
    1278                 :        135 :   const tree *t2 = (const tree *)b;
    1279                 :            : 
    1280                 :        135 :   int uid1 = DECL_UID (*t1);
    1281                 :        135 :   int uid2 = DECL_UID (*t2);
    1282                 :            : 
    1283                 :        135 :   if (uid1 < uid2)
    1284                 :            :     return -1;
    1285                 :         60 :   else if (uid1 > uid2)
    1286                 :            :     return 1;
    1287                 :            :   else
    1288                 :          0 :     return 0;
    1289                 :            : }
    1290                 :            : 
    1291                 :            : /* Generate IFN_ASAN_MARK internal call for all VARIABLES
    1292                 :            :    depending on POISON flag.  Created statement is appended
    1293                 :            :    to SEQ_P gimple sequence.  */
    1294                 :            : 
    1295                 :            : static void
    1296                 :     900111 : asan_poison_variables (hash_set<tree> *variables, bool poison, gimple_seq *seq_p)
    1297                 :            : {
    1298                 :     900111 :   unsigned c = variables->elements ();
    1299                 :     900111 :   if (c == 0)
    1300                 :     900047 :     return;
    1301                 :            : 
    1302                 :        128 :   auto_vec<tree> sorted_variables (c);
    1303                 :            : 
    1304                 :        213 :   for (hash_set<tree>::iterator it = variables->begin ();
    1305                 :        149 :        it != variables->end (); ++it)
    1306                 :         85 :     sorted_variables.safe_push (*it);
    1307                 :            : 
    1308                 :         64 :   sorted_variables.qsort (sort_by_decl_uid);
    1309                 :            : 
    1310                 :            :   unsigned i;
    1311                 :            :   tree var;
    1312                 :        213 :   FOR_EACH_VEC_ELT (sorted_variables, i, var)
    1313                 :            :     {
    1314                 :         85 :       asan_poison_variable (var, poison, seq_p);
    1315                 :            : 
    1316                 :            :       /* Add use_after_scope_memory attribute for the variable in order
    1317                 :            :          to prevent re-written into SSA.  */
    1318                 :         85 :       if (!lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE,
    1319                 :         85 :                              DECL_ATTRIBUTES (var)))
    1320                 :         69 :         DECL_ATTRIBUTES (var)
    1321                 :         69 :           = tree_cons (get_identifier (ASAN_USE_AFTER_SCOPE_ATTRIBUTE),
    1322                 :            :                        integer_one_node,
    1323                 :         69 :                        DECL_ATTRIBUTES (var));
    1324                 :            :     }
    1325                 :            : }
    1326                 :            : 
    1327                 :            : /* Gimplify a BIND_EXPR.  Just voidify and recurse.  */
    1328                 :            : 
    1329                 :            : static enum gimplify_status
    1330                 :    4014900 : gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
    1331                 :            : {
    1332                 :    4014900 :   tree bind_expr = *expr_p;
    1333                 :    4014900 :   bool old_keep_stack = gimplify_ctxp->keep_stack;
    1334                 :    4014900 :   bool old_save_stack = gimplify_ctxp->save_stack;
    1335                 :    4014900 :   tree t;
    1336                 :    4014900 :   gbind *bind_stmt;
    1337                 :    4014900 :   gimple_seq body, cleanup;
    1338                 :    4014900 :   gcall *stack_save;
    1339                 :    4014900 :   location_t start_locus = 0, end_locus = 0;
    1340                 :    4014900 :   tree ret_clauses = NULL;
    1341                 :            : 
    1342                 :    4014900 :   tree temp = voidify_wrapper_expr (bind_expr, NULL);
    1343                 :            : 
    1344                 :            :   /* Mark variables seen in this bind expr.  */
    1345                 :    7883430 :   for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
    1346                 :            :     {
    1347                 :    3868520 :       if (VAR_P (t))
    1348                 :            :         {
    1349                 :    3565910 :           struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
    1350                 :            : 
    1351                 :            :           /* Mark variable as local.  */
    1352                 :    3565910 :           if (ctx && ctx->region_type != ORT_NONE && !DECL_EXTERNAL (t))
    1353                 :            :             {
    1354                 :      72923 :               if (! DECL_SEEN_IN_BIND_EXPR_P (t)
    1355                 :      72923 :                   || splay_tree_lookup (ctx->variables,
    1356                 :            :                                         (splay_tree_key) t) == NULL)
    1357                 :            :                 {
    1358                 :      72923 :                   int flag = GOVD_LOCAL;
    1359                 :      72923 :                   if (ctx->region_type == ORT_SIMD
    1360                 :            :                       && TREE_ADDRESSABLE (t)
    1361                 :       4459 :                       && !TREE_STATIC (t))
    1362                 :            :                     {
    1363                 :         62 :                       if (TREE_CODE (DECL_SIZE_UNIT (t)) != INTEGER_CST)
    1364                 :          2 :                         ctx->add_safelen1 = true;
    1365                 :            :                       else
    1366                 :            :                         flag = GOVD_PRIVATE;
    1367                 :            :                     }
    1368                 :      72923 :                   omp_add_variable (ctx, t, flag | GOVD_SEEN);
    1369                 :            :                 }
    1370                 :            :               /* Static locals inside of target construct or offloaded
    1371                 :            :                  routines need to be "omp declare target".  */
    1372                 :      72923 :               if (TREE_STATIC (t))
    1373                 :        213 :                 for (; ctx; ctx = ctx->outer_context)
    1374                 :        138 :                   if ((ctx->region_type & ORT_TARGET) != 0)
    1375                 :            :                     {
    1376                 :         38 :                       if (!lookup_attribute ("omp declare target",
    1377                 :         38 :                                              DECL_ATTRIBUTES (t)))
    1378                 :            :                         {
    1379                 :         25 :                           tree id = get_identifier ("omp declare target");
    1380                 :         50 :                           DECL_ATTRIBUTES (t)
    1381                 :         25 :                             = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t));
    1382                 :         25 :                           varpool_node *node = varpool_node::get (t);
    1383                 :         25 :                           if (node)
    1384                 :            :                             {
    1385                 :          4 :                               node->offloadable = 1;
    1386                 :          4 :                               if (ENABLE_OFFLOADING && !DECL_EXTERNAL (t))
    1387                 :            :                                 {
    1388                 :            :                                   g->have_offload = true;
    1389                 :            :                                   if (!in_lto_p)
    1390                 :            :                                     vec_safe_push (offload_vars, t);
    1391                 :            :                                 }
    1392                 :            :                             }
    1393                 :            :                         }
    1394                 :            :                       break;
    1395                 :            :                     }
    1396                 :            :             }
    1397                 :            : 
    1398                 :    3565910 :           DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
    1399                 :            : 
    1400                 :    3565910 :           if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
    1401                 :        630 :             cfun->has_local_explicit_reg_vars = true;
    1402                 :            :         }
    1403                 :            : 
    1404                 :            :       /* Preliminarily mark non-addressed complex variables as eligible
    1405                 :            :          for promotion to gimple registers.  We'll transform their uses
    1406                 :            :          as we find them.  */
    1407                 :    3868520 :       if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
    1408                 :    3827820 :            || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
    1409                 :      79412 :           && !TREE_THIS_VOLATILE (t)
    1410                 :      63631 :           && (VAR_P (t) && !DECL_HARD_REGISTER (t))
    1411                 :    3930160 :           && !needs_to_live_in_memory (t))
    1412                 :      53520 :         DECL_GIMPLE_REG_P (t) = 1;
    1413                 :            :     }
    1414                 :            : 
    1415                 :    8029810 :   bind_stmt = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
    1416                 :    4014900 :                                  BIND_EXPR_BLOCK (bind_expr));
    1417                 :    4014900 :   gimple_push_bind_expr (bind_stmt);
    1418                 :            : 
    1419                 :    4014900 :   gimplify_ctxp->keep_stack = false;
    1420                 :    4014900 :   gimplify_ctxp->save_stack = false;
    1421                 :            : 
    1422                 :            :   /* Gimplify the body into the GIMPLE_BIND tuple's body.  */
    1423                 :    4014900 :   body = NULL;
    1424                 :    4014900 :   gimplify_stmt (&BIND_EXPR_BODY (bind_expr), &body);
    1425                 :    4014900 :   gimple_bind_set_body (bind_stmt, body);
    1426                 :            : 
    1427                 :            :   /* Source location wise, the cleanup code (stack_restore and clobbers)
    1428                 :            :      belongs to the end of the block, so propagate what we have.  The
    1429                 :            :      stack_save operation belongs to the beginning of block, which we can
    1430                 :            :      infer from the bind_expr directly if the block has no explicit
    1431                 :            :      assignment.  */
    1432                 :    4014900 :   if (BIND_EXPR_BLOCK (bind_expr))
    1433                 :            :     {
    1434                 :    3890950 :       end_locus = BLOCK_SOURCE_END_LOCATION (BIND_EXPR_BLOCK (bind_expr));
    1435                 :    3890950 :       start_locus = BLOCK_SOURCE_LOCATION (BIND_EXPR_BLOCK (bind_expr));
    1436                 :            :     }
    1437                 :    3890950 :   if (start_locus == 0)
    1438                 :    4014900 :     start_locus = EXPR_LOCATION (bind_expr);
    1439                 :            : 
    1440                 :    4014900 :   cleanup = NULL;
    1441                 :    4014900 :   stack_save = NULL;
    1442                 :            : 
    1443                 :            :   /* If the code both contains VLAs and calls alloca, then we cannot reclaim
    1444                 :            :      the stack space allocated to the VLAs.  */
    1445                 :    4014900 :   if (gimplify_ctxp->save_stack && !gimplify_ctxp->keep_stack)
    1446                 :            :     {
    1447                 :       7287 :       gcall *stack_restore;
    1448                 :            : 
    1449                 :            :       /* Save stack on entry and restore it on exit.  Add a try_finally
    1450                 :            :          block to achieve this.  */
    1451                 :       7287 :       build_stack_save_restore (&stack_save, &stack_restore);
    1452                 :            : 
    1453                 :       7287 :       gimple_set_location (stack_save, start_locus);
    1454                 :       7287 :       gimple_set_location (stack_restore, end_locus);
    1455                 :            : 
    1456                 :       7287 :       gimplify_seq_add_stmt (&cleanup, stack_restore);
    1457                 :            :     }
    1458                 :            : 
    1459                 :            :   /* Add clobbers for all variables that go out of scope.  */
    1460                 :    7883430 :   for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
    1461                 :            :     {
    1462                 :    3868520 :       if (VAR_P (t)
    1463                 :    3565910 :           && !is_global_var (t)
    1464                 :    7274250 :           && DECL_CONTEXT (t) == current_function_decl)
    1465                 :            :         {
    1466                 :    3404950 :           if (!DECL_HARD_REGISTER (t)
    1467                 :    3404320 :               && !TREE_THIS_VOLATILE (t)
    1468                 :    3362110 :               && !DECL_HAS_VALUE_EXPR_P (t)
    1469                 :            :               /* Only care for variables that have to be in memory.  Others
    1470                 :            :                  will be rewritten into SSA names, hence moved to the
    1471                 :            :                  top-level.  */
    1472                 :    3334750 :               && !is_gimple_reg (t)
    1473                 :    4174720 :               && flag_stack_reuse != SR_NONE)
    1474                 :            :             {
    1475                 :     768343 :               tree clobber = build_clobber (TREE_TYPE (t));
    1476                 :     768343 :               gimple *clobber_stmt;
    1477                 :     768343 :               clobber_stmt = gimple_build_assign (t, clobber);
    1478                 :     768343 :               gimple_set_location (clobber_stmt, end_locus);
    1479                 :     768343 :               gimplify_seq_add_stmt (&cleanup, clobber_stmt);
    1480                 :            :             }
    1481                 :            : 
    1482                 :    3404950 :           if (flag_openacc && oacc_declare_returns != NULL)
    1483                 :            :             {
    1484                 :        238 :               tree *c = oacc_declare_returns->get (t);
    1485                 :        123 :               if (c != NULL)
    1486                 :            :                 {
    1487                 :        123 :                   if (ret_clauses)
    1488                 :         75 :                     OMP_CLAUSE_CHAIN (*c) = ret_clauses;
    1489                 :            : 
    1490                 :        123 :                   ret_clauses = *c;
    1491                 :            : 
    1492                 :        123 :                   oacc_declare_returns->remove (t);
    1493                 :            : 
    1494                 :        123 :                   if (oacc_declare_returns->is_empty ())
    1495                 :            :                     {
    1496                 :         33 :                       delete oacc_declare_returns;
    1497                 :         33 :                       oacc_declare_returns = NULL;
    1498                 :            :                     }
    1499                 :            :                 }
    1500                 :            :             }
    1501                 :            :         }
    1502                 :            : 
    1503                 :    3868520 :       if (asan_poisoned_variables != NULL
    1504                 :    3868520 :           && asan_poisoned_variables->contains (t))
    1505                 :            :         {
    1506                 :       1349 :           asan_poisoned_variables->remove (t);
    1507                 :       1349 :           asan_poison_variable (t, true, &cleanup);
    1508                 :            :         }
    1509                 :            : 
    1510                 :    3868520 :       if (gimplify_ctxp->live_switch_vars != NULL
    1511                 :    3868520 :           && gimplify_ctxp->live_switch_vars->contains (t))
    1512                 :         55 :         gimplify_ctxp->live_switch_vars->remove (t);
    1513                 :            :     }
    1514                 :            : 
    1515                 :    4014900 :   if (ret_clauses)
    1516                 :            :     {
    1517                 :         48 :       gomp_target *stmt;
    1518                 :         48 :       gimple_stmt_iterator si = gsi_start (cleanup);
    1519                 :            : 
    1520                 :         48 :       stmt = gimple_build_omp_target (NULL, GF_OMP_TARGET_KIND_OACC_DECLARE,
    1521                 :            :                                       ret_clauses);
    1522                 :         48 :       gsi_insert_seq_before_without_update (&si, stmt, GSI_NEW_STMT);
    1523                 :            :     }
    1524                 :            : 
    1525                 :    4014900 :   if (cleanup)
    1526                 :            :     {
    1527                 :     497238 :       gtry *gs;
    1528                 :     497238 :       gimple_seq new_body;
    1529                 :            : 
    1530                 :     497238 :       new_body = NULL;
    1531                 :     497238 :       gs = gimple_build_try (gimple_bind_body (bind_stmt), cleanup,
    1532                 :            :                              GIMPLE_TRY_FINALLY);
    1533                 :            : 
    1534                 :     497238 :       if (stack_save)
    1535                 :       7287 :         gimplify_seq_add_stmt (&new_body, stack_save);
    1536                 :     497238 :       gimplify_seq_add_stmt (&new_body, gs);
    1537                 :     497238 :       gimple_bind_set_body (bind_stmt, new_body);
    1538                 :            :     }
    1539                 :            : 
    1540                 :            :   /* keep_stack propagates all the way up to the outermost BIND_EXPR.  */
    1541                 :    4014900 :   if (!gimplify_ctxp->keep_stack)
    1542                 :    4005760 :     gimplify_ctxp->keep_stack = old_keep_stack;
    1543                 :    4014900 :   gimplify_ctxp->save_stack = old_save_stack;
    1544                 :            : 
    1545                 :    4014900 :   gimple_pop_bind_expr ();
    1546                 :            : 
    1547                 :    4014900 :   gimplify_seq_add_stmt (pre_p, bind_stmt);
    1548                 :            : 
    1549                 :    4014900 :   if (temp)
    1550                 :            :     {
    1551                 :       3319 :       *expr_p = temp;
    1552                 :       3319 :       return GS_OK;
    1553                 :            :     }
    1554                 :            : 
    1555                 :    4011580 :   *expr_p = NULL_TREE;
    1556                 :    4011580 :   return GS_ALL_DONE;
    1557                 :            : }
    1558                 :            : 
    1559                 :            : /* Maybe add early return predict statement to PRE_P sequence.  */
    1560                 :            : 
    1561                 :            : static void
    1562                 :    1339620 : maybe_add_early_return_predict_stmt (gimple_seq *pre_p)
    1563                 :            : {
    1564                 :            :   /* If we are not in a conditional context, add PREDICT statement.  */
    1565                 :    1339620 :   if (gimple_conditional_context ())
    1566                 :            :     {
    1567                 :     236096 :       gimple *predict = gimple_build_predict (PRED_TREE_EARLY_RETURN,
    1568                 :            :                                               NOT_TAKEN);
    1569                 :     236096 :       gimplify_seq_add_stmt (pre_p, predict);
    1570                 :            :     }
    1571                 :    1339620 : }
    1572                 :            : 
    1573                 :            : /* Gimplify a RETURN_EXPR.  If the expression to be returned is not a
    1574                 :            :    GIMPLE value, it is assigned to a new temporary and the statement is
    1575                 :            :    re-written to return the temporary.
    1576                 :            : 
    1577                 :            :    PRE_P points to the sequence where side effects that must happen before
    1578                 :            :    STMT should be stored.  */
    1579                 :            : 
    1580                 :            : static enum gimplify_status
    1581                 :    1339630 : gimplify_return_expr (tree stmt, gimple_seq *pre_p)
    1582                 :            : {
    1583                 :    1339630 :   greturn *ret;
    1584                 :    1339630 :   tree ret_expr = TREE_OPERAND (stmt, 0);
    1585                 :    1339630 :   tree result_decl, result;
    1586                 :            : 
    1587                 :    1339630 :   if (ret_expr == error_mark_node)
    1588                 :            :     return GS_ERROR;
    1589                 :            : 
    1590                 :    1339620 :   if (!ret_expr
    1591                 :    1295810 :       || TREE_CODE (ret_expr) == RESULT_DECL)
    1592                 :            :     {
    1593                 :      53800 :       maybe_add_early_return_predict_stmt (pre_p);
    1594                 :      53800 :       greturn *ret = gimple_build_return (ret_expr);
    1595                 :      53800 :       gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
    1596                 :      53800 :       gimplify_seq_add_stmt (pre_p, ret);
    1597                 :      53800 :       return GS_ALL_DONE;
    1598                 :            :     }
    1599                 :            : 
    1600                 :    1285820 :   if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
    1601                 :            :     result_decl = NULL_TREE;
    1602                 :    1285680 :   else if (TREE_CODE (ret_expr) == COMPOUND_EXPR)
    1603                 :            :     {
    1604                 :            :       /* Used in C++ for handling EH cleanup of the return value if a local
    1605                 :            :          cleanup throws.  Assume the front-end knows what it's doing.  */
    1606                 :        159 :       result_decl = DECL_RESULT (current_function_decl);
    1607                 :            :       /* But crash if we end up trying to modify ret_expr below.  */
    1608                 :        159 :       ret_expr = NULL_TREE;
    1609                 :            :     }
    1610                 :            :   else
    1611                 :            :     {
    1612                 :    1285520 :       result_decl = TREE_OPERAND (ret_expr, 0);
    1613                 :            : 
    1614                 :            :       /* See through a return by reference.  */
    1615                 :    1285520 :       if (TREE_CODE (result_decl) == INDIRECT_REF)
    1616                 :      24371 :         result_decl = TREE_OPERAND (result_decl, 0);
    1617                 :            : 
    1618                 :    1285520 :       gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
    1619                 :            :                    || TREE_CODE (ret_expr) == INIT_EXPR)
    1620                 :            :                   && TREE_CODE (result_decl) == RESULT_DECL);
    1621                 :            :     }
    1622                 :            : 
    1623                 :            :   /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
    1624                 :            :      Recall that aggregate_value_p is FALSE for any aggregate type that is
    1625                 :            :      returned in registers.  If we're returning values in registers, then
    1626                 :            :      we don't want to extend the lifetime of the RESULT_DECL, particularly
    1627                 :            :      across another call.  In addition, for those aggregates for which
    1628                 :            :      hard_function_value generates a PARALLEL, we'll die during normal
    1629                 :            :      expansion of structure assignments; there's special code in expand_return
    1630                 :            :      to handle this case that does not exist in expand_expr.  */
    1631                 :    1285680 :   if (!result_decl)
    1632                 :            :     result = NULL_TREE;
    1633                 :    1285680 :   else if (aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
    1634                 :            :     {
    1635                 :     120839 :       if (!poly_int_tree_p (DECL_SIZE (result_decl)))
    1636                 :            :         {
    1637                 :         34 :           if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl)))
    1638                 :          0 :             gimplify_type_sizes (TREE_TYPE (result_decl), pre_p);
    1639                 :            :           /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
    1640                 :            :              should be effectively allocated by the caller, i.e. all calls to
    1641                 :            :              this function must be subject to the Return Slot Optimization.  */
    1642                 :         34 :           gimplify_one_sizepos (&DECL_SIZE (result_decl), pre_p);
    1643                 :         34 :           gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl), pre_p);
    1644                 :            :         }
    1645                 :            :       result = result_decl;
    1646                 :            :     }
    1647                 :    1164840 :   else if (gimplify_ctxp->return_temp)
    1648                 :            :     result = gimplify_ctxp->return_temp;
    1649                 :            :   else
    1650                 :            :     {
    1651                 :     924466 :       result = create_tmp_reg (TREE_TYPE (result_decl));
    1652                 :            : 
    1653                 :            :       /* ??? With complex control flow (usually involving abnormal edges),
    1654                 :            :          we can wind up warning about an uninitialized value for this.  Due
    1655                 :            :          to how this variable is constructed and initialized, this is never
    1656                 :            :          true.  Give up and never warn.  */
    1657                 :     924466 :       TREE_NO_WARNING (result) = 1;
    1658                 :            : 
    1659                 :     924466 :       gimplify_ctxp->return_temp = result;
    1660                 :            :     }
    1661                 :            : 
    1662                 :            :   /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
    1663                 :            :      Then gimplify the whole thing.  */
    1664                 :    1285820 :   if (result != result_decl)
    1665                 :    1164840 :     TREE_OPERAND (ret_expr, 0) = result;
    1666                 :            : 
    1667                 :    1285820 :   gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
    1668                 :            : 
    1669                 :    1285820 :   maybe_add_early_return_predict_stmt (pre_p);
    1670                 :    1285820 :   ret = gimple_build_return (result);
    1671                 :    1285820 :   gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
    1672                 :    1285820 :   gimplify_seq_add_stmt (pre_p, ret);
    1673                 :            : 
    1674                 :    1285820 :   return GS_ALL_DONE;
    1675                 :            : }
    1676                 :            : 
    1677                 :            : /* Gimplify a variable-length array DECL.  */
    1678                 :            : 
    1679                 :            : static void
    1680                 :       8185 : gimplify_vla_decl (tree decl, gimple_seq *seq_p)
    1681                 :            : {
    1682                 :            :   /* This is a variable-sized decl.  Simplify its size and mark it
    1683                 :            :      for deferred expansion.  */
    1684                 :       8185 :   tree t, addr, ptr_type;
    1685                 :            : 
    1686                 :       8185 :   gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
    1687                 :       8185 :   gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
    1688                 :            : 
    1689                 :            :   /* Don't mess with a DECL_VALUE_EXPR set by the front-end.  */
    1690                 :       8185 :   if (DECL_HAS_VALUE_EXPR_P (decl))
    1691                 :            :     return;
    1692                 :            : 
    1693                 :            :   /* All occurrences of this decl in final gimplified code will be
    1694                 :            :      replaced by indirection.  Setting DECL_VALUE_EXPR does two
    1695                 :            :      things: First, it lets the rest of the gimplifier know what
    1696                 :            :      replacement to use.  Second, it lets the debug info know
    1697                 :            :      where to find the value.  */
    1698                 :       8185 :   ptr_type = build_pointer_type (TREE_TYPE (decl));
    1699                 :       8185 :   addr = create_tmp_var (ptr_type, get_name (decl));
    1700                 :       8185 :   DECL_IGNORED_P (addr) = 0;
    1701                 :       8185 :   t = build_fold_indirect_ref (addr);
    1702                 :       8185 :   TREE_THIS_NOTRAP (t) = 1;
    1703                 :       8185 :   SET_DECL_VALUE_EXPR (decl, t);
    1704                 :       8185 :   DECL_HAS_VALUE_EXPR_P (decl) = 1;
    1705                 :            : 
    1706                 :      16370 :   t = build_alloca_call_expr (DECL_SIZE_UNIT (decl), DECL_ALIGN (decl),
    1707                 :       8185 :                               max_int_size_in_bytes (TREE_TYPE (decl)));
    1708                 :            :   /* The call has been built for a variable-sized object.  */
    1709                 :       8185 :   CALL_ALLOCA_FOR_VAR_P (t) = 1;
    1710                 :       8185 :   t = fold_convert (ptr_type, t);
    1711                 :       8185 :   t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
    1712                 :            : 
    1713                 :       8185 :   gimplify_and_add (t, seq_p);
    1714                 :            : 
    1715                 :            :   /* Record the dynamic allocation associated with DECL if requested.  */
    1716                 :       8185 :   if (flag_callgraph_info & CALLGRAPH_INFO_DYNAMIC_ALLOC)
    1717                 :          0 :     record_dynamic_alloc (decl);
    1718                 :            : }
    1719                 :            : 
    1720                 :            : /* A helper function to be called via walk_tree.  Mark all labels under *TP
    1721                 :            :    as being forced.  To be called for DECL_INITIAL of static variables.  */
    1722                 :            : 
    1723                 :            : static tree
    1724                 :     583049 : force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
    1725                 :            : {
    1726                 :     583049 :   if (TYPE_P (*tp))
    1727                 :          0 :     *walk_subtrees = 0;
    1728                 :     583049 :   if (TREE_CODE (*tp) == LABEL_DECL)
    1729                 :            :     {
    1730                 :        986 :       FORCED_LABEL (*tp) = 1;
    1731                 :        986 :       cfun->has_forced_label_in_static = 1;
    1732                 :            :     }
    1733                 :            : 
    1734                 :     583049 :   return NULL_TREE;
    1735                 :            : }
    1736                 :            : 
    1737                 :            : /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
    1738                 :            :    and initialization explicit.  */
    1739                 :            : 
    1740                 :            : static enum gimplify_status
    1741                 :    4647200 : gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
    1742                 :            : {
    1743                 :    4647200 :   tree stmt = *stmt_p;
    1744                 :    4647200 :   tree decl = DECL_EXPR_DECL (stmt);
    1745                 :            : 
    1746                 :    4647200 :   *stmt_p = NULL_TREE;
    1747                 :            : 
    1748                 :    4647200 :   if (TREE_TYPE (decl) == error_mark_node)
    1749                 :            :     return GS_ERROR;
    1750                 :            : 
    1751                 :    4647150 :   if ((TREE_CODE (decl) == TYPE_DECL
    1752                 :    4615390 :        || VAR_P (decl))
    1753                 :    9259840 :       && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
    1754                 :            :     {
    1755                 :     512504 :       gimplify_type_sizes (TREE_TYPE (decl), seq_p);
    1756                 :     512504 :       if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
    1757                 :      14971 :         gimplify_type_sizes (TREE_TYPE (TREE_TYPE (decl)), seq_p);
    1758                 :            :     }
    1759                 :            : 
    1760                 :            :   /* ??? DECL_ORIGINAL_TYPE is streamed for LTO so it needs to be gimplified
    1761                 :            :      in case its size expressions contain problematic nodes like CALL_EXPR.  */
    1762                 :    4647150 :   if (TREE_CODE (decl) == TYPE_DECL
    1763                 :      31756 :       && DECL_ORIGINAL_TYPE (decl)
    1764                 :    4652430 :       && !TYPE_SIZES_GIMPLIFIED (DECL_ORIGINAL_TYPE (decl)))
    1765                 :            :     {
    1766                 :          0 :       gimplify_type_sizes (DECL_ORIGINAL_TYPE (decl), seq_p);
    1767                 :          0 :       if (TREE_CODE (DECL_ORIGINAL_TYPE (decl)) == REFERENCE_TYPE)
    1768                 :          0 :         gimplify_type_sizes (TREE_TYPE (DECL_ORIGINAL_TYPE (decl)), seq_p);
    1769                 :            :     }
    1770                 :            : 
    1771                 :    4647150 :   if (VAR_P (decl) && !DECL_EXTERNAL (decl))
    1772                 :            :     {
    1773                 :    4612690 :       tree init = DECL_INITIAL (decl);
    1774                 :    4612690 :       bool is_vla = false;
    1775                 :            : 
    1776                 :    4612690 :       poly_uint64 size;
    1777                 :    4612690 :       if (!poly_int_tree_p (DECL_SIZE_UNIT (decl), &size)
    1778                 :    4612690 :           || (!TREE_STATIC (decl)
    1779                 :    4512300 :               && flag_stack_check == GENERIC_STACK_CHECK
    1780                 :        205 :               && maybe_gt (size,
    1781                 :            :                            (unsigned HOST_WIDE_INT) STACK_CHECK_MAX_VAR_SIZE)))
    1782                 :            :         {
    1783                 :       8081 :           gimplify_vla_decl (decl, seq_p);
    1784                 :       8081 :           is_vla = true;
    1785                 :            :         }
    1786                 :            : 
    1787                 :    4612690 :       if (asan_poisoned_variables
    1788                 :       3522 :           && !is_vla
    1789                 :            :           && TREE_ADDRESSABLE (decl)
    1790                 :       3353 :           && !TREE_STATIC (decl)
    1791                 :       1364 :           && !DECL_HAS_VALUE_EXPR_P (decl)
    1792                 :       1357 :           && DECL_ALIGN (decl) <= MAX_SUPPORTED_STACK_ALIGNMENT
    1793                 :       1357 :           && dbg_cnt (asan_use_after_scope)
    1794                 :    4614050 :           && !gimplify_omp_ctxp)
    1795                 :            :         {
    1796                 :       1349 :           asan_poisoned_variables->add (decl);
    1797                 :       1349 :           asan_poison_variable (decl, false, seq_p);
    1798                 :       1349 :           if (!DECL_ARTIFICIAL (decl) && gimplify_ctxp->live_switch_vars)
    1799                 :         55 :             gimplify_ctxp->live_switch_vars->add (decl);
    1800                 :            :         }
    1801                 :            : 
    1802                 :            :       /* Some front ends do not explicitly declare all anonymous
    1803                 :            :          artificial variables.  We compensate here by declaring the
    1804                 :            :          variables, though it would be better if the front ends would
    1805                 :            :          explicitly declare them.  */
    1806                 :    4612690 :       if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
    1807                 :    4612690 :           && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
    1808                 :      14541 :         gimple_add_tmp_var (decl);
    1809                 :            : 
    1810                 :    4612690 :       if (init && init != error_mark_node)
    1811                 :            :         {
    1812                 :    2875790 :           if (!TREE_STATIC (decl))
    1813                 :            :             {
    1814                 :    2853750 :               DECL_INITIAL (decl) = NULL_TREE;
    1815                 :    2853750 :               init = build2 (INIT_EXPR, void_type_node, decl, init);
    1816                 :    2853750 :               gimplify_and_add (init, seq_p);
    1817                 :    2853750 :               ggc_free (init);
    1818                 :            :             }
    1819                 :            :           else
    1820                 :            :             /* We must still examine initializers for static variables
    1821                 :            :                as they may contain a label address.  */
    1822                 :      22041 :             walk_tree (&init, force_labels_r, NULL, NULL);
    1823                 :            :         }
    1824                 :            :     }
    1825                 :            : 
    1826                 :            :   return GS_ALL_DONE;
    1827                 :            : }
    1828                 :            : 
    1829                 :            : /* Gimplify a LOOP_EXPR.  Normally this just involves gimplifying the body
    1830                 :            :    and replacing the LOOP_EXPR with goto, but if the loop contains an
    1831                 :            :    EXIT_EXPR, we need to append a label for it to jump to.  */
    1832                 :            : 
    1833                 :            : static enum gimplify_status
    1834                 :     196645 : gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
    1835                 :            : {
    1836                 :     196645 :   tree saved_label = gimplify_ctxp->exit_label;
    1837                 :     196645 :   tree start_label = create_artificial_label (UNKNOWN_LOCATION);
    1838                 :            : 
    1839                 :     196645 :   gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
    1840                 :            : 
    1841                 :     196645 :   gimplify_ctxp->exit_label = NULL_TREE;
    1842                 :            : 
    1843                 :     196645 :   gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
    1844                 :            : 
    1845                 :     196645 :   gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
    1846                 :            : 
    1847                 :     196645 :   if (gimplify_ctxp->exit_label)
    1848                 :     199027 :     gimplify_seq_add_stmt (pre_p,
    1849                 :       2382 :                            gimple_build_label (gimplify_ctxp->exit_label));
    1850                 :            : 
    1851                 :     196645 :   gimplify_ctxp->exit_label = saved_label;
    1852                 :            : 
    1853                 :     196645 :   *expr_p = NULL;
    1854                 :     196645 :   return GS_ALL_DONE;
    1855                 :            : }
    1856                 :            : 
    1857                 :            : /* Gimplify a statement list onto a sequence.  These may be created either
    1858                 :            :    by an enlightened front-end, or by shortcut_cond_expr.  */
    1859                 :            : 
    1860                 :            : static enum gimplify_status
    1861                 :    5844410 : gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
    1862                 :            : {
    1863                 :    5844410 :   tree temp = voidify_wrapper_expr (*expr_p, NULL);
    1864                 :            : 
    1865                 :    5844410 :   tree_stmt_iterator i = tsi_start (*expr_p);
    1866                 :            : 
    1867                 :   30987600 :   while (!tsi_end_p (i))
    1868                 :            :     {
    1869                 :   25143200 :       gimplify_stmt (tsi_stmt_ptr (i), pre_p);
    1870                 :   25143200 :       tsi_delink (&i);
    1871                 :            :     }
    1872                 :            : 
    1873                 :    5844410 :   if (temp)
    1874                 :            :     {
    1875                 :       8476 :       *expr_p = temp;
    1876                 :       8476 :       return GS_OK;
    1877                 :            :     }
    1878                 :            : 
    1879                 :            :   return GS_ALL_DONE;
    1880                 :            : }
    1881                 :            : 
    1882                 :            : /* Callback for walk_gimple_seq.  */
    1883                 :            : 
    1884                 :            : static tree
    1885                 :      32385 : warn_switch_unreachable_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
    1886                 :            :                            struct walk_stmt_info *wi)
    1887                 :            : {
    1888                 :      32385 :   gimple *stmt = gsi_stmt (*gsi_p);
    1889                 :            : 
    1890                 :      32385 :   *handled_ops_p = true;
    1891                 :      32385 :   switch (gimple_code (stmt))
    1892                 :            :     {
    1893                 :        117 :     case GIMPLE_TRY:
    1894                 :            :       /* A compiler-generated cleanup or a user-written try block.
    1895                 :            :          If it's empty, don't dive into it--that would result in
    1896                 :            :          worse location info.  */
    1897                 :        117 :       if (gimple_try_eval (stmt) == NULL)
    1898                 :            :         {
    1899                 :          4 :           wi->info = stmt;
    1900                 :          4 :           return integer_zero_node;
    1901                 :            :         }
    1902                 :            :       /* Fall through.  */
    1903                 :       1081 :     case GIMPLE_BIND:
    1904                 :       1081 :     case GIMPLE_CATCH:
    1905                 :       1081 :     case GIMPLE_EH_FILTER:
    1906                 :       1081 :     case GIMPLE_TRANSACTION:
    1907                 :            :       /* Walk the sub-statements.  */
    1908                 :       1081 :       *handled_ops_p = false;
    1909                 :       1081 :       break;
    1910                 :            : 
    1911                 :            :     case GIMPLE_DEBUG:
    1912                 :            :       /* Ignore these.  We may generate them before declarations that
    1913                 :            :          are never executed.  If there's something to warn about,
    1914                 :            :          there will be non-debug stmts too, and we'll catch those.  */
    1915                 :            :       break;
    1916                 :            : 
    1917                 :         26 :     case GIMPLE_CALL:
    1918                 :         26 :       if (gimple_call_internal_p (stmt, IFN_ASAN_MARK))
    1919                 :            :         {
    1920                 :          8 :           *handled_ops_p = false;
    1921                 :          8 :           break;
    1922                 :            :         }
    1923                 :            :       /* Fall through.  */
    1924                 :      30830 :     default:
    1925                 :            :       /* Save the first "real" statement (not a decl/lexical scope/...).  */
    1926                 :      30830 :       wi->info = stmt;
    1927                 :      30830 :       return integer_zero_node;
    1928                 :            :     }
    1929                 :            :   return NULL_TREE;
    1930                 :            : }
    1931                 :            : 
    1932                 :            : /* Possibly warn about unreachable statements between switch's controlling
    1933                 :            :    expression and the first case.  SEQ is the body of a switch expression.  */
    1934                 :            : 
    1935                 :            : static void
    1936                 :      33146 : maybe_warn_switch_unreachable (gimple_seq seq)
    1937                 :            : {
    1938                 :      33146 :   if (!warn_switch_unreachable
    1939                 :            :       /* This warning doesn't play well with Fortran when optimizations
    1940                 :            :          are on.  */
    1941                 :      33113 :       || lang_GNU_Fortran ()
    1942                 :      64111 :       || seq == NULL)
    1943                 :       2309 :     return;
    1944                 :            : 
    1945                 :      30837 :   struct walk_stmt_info wi;
    1946                 :      30837 :   memset (&wi, 0, sizeof (wi));
    1947                 :      30837 :   walk_gimple_seq (seq, warn_switch_unreachable_r, NULL, &wi);
    1948                 :      30837 :   gimple *stmt = (gimple *) wi.info;
    1949                 :            : 
    1950                 :      30837 :   if (stmt && gimple_code (stmt) != GIMPLE_LABEL)
    1951                 :            :     {
    1952                 :        210 :       if (gimple_code (stmt) == GIMPLE_GOTO
    1953                 :         52 :           && TREE_CODE (gimple_goto_dest (stmt)) == LABEL_DECL
    1954                 :        262 :           && DECL_ARTIFICIAL (gimple_goto_dest (stmt)))
    1955                 :            :         /* Don't warn for compiler-generated gotos.  These occur
    1956                 :            :            in Duff's devices, for example.  */;
    1957                 :            :       else
    1958                 :        158 :         warning_at (gimple_location (stmt), OPT_Wswitch_unreachable,
    1959                 :            :                     "statement will never be executed");
    1960                 :            :     }
    1961                 :            : }
    1962                 :            : 
    1963                 :            : 
    1964                 :            : /* A label entry that pairs label and a location.  */
    1965                 :            : struct label_entry
    1966                 :            : {
    1967                 :            :   tree label;
    1968                 :            :   location_t loc;
    1969                 :            : };
    1970                 :            : 
    1971                 :            : /* Find LABEL in vector of label entries VEC.  */
    1972                 :            : 
    1973                 :            : static struct label_entry *
    1974                 :       6611 : find_label_entry (const auto_vec<struct label_entry> *vec, tree label)
    1975                 :            : {
    1976                 :          0 :   unsigned int i;
    1977                 :          0 :   struct label_entry *l;
    1978                 :            : 
    1979                 :      14451 :   FOR_EACH_VEC_ELT (*vec, i, l)
    1980                 :      13615 :     if (l->label == label)
    1981                 :          0 :       return l;
    1982                 :            :   return NULL;
    1983                 :            : }
    1984                 :            : 
    1985                 :            : /* Return true if LABEL, a LABEL_DECL, represents a case label
    1986                 :            :    in a vector of labels CASES.  */
    1987                 :            : 
    1988                 :            : static bool
    1989                 :      14077 : case_label_p (const vec<tree> *cases, tree label)
    1990                 :            : {
    1991                 :      14077 :   unsigned int i;
    1992                 :      14077 :   tree l;
    1993                 :            : 
    1994                 :     133572 :   FOR_EACH_VEC_ELT (*cases, i, l)
    1995                 :     130605 :     if (CASE_LABEL (l) == label)
    1996                 :            :       return true;
    1997                 :            :   return false;
    1998                 :            : }
    1999                 :            : 
    2000                 :            : /* Find the last nondebug statement in a scope STMT.  */
    2001                 :            : 
    2002                 :            : static gimple *
    2003                 :       1659 : last_stmt_in_scope (gimple *stmt)
    2004                 :            : {
    2005                 :       3163 :   if (!stmt)
    2006                 :            :     return NULL;
    2007                 :            : 
    2008                 :       3150 :   switch (gimple_code (stmt))
    2009                 :            :     {
    2010                 :       1212 :     case GIMPLE_BIND:
    2011                 :       1212 :       {
    2012                 :       1212 :         gbind *bind = as_a <gbind *> (stmt);
    2013                 :       1212 :         stmt = gimple_seq_last_nondebug_stmt (gimple_bind_body (bind));
    2014                 :       1212 :         return last_stmt_in_scope (stmt);
    2015                 :            :       }
    2016                 :            : 
    2017                 :        386 :     case GIMPLE_TRY:
    2018                 :        386 :       {
    2019                 :        386 :         gtry *try_stmt = as_a <gtry *> (stmt);
    2020                 :        386 :         stmt = gimple_seq_last_nondebug_stmt (gimple_try_eval (try_stmt));
    2021                 :        386 :         gimple *last_eval = last_stmt_in_scope (stmt);
    2022                 :        386 :         if (gimple_stmt_may_fallthru (last_eval)
    2023                 :        299 :             && (last_eval == NULL
    2024                 :        296 :                 || !gimple_call_internal_p (last_eval, IFN_FALLTHROUGH))
    2025                 :        678 :             && gimple_try_kind (try_stmt) == GIMPLE_TRY_FINALLY)
    2026                 :            :           {
    2027                 :        292 :             stmt = gimple_seq_last_nondebug_stmt (gimple_try_cleanup (try_stmt));
    2028                 :        292 :             return last_stmt_in_scope (stmt);
    2029                 :            :           }
    2030                 :            :         else
    2031                 :            :           return last_eval;
    2032                 :            :       }
    2033                 :            : 
    2034                 :          0 :     case GIMPLE_DEBUG:
    2035                 :          0 :       gcc_unreachable ();
    2036                 :            : 
    2037                 :            :     default:
    2038                 :            :       return stmt;
    2039                 :            :     }
    2040                 :            : }
    2041                 :            : 
    2042                 :            : /* Collect interesting labels in LABELS and return the statement preceding
    2043                 :            :    another case label, or a user-defined label.  Store a location useful
    2044                 :            :    to give warnings at *PREVLOC (usually the location of the returned
    2045                 :            :    statement or of its surrounding scope).  */
    2046                 :            : 
    2047                 :            : static gimple *
    2048                 :      14979 : collect_fallthrough_labels (gimple_stmt_iterator *gsi_p,
    2049                 :            :                             auto_vec <struct label_entry> *labels,
    2050                 :            :                             location_t *prevloc)
    2051                 :            : {
    2052                 :      14979 :   gimple *prev = NULL;
    2053                 :            : 
    2054                 :      14979 :   *prevloc = UNKNOWN_LOCATION;
    2055                 :      66195 :   do
    2056                 :            :     {
    2057                 :      66195 :       if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_BIND)
    2058                 :            :         {
    2059                 :            :           /* Recognize the special GIMPLE_BIND added by gimplify_switch_expr,
    2060                 :            :              which starts on a GIMPLE_SWITCH and ends with a break label.
    2061                 :            :              Handle that as a single statement that can fall through.  */
    2062                 :       1319 :           gbind *bind = as_a <gbind *> (gsi_stmt (*gsi_p));
    2063                 :       1319 :           gimple *first = gimple_seq_first_stmt (gimple_bind_body (bind));
    2064                 :       1319 :           gimple *last = gimple_seq_last_stmt (gimple_bind_body (bind));
    2065                 :       1309 :           if (last
    2066                 :       1309 :               && gimple_code (first) == GIMPLE_SWITCH
    2067                 :       1450 :               && gimple_code (last) == GIMPLE_LABEL)
    2068                 :            :             {
    2069                 :        141 :               tree label = gimple_label_label (as_a <glabel *> (last));
    2070                 :        141 :               if (SWITCH_BREAK_LABEL_P (label))
    2071                 :            :                 {
    2072                 :        141 :                   prev = bind;
    2073                 :        141 :                   gsi_next (gsi_p);
    2074                 :        141 :                   continue;
    2075                 :            :                 }
    2076                 :            :             }
    2077                 :            :         }
    2078                 :      66054 :       if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_BIND
    2079                 :      66054 :           || gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_TRY)
    2080                 :            :         {
    2081                 :            :           /* Nested scope.  Only look at the last statement of
    2082                 :            :              the innermost scope.  */
    2083                 :       1273 :           location_t bind_loc = gimple_location (gsi_stmt (*gsi_p));
    2084                 :       1273 :           gimple *last = last_stmt_in_scope (gsi_stmt (*gsi_p));
    2085                 :       1273 :           if (last)
    2086                 :            :             {
    2087                 :       1263 :               prev = last;
    2088                 :            :               /* It might be a label without a location.  Use the
    2089                 :            :                  location of the scope then.  */
    2090                 :       1666 :               if (!gimple_has_location (prev))
    2091                 :        579 :                 *prevloc = bind_loc;
    2092                 :            :             }
    2093                 :       1273 :           gsi_next (gsi_p);
    2094                 :       1273 :           continue;
    2095                 :            :         }
    2096                 :            : 
    2097                 :            :       /* Ifs are tricky.  */
    2098                 :      64781 :       if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_COND)
    2099                 :            :         {
    2100                 :       4488 :           gcond *cond_stmt = as_a <gcond *> (gsi_stmt (*gsi_p));
    2101                 :       4488 :           tree false_lab = gimple_cond_false_label (cond_stmt);
    2102                 :       4488 :           location_t if_loc = gimple_location (cond_stmt);
    2103                 :            : 
    2104                 :            :           /* If we have e.g.
    2105                 :            :                if (i > 1) goto <D.2259>; else goto D;
    2106                 :            :              we can't do much with the else-branch.  */
    2107                 :       4488 :           if (!DECL_ARTIFICIAL (false_lab))
    2108                 :            :             break;
    2109                 :            : 
    2110                 :            :           /* Go on until the false label, then one step back.  */
    2111                 :      38592 :           for (; !gsi_end_p (*gsi_p); gsi_next (gsi_p))
    2112                 :            :             {
    2113                 :      38592 :               gimple *stmt = gsi_stmt (*gsi_p);
    2114                 :      38592 :               if (gimple_code (stmt) == GIMPLE_LABEL
    2115                 :      38592 :                   && gimple_label_label (as_a <glabel *> (stmt)) == false_lab)
    2116                 :            :                 break;
    2117                 :            :             }
    2118                 :            : 
    2119                 :            :           /* Not found?  Oops.  */
    2120                 :       4488 :           if (gsi_end_p (*gsi_p))
    2121                 :            :             break;
    2122                 :            : 
    2123                 :       4488 :           struct label_entry l = { false_lab, if_loc };
    2124                 :       4488 :           labels->safe_push (l);
    2125                 :            : 
    2126                 :            :           /* Go to the last statement of the then branch.  */
    2127                 :       4488 :           gsi_prev (gsi_p);
    2128                 :            : 
    2129                 :            :           /* if (i != 0) goto <D.1759>; else goto <D.1760>;
    2130                 :            :              <D.1759>:
    2131                 :            :              <stmt>;
    2132                 :            :              goto <D.1761>;
    2133                 :            :              <D.1760>:
    2134                 :            :            */
    2135                 :       4488 :           if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_GOTO
    2136                 :       4670 :               && !gimple_has_location (gsi_stmt (*gsi_p)))
    2137                 :            :             {
    2138                 :            :               /* Look at the statement before, it might be
    2139                 :            :                  attribute fallthrough, in which case don't warn.  */
    2140                 :       1381 :               gsi_prev (gsi_p);
    2141                 :       1381 :               bool fallthru_before_dest
    2142                 :       1381 :                 = gimple_call_internal_p (gsi_stmt (*gsi_p), IFN_FALLTHROUGH);
    2143                 :       1381 :               gsi_next (gsi_p);
    2144                 :       1381 :               tree goto_dest = gimple_goto_dest (gsi_stmt (*gsi_p));
    2145                 :       1381 :               if (!fallthru_before_dest)
    2146                 :            :                 {
    2147                 :       1312 :                   struct label_entry l = { goto_dest, if_loc };
    2148                 :       1312 :                   labels->safe_push (l);
    2149                 :            :                 }
    2150                 :            :             }
    2151                 :            :           /* And move back.  */
    2152                 :       4488 :           gsi_next (gsi_p);
    2153                 :            :         }
    2154                 :            : 
    2155                 :            :       /* Remember the last statement.  Skip labels that are of no interest
    2156                 :            :          to us.  */
    2157                 :      64781 :       if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_LABEL)
    2158                 :            :         {
    2159                 :       6611 :           tree label = gimple_label_label (as_a <glabel *> (gsi_stmt (*gsi_p)));
    2160                 :      13222 :           if (find_label_entry (labels, label))
    2161                 :       5800 :             prev = gsi_stmt (*gsi_p);
    2162                 :            :         }
    2163                 :      58170 :       else if (gimple_call_internal_p (gsi_stmt (*gsi_p), IFN_ASAN_MARK))
    2164                 :            :         ;
    2165                 :      58170 :       else if (gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_PREDICT)
    2166                 :            :         ;
    2167                 :      57126 :       else if (!is_gimple_debug (gsi_stmt (*gsi_p)))
    2168                 :      42254 :         prev = gsi_stmt (*gsi_p);
    2169                 :      64781 :       gsi_next (gsi_p);
    2170                 :            :     }
    2171                 :      66195 :   while (!gsi_end_p (*gsi_p)
    2172                 :            :          /* Stop if we find a case or a user-defined label.  */
    2173                 :      66195 :          && (gimple_code (gsi_stmt (*gsi_p)) != GIMPLE_LABEL
    2174                 :      15652 :              || !gimple_has_location (gsi_stmt (*gsi_p))));
    2175                 :            : 
    2176                 :      29950 :   if (prev && gimple_has_location (prev))
    2177                 :      14511 :     *prevloc = gimple_location (prev);
    2178                 :      14979 :   return prev;
    2179                 :            : }
    2180                 :            : 
    2181                 :            : /* Return true if the switch fallthough warning should occur.  LABEL is
    2182                 :            :    the label statement that we're falling through to.  */
    2183                 :            : 
    2184                 :            : static bool
    2185                 :      13521 : should_warn_for_implicit_fallthrough (gimple_stmt_iterator *gsi_p, tree label)
    2186                 :            : {
    2187                 :      13521 :   gimple_stmt_iterator gsi = *gsi_p;
    2188                 :            : 
    2189                 :            :   /* Don't warn if the label is marked with a "falls through" comment.  */
    2190                 :      13521 :   if (FALLTHROUGH_LABEL_P (label))
    2191                 :            :     return false;
    2192                 :            : 
    2193                 :            :   /* Don't warn for non-case labels followed by a statement:
    2194                 :            :        case 0:
    2195                 :            :          foo ();
    2196                 :            :        label:
    2197                 :            :          bar ();
    2198                 :            :      as these are likely intentional.  */
    2199                 :      12488 :   if (!case_label_p (&gimplify_ctxp->case_labels, label))
    2200                 :            :     {
    2201                 :       2967 :       tree l;
    2202                 :       2967 :       while (!gsi_end_p (gsi)
    2203                 :       1668 :              && gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL
    2204                 :       1589 :              && (l = gimple_label_label (as_a <glabel *> (gsi_stmt (gsi))))
    2205                 :       1589 :              && !case_label_p (&gimplify_ctxp->case_labels, l))
    2206                 :       4498 :         gsi_next_nondebug (&gsi);
    2207                 :       1476 :       if (gsi_end_p (gsi) || gimple_code (gsi_stmt (gsi)) != GIMPLE_LABEL)
    2208                 :            :         return false;
    2209                 :            :     }
    2210                 :            : 
    2211                 :            :   /* Don't warn for terminated branches, i.e. when the subsequent case labels
    2212                 :            :      immediately breaks.  */
    2213                 :      11110 :   gsi = *gsi_p;
    2214                 :            : 
    2215                 :            :   /* Skip all immediately following labels.  */
    2216                 :      24810 :   while (!gsi_end_p (gsi)
    2217                 :      24728 :          && (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL
    2218                 :      11214 :              || gimple_code (gsi_stmt (gsi)) == GIMPLE_PREDICT))
    2219                 :      46637 :     gsi_next_nondebug (&gsi);
    2220                 :            : 
    2221                 :            :   /* { ... something; default:; } */
    2222                 :      11110 :   if (gsi_end_p (gsi)
    2223                 :            :       /* { ... something; default: break; } or
    2224                 :            :          { ... something; default: goto L; } */
    2225                 :      11028 :       || gimple_code (gsi_stmt (gsi)) == GIMPLE_GOTO
    2226                 :            :       /* { ... something; default: return; } */
    2227                 :      21487 :       || gimple_code (gsi_stmt (gsi)) == GIMPLE_RETURN)
    2228                 :        746 :     return false;
    2229                 :            : 
    2230                 :            :   return true;
    2231                 :            : }
    2232                 :            : 
    2233                 :            : /* Callback for walk_gimple_seq.  */
    2234                 :            : 
    2235                 :            : static tree
    2236                 :      17038 : warn_implicit_fallthrough_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
    2237                 :            :                              struct walk_stmt_info *)
    2238                 :            : {
    2239                 :      17038 :   gimple *stmt = gsi_stmt (*gsi_p);
    2240                 :            : 
    2241                 :      17038 :   *handled_ops_p = true;
    2242                 :      17038 :   switch (gimple_code (stmt))
    2243                 :            :     {
    2244                 :        228 :     case GIMPLE_TRY:
    2245                 :        228 :     case GIMPLE_BIND:
    2246                 :        228 :     case GIMPLE_CATCH:
    2247                 :        228 :     case GIMPLE_EH_FILTER:
    2248                 :        228 :     case GIMPLE_TRANSACTION:
    2249                 :            :       /* Walk the sub-statements.  */
    2250                 :        228 :       *handled_ops_p = false;
    2251                 :        228 :       break;
    2252                 :            : 
    2253                 :            :     /* Find a sequence of form:
    2254                 :            : 
    2255                 :            :        GIMPLE_LABEL
    2256                 :            :        [...]
    2257                 :            :        <may fallthru stmt>
    2258                 :            :        GIMPLE_LABEL
    2259                 :            : 
    2260                 :            :        and possibly warn.  */
    2261                 :      37433 :     case GIMPLE_LABEL:
    2262                 :      37433 :       {
    2263                 :            :         /* Found a label.  Skip all immediately following labels.  */
    2264                 :      37433 :         while (!gsi_end_p (*gsi_p)
    2265                 :      35956 :                && gimple_code (gsi_stmt (*gsi_p)) == GIMPLE_LABEL)
    2266                 :      68901 :           gsi_next_nondebug (gsi_p);
    2267                 :            : 
    2268                 :            :         /* There might be no more statements.  */
    2269                 :      16456 :         if (gsi_end_p (*gsi_p))
    2270                 :       1477 :           return integer_zero_node;
    2271                 :            : 
    2272                 :            :         /* Vector of labels that fall through.  */
    2273                 :      28508 :         auto_vec <struct label_entry> labels;
    2274                 :      14979 :         location_t prevloc;
    2275                 :      14979 :         gimple *prev = collect_fallthrough_labels (gsi_p, &labels, &prevloc);
    2276                 :            : 
    2277                 :            :         /* There might be no more statements.  */
    2278                 :      14979 :         if (gsi_end_p (*gsi_p))
    2279                 :       4377 :           return integer_zero_node;
    2280                 :            : 
    2281                 :      13529 :         gimple *next = gsi_stmt (*gsi_p);
    2282                 :      13529 :         tree label;
    2283                 :            :         /* If what follows is a label, then we may have a fallthrough.  */
    2284                 :      13529 :         if (gimple_code (next) == GIMPLE_LABEL
    2285                 :      13529 :             && gimple_has_location (next)
    2286                 :      13529 :             && (label = gimple_label_label (as_a <glabel *> (next)))
    2287                 :      27058 :             && prev != NULL)
    2288                 :            :           {
    2289                 :      13521 :             struct label_entry *l;
    2290                 :      13521 :             bool warned_p = false;
    2291                 :      13521 :             auto_diagnostic_group d;
    2292                 :      13521 :             if (!should_warn_for_implicit_fallthrough (gsi_p, label))
    2293                 :            :               /* Quiet.  */;
    2294                 :      10630 :             else if (gimple_code (prev) == GIMPLE_LABEL
    2295                 :        266 :                      && (label = gimple_label_label (as_a <glabel *> (prev)))
    2296                 :      10630 :                      && (l = find_label_entry (&labels, label)))
    2297                 :        241 :               warned_p = warning_at (l->loc, OPT_Wimplicit_fallthrough_,
    2298                 :            :                                      "this statement may fall through");
    2299                 :      10123 :             else if (!gimple_call_internal_p (prev, IFN_FALLTHROUGH)
    2300                 :            :                      /* Try to be clever and don't warn when the statement
    2301                 :            :                         can't actually fall through.  */
    2302                 :       9973 :                      && gimple_stmt_may_fallthru (prev)
    2303                 :      10463 :                      && prevloc != UNKNOWN_LOCATION)
    2304                 :        340 :               warned_p = warning_at (prevloc,
    2305                 :            :                                      OPT_Wimplicit_fallthrough_,
    2306                 :            :                                      "this statement may fall through");
    2307                 :        581 :             if (warned_p)
    2308                 :        581 :               inform (gimple_location (next), "here");
    2309                 :            : 
    2310                 :            :             /* Mark this label as processed so as to prevent multiple
    2311                 :            :                warnings in nested switches.  */
    2312                 :      13521 :             FALLTHROUGH_LABEL_P (label) = true;
    2313                 :            : 
    2314                 :            :             /* So that next warn_implicit_fallthrough_r will start looking for
    2315                 :            :                a new sequence starting with this label.  */
    2316                 :      27042 :             gsi_prev (gsi_p);
    2317                 :            :           }
    2318                 :            :       }
    2319                 :            :       break;
    2320                 :            :    default:
    2321                 :            :       break;
    2322                 :            :     }
    2323                 :            :   return NULL_TREE;
    2324                 :            : }
    2325                 :            : 
    2326                 :            : /* Warn when a switch case falls through.  */
    2327                 :            : 
    2328                 :            : static void
    2329                 :      33146 : maybe_warn_implicit_fallthrough (gimple_seq seq)
    2330                 :            : {
    2331                 :      33146 :   if (!warn_implicit_fallthrough)
    2332                 :      30295 :     return;
    2333                 :            : 
    2334                 :            :   /* This warning is meant for C/C++/ObjC/ObjC++ only.  */
    2335                 :       2851 :   if (!(lang_GNU_C ()
    2336                 :       1185 :         || lang_GNU_CXX ()
    2337                 :          0 :         || lang_GNU_OBJC ()))
    2338                 :            :     return;
    2339                 :            : 
    2340                 :       2851 :   struct walk_stmt_info wi;
    2341                 :       2851 :   memset (&wi, 0, sizeof (wi));
    2342                 :       2851 :   walk_gimple_seq (seq, warn_implicit_fallthrough_r, NULL, &wi);
    2343                 :            : }
    2344                 :            : 
    2345                 :            : /* Callback for walk_gimple_seq.  */
    2346                 :            : 
    2347                 :            : static tree
    2348                 :    2429970 : expand_FALLTHROUGH_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
    2349                 :            :                       struct walk_stmt_info *wi)
    2350                 :            : {
    2351                 :    2429970 :   gimple *stmt = gsi_stmt (*gsi_p);
    2352                 :            : 
    2353                 :    2429970 :   *handled_ops_p = true;
    2354                 :    2429970 :   switch (gimple_code (stmt))
    2355                 :            :     {
    2356                 :     121126 :     case GIMPLE_TRY:
    2357                 :     121126 :     case GIMPLE_BIND:
    2358                 :     121126 :     case GIMPLE_CATCH:
    2359                 :     121126 :     case GIMPLE_EH_FILTER:
    2360                 :     121126 :     case GIMPLE_TRANSACTION:
    2361                 :            :       /* Walk the sub-statements.  */
    2362                 :     121126 :       *handled_ops_p = false;
    2363                 :     121126 :       break;
    2364                 :     171424 :     case GIMPLE_CALL:
    2365                 :     171424 :       if (gimple_call_internal_p (stmt, IFN_FALLTHROUGH))
    2366                 :            :         {
    2367                 :        349 :           gsi_remove (gsi_p, true);
    2368                 :        349 :           if (gsi_end_p (*gsi_p))
    2369                 :            :             {
    2370                 :         33 :               *static_cast<location_t *>(wi->info) = gimple_location (stmt);
    2371                 :         33 :               return integer_zero_node;
    2372                 :            :             }
    2373                 :            : 
    2374                 :        316 :           bool found = false;
    2375                 :        316 :           location_t loc = gimple_location (stmt);
    2376                 :            : 
    2377                 :        316 :           gimple_stmt_iterator gsi2 = *gsi_p;
    2378                 :        316 :           stmt = gsi_stmt (gsi2);
    2379                 :        385 :           if (gimple_code (stmt) == GIMPLE_GOTO && !gimple_has_location (stmt))
    2380                 :            :             {
    2381                 :            :               /* Go on until the artificial label.  */
    2382                 :         69 :               tree goto_dest = gimple_goto_dest (stmt);
    2383                 :        437 :               for (; !gsi_end_p (gsi2); gsi_next (&gsi2))
    2384                 :            :                 {
    2385                 :        437 :                   if (gimple_code (gsi_stmt (gsi2)) == GIMPLE_LABEL
    2386                 :        437 :                       && gimple_label_label (as_a <glabel *> (gsi_stmt (gsi2)))
    2387                 :            :                            == goto_dest)
    2388                 :            :                     break;
    2389                 :            :                 }
    2390                 :            : 
    2391                 :            :               /* Not found?  Stop.  */
    2392                 :         69 :               if (gsi_end_p (gsi2))
    2393                 :            :                 break;
    2394                 :            : 
    2395                 :            :               /* Look one past it.  */
    2396                 :         69 :               gsi_next (&gsi2);
    2397                 :            :             }
    2398                 :            : 
    2399                 :            :           /* We're looking for a case label or default label here.  */
    2400                 :        415 :           while (!gsi_end_p (gsi2))
    2401                 :            :             {
    2402                 :        415 :               stmt = gsi_stmt (gsi2);
    2403                 :        415 :               if (gimple_code (stmt) == GIMPLE_LABEL)
    2404                 :            :                 {
    2405                 :        375 :                   tree label = gimple_label_label (as_a <glabel *> (stmt));
    2406                 :        687 :                   if (gimple_has_location (stmt) && DECL_ARTIFICIAL (label))
    2407                 :            :                     {
    2408                 :            :                       found = true;
    2409                 :            :                       break;
    2410                 :            :                     }
    2411                 :            :                 }
    2412                 :         40 :               else if (gimple_call_internal_p (stmt, IFN_ASAN_MARK))
    2413                 :            :                 ;
    2414                 :         40 :               else if (!is_gimple_debug (stmt))
    2415                 :            :                 /* Anything else is not expected.  */
    2416                 :            :                 break;
    2417                 :         99 :               gsi_next (&gsi2);
    2418                 :            :             }
    2419                 :        316 :           if (!found)
    2420                 :         24 :             pedwarn (loc, 0, "attribute %<fallthrough%> not preceding "
    2421                 :            :                      "a case label or default label");
    2422                 :            :         }
    2423                 :            :       break;
    2424                 :            :     default:
    2425                 :            :       break;
    2426                 :            :     }
    2427                 :            :   return NULL_TREE;
    2428                 :            : }
    2429                 :            : 
    2430                 :            : /* Expand all FALLTHROUGH () calls in SEQ.  */
    2431                 :            : 
    2432                 :            : static void
    2433                 :      31871 : expand_FALLTHROUGH (gimple_seq *seq_p)
    2434                 :            : {
    2435                 :      31871 :   struct walk_stmt_info wi;
    2436                 :      31871 :   location_t loc;
    2437                 :      31871 :   memset (&wi, 0, sizeof (wi));
    2438                 :      31871 :   wi.info = (void *) &loc;
    2439                 :      31871 :   walk_gimple_seq_mod (seq_p, expand_FALLTHROUGH_r, NULL, &wi);
    2440                 :      31871 :   if (wi.callback_result == integer_zero_node)
    2441                 :            :     /* We've found [[fallthrough]]; at the end of a switch, which the C++
    2442                 :            :        standard says is ill-formed; see [dcl.attr.fallthrough].  */
    2443                 :          6 :     pedwarn (loc, 0, "attribute %<fallthrough%> not preceding "
    2444                 :            :              "a case label or default label");
    2445                 :      31871 : }
    2446                 :            : 
    2447                 :            : 
    2448                 :            : /* Gimplify a SWITCH_EXPR, and collect the vector of labels it can
    2449                 :            :    branch to.  */
    2450                 :            : 
    2451                 :            : static enum gimplify_status
    2452                 :      33146 : gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
    2453                 :            : {
    2454                 :      33146 :   tree switch_expr = *expr_p;
    2455                 :      33146 :   gimple_seq switch_body_seq = NULL;
    2456                 :      33146 :   enum gimplify_status ret;
    2457                 :      33146 :   tree index_type = TREE_TYPE (switch_expr);
    2458                 :      33146 :   if (index_type == NULL_TREE)
    2459                 :       9398 :     index_type = TREE_TYPE (SWITCH_COND (switch_expr));
    2460                 :            : 
    2461                 :      33146 :   ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
    2462                 :            :                        fb_rvalue);
    2463                 :      33146 :   if (ret == GS_ERROR || ret == GS_UNHANDLED)
    2464                 :            :     return ret;
    2465                 :            : 
    2466                 :      33146 :   if (SWITCH_BODY (switch_expr))
    2467                 :            :     {
    2468                 :      33146 :       vec<tree> labels;
    2469                 :      33146 :       vec<tree> saved_labels;
    2470                 :      33146 :       hash_set<tree> *saved_live_switch_vars = NULL;
    2471                 :      33146 :       tree default_case = NULL_TREE;
    2472                 :      33146 :       gswitch *switch_stmt;
    2473                 :            : 
    2474                 :            :       /* Save old labels, get new ones from body, then restore the old
    2475                 :            :          labels.  Save all the things from the switch body to append after.  */
    2476                 :      33146 :       saved_labels = gimplify_ctxp->case_labels;
    2477                 :      33146 :       gimplify_ctxp->case_labels.create (8);
    2478                 :            : 
    2479                 :            :       /* Do not create live_switch_vars if SWITCH_BODY is not a BIND_EXPR.  */
    2480                 :      33146 :       saved_live_switch_vars = gimplify_ctxp->live_switch_vars;
    2481                 :      33146 :       tree_code body_type = TREE_CODE (SWITCH_BODY (switch_expr));
    2482                 :      33146 :       if (body_type == BIND_EXPR || body_type == STATEMENT_LIST)
    2483                 :      32856 :         gimplify_ctxp->live_switch_vars = new hash_set<tree> (4);
    2484                 :            :       else
    2485                 :        290 :         gimplify_ctxp->live_switch_vars = NULL;
    2486                 :            : 
    2487                 :      33146 :       bool old_in_switch_expr = gimplify_ctxp->in_switch_expr;
    2488                 :      33146 :       gimplify_ctxp->in_switch_expr = true;
    2489                 :            : 
    2490                 :      33146 :       gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
    2491                 :            : 
    2492                 :      33146 :       gimplify_ctxp->in_switch_expr = old_in_switch_expr;
    2493                 :      33146 :       maybe_warn_switch_unreachable (switch_body_seq);
    2494                 :      33146 :       maybe_warn_implicit_fallthrough (switch_body_seq);
    2495                 :            :       /* Only do this for the outermost GIMPLE_SWITCH.  */
    2496                 :      33146 :       if (!gimplify_ctxp->in_switch_expr)
    2497                 :      31871 :         expand_FALLTHROUGH (&switch_body_seq);
    2498                 :            : 
    2499                 :      33146 :       labels = gimplify_ctxp->case_labels;
    2500                 :      33146 :       gimplify_ctxp->case_labels = saved_labels;
    2501                 :            : 
    2502                 :      33146 :       if (gimplify_ctxp->live_switch_vars)
    2503                 :            :         {
    2504                 :      32856 :           gcc_assert (gimplify_ctxp->live_switch_vars->is_empty ());
    2505                 :      32856 :           delete gimplify_ctxp->live_switch_vars;
    2506                 :            :         }
    2507                 :      33146 :       gimplify_ctxp->live_switch_vars = saved_live_switch_vars;
    2508                 :            : 
    2509                 :      33146 :       preprocess_case_label_vec_for_gimple (labels, index_type,
    2510                 :            :                                             &default_case);
    2511                 :            : 
    2512                 :      33146 :       bool add_bind = false;
    2513                 :      33146 :       if (!default_case)
    2514                 :            :         {
    2515                 :      11532 :           glabel *new_default;
    2516                 :            : 
    2517                 :      11532 :           default_case
    2518                 :      11532 :             = build_case_label (NULL_TREE, NULL_TREE,
    2519                 :            :                                 create_artificial_label (UNKNOWN_LOCATION));
    2520                 :      11532 :           if (old_in_switch_expr)
    2521                 :            :             {
    2522                 :        553 :               SWITCH_BREAK_LABEL_P (CASE_LABEL (default_case)) = 1;
    2523                 :        553 :               add_bind = true;
    2524                 :            :             }
    2525                 :      11532 :           new_default = gimple_build_label (CASE_LABEL (default_case));
    2526                 :      11532 :           gimplify_seq_add_stmt (&switch_body_seq, new_default);
    2527                 :            :         }
    2528                 :      21614 :       else if (old_in_switch_expr)
    2529                 :            :         {
    2530                 :        722 :           gimple *last = gimple_seq_last_stmt (switch_body_seq);
    2531                 :        722 :           if (last && gimple_code (last) == GIMPLE_LABEL)
    2532                 :            :             {
    2533                 :        440 :               tree label = gimple_label_label (as_a <glabel *> (last));
    2534                 :        440 :               if (SWITCH_BREAK_LABEL_P (label))
    2535                 :        439 :                 add_bind = true;
    2536                 :            :             }
    2537                 :            :         }
    2538                 :            : 
    2539                 :      33146 :       switch_stmt = gimple_build_switch (SWITCH_COND (switch_expr),
    2540                 :            :                                          default_case, labels);
    2541                 :            :       /* For the benefit of -Wimplicit-fallthrough, if switch_body_seq
    2542                 :            :          ends with a GIMPLE_LABEL holding SWITCH_BREAK_LABEL_P LABEL_DECL,
    2543                 :            :          wrap the GIMPLE_SWITCH up to that GIMPLE_LABEL into a GIMPLE_BIND,
    2544                 :            :          so that we can easily find the start and end of the switch
    2545                 :            :          statement.  */
    2546                 :      33146 :       if (add_bind)
    2547                 :            :         {
    2548                 :        992 :           gimple_seq bind_body = NULL;
    2549                 :        992 :           gimplify_seq_add_stmt (&bind_body, switch_stmt);
    2550                 :        992 :           gimple_seq_add_seq (&bind_body, switch_body_seq);
    2551                 :        992 :           gbind *bind = gimple_build_bind (NULL_TREE, bind_body, NULL_TREE);
    2552                 :        992 :           gimple_set_location (bind, EXPR_LOCATION (switch_expr));
    2553                 :        992 :           gimplify_seq_add_stmt (pre_p, bind);
    2554                 :            :         }
    2555                 :            :       else
    2556                 :            :         {
    2557                 :      32154 :           gimplify_seq_add_stmt (pre_p, switch_stmt);
    2558                 :      32154 :           gimplify_seq_add_seq (pre_p, switch_body_seq);
    2559                 :            :         }
    2560                 :      33146 :       labels.release ();
    2561                 :            :     }
    2562                 :            :   else
    2563                 :          0 :     gcc_unreachable ();
    2564                 :            : 
    2565                 :      33146 :   return GS_ALL_DONE;
    2566                 :            : }
    2567                 :            : 
    2568                 :            : /* Gimplify the LABEL_EXPR pointed to by EXPR_P.  */
    2569                 :            : 
    2570                 :            : static enum gimplify_status
    2571                 :    1584990 : gimplify_label_expr (tree *expr_p, gimple_seq *pre_p)
    2572                 :            : {
    2573                 :    1584990 :   gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
    2574                 :            :               == current_function_decl);
    2575                 :            : 
    2576                 :    1584990 :   tree label = LABEL_EXPR_LABEL (*expr_p);
    2577                 :    1584990 :   glabel *label_stmt = gimple_build_label (label);
    2578                 :    1584990 :   gimple_set_location (label_stmt, EXPR_LOCATION (*expr_p));
    2579                 :    1584990 :   gimplify_seq_add_stmt (pre_p, label_stmt);
    2580                 :            : 
    2581                 :    1584990 :   if (lookup_attribute ("cold", DECL_ATTRIBUTES (label)))
    2582                 :          5 :     gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_COLD_LABEL,
    2583                 :            :                                                       NOT_TAKEN));
    2584                 :    1584980 :   else if (lookup_attribute ("hot", DECL_ATTRIBUTES (label)))
    2585                 :          4 :     gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_HOT_LABEL,
    2586                 :            :                                                       TAKEN));
    2587                 :            : 
    2588                 :    1584990 :   return GS_ALL_DONE;
    2589                 :            : }
    2590                 :            : 
    2591                 :            : /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P.  */
    2592                 :            : 
    2593                 :            : static enum gimplify_status
    2594                 :     900267 : gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
    2595                 :            : {
    2596                 :     900267 :   struct gimplify_ctx *ctxp;
    2597                 :     900267 :   glabel *label_stmt;
    2598                 :            : 
    2599                 :            :   /* Invalid programs can play Duff's Device type games with, for example,
    2600                 :            :      #pragma omp parallel.  At least in the C front end, we don't
    2601                 :            :      detect such invalid branches until after gimplification, in the
    2602                 :            :      diagnose_omp_blocks pass.  */
    2603                 :     900276 :   for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
    2604                 :     900276 :     if (ctxp->case_labels.exists ())
    2605                 :            :       break;
    2606                 :            : 
    2607                 :     900267 :   tree label = CASE_LABEL (*expr_p);
    2608                 :     900267 :   label_stmt = gimple_build_label (label);
    2609                 :     900267 :   gimple_set_location (label_stmt, EXPR_LOCATION (*expr_p));
    2610                 :     900267 :   ctxp->case_labels.safe_push (*expr_p);
    2611                 :     900267 :   gimplify_seq_add_stmt (pre_p, label_stmt);
    2612                 :            : 
    2613                 :     900267 :   if (lookup_attribute ("cold", DECL_ATTRIBUTES (label)))
    2614                 :          5 :     gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_COLD_LABEL,
    2615                 :            :                                                       NOT_TAKEN));
    2616                 :     900262 :   else if (lookup_attribute ("hot", DECL_ATTRIBUTES (label)))
    2617                 :          4 :     gimple_seq_add_stmt (pre_p, gimple_build_predict (PRED_HOT_LABEL,
    2618                 :            :                                                       TAKEN));
    2619                 :            : 
    2620                 :     900267 :   return GS_ALL_DONE;
    2621                 :            : }
    2622                 :            : 
    2623                 :            : /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
    2624                 :            :    if necessary.  */
    2625                 :            : 
    2626                 :            : tree
    2627                 :    2063000 : build_and_jump (tree *label_p)
    2628                 :            : {
    2629                 :    2063000 :   if (label_p == NULL)
    2630                 :            :     /* If there's nowhere to jump, just fall through.  */
    2631                 :            :     return NULL_TREE;
    2632                 :            : 
    2633                 :    1636300 :   if (*label_p == NULL_TREE)
    2634                 :            :     {
    2635                 :    1240290 :       tree label = create_artificial_label (UNKNOWN_LOCATION);
    2636                 :    1240290 :       *label_p = label;
    2637                 :            :     }
    2638                 :            : 
    2639                 :    1636300 :   return build1 (GOTO_EXPR, void_type_node, *label_p);
    2640                 :            : }
    2641                 :            : 
    2642                 :            : /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
    2643                 :            :    This also involves building a label to jump to and communicating it to
    2644                 :            :    gimplify_loop_expr through gimplify_ctxp->exit_label.  */
    2645                 :            : 
    2646                 :            : static enum gimplify_status
    2647                 :       2382 : gimplify_exit_expr (tree *expr_p)
    2648                 :            : {
    2649                 :       2382 :   tree cond = TREE_OPERAND (*expr_p, 0);
    2650                 :       2382 :   tree expr;
    2651                 :            : 
    2652                 :       2382 :   expr = build_and_jump (&gimplify_ctxp->exit_label);
    2653                 :       2382 :   expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
    2654                 :       2382 :   *expr_p = expr;
    2655                 :            : 
    2656                 :       2382 :   return GS_OK;
    2657                 :            : }
    2658                 :            : 
    2659                 :            : /* *EXPR_P is a COMPONENT_REF being used as an rvalue.  If its type is
    2660                 :            :    different from its canonical type, wrap the whole thing inside a
    2661                 :            :    NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
    2662                 :            :    type.
    2663                 :            : 
    2664                 :            :    The canonical type of a COMPONENT_REF is the type of the field being
    2665                 :            :    referenced--unless the field is a bit-field which can be read directly
    2666                 :            :    in a smaller mode, in which case the canonical type is the
    2667                 :            :    sign-appropriate type corresponding to that mode.  */
    2668                 :            : 
    2669                 :            : static void
    2670                 :   11587500 : canonicalize_component_ref (tree *expr_p)
    2671                 :            : {
    2672                 :   11587500 :   tree expr = *expr_p;
    2673                 :   11587500 :   tree type;
    2674                 :            : 
    2675                 :   11587500 :   gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
    2676                 :            : 
    2677                 :   11587500 :   if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
    2678                 :    4211930 :     type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
    2679                 :            :   else
    2680                 :    7375600 :     type = TREE_TYPE (TREE_OPERAND (expr, 1));
    2681                 :            : 
    2682                 :            :   /* One could argue that all the stuff below is not necessary for
    2683                 :            :      the non-bitfield case and declare it a FE error if type
    2684                 :            :      adjustment would be needed.  */
    2685                 :   11587500 :   if (TREE_TYPE (expr) != type)
    2686                 :            :     {
    2687                 :            : #ifdef ENABLE_TYPES_CHECKING
    2688                 :     419708 :       tree old_type = TREE_TYPE (expr);
    2689                 :            : #endif
    2690                 :     419708 :       int type_quals;
    2691                 :            : 
    2692                 :            :       /* We need to preserve qualifiers and propagate them from
    2693                 :            :          operand 0.  */
    2694                 :     419708 :       type_quals = TYPE_QUALS (type)
    2695                 :     419708 :         | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
    2696                 :     419708 :       if (TYPE_QUALS (type) != type_quals)
    2697                 :     419667 :         type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
    2698                 :            : 
    2699                 :            :       /* Set the type of the COMPONENT_REF to the underlying type.  */
    2700                 :     419708 :       TREE_TYPE (expr) = type;
    2701                 :            : 
    2702                 :            : #ifdef ENABLE_TYPES_CHECKING
    2703                 :            :       /* It is now a FE error, if the conversion from the canonical
    2704                 :            :          type to the original expression type is not useless.  */
    2705                 :     419708 :       gcc_assert (useless_type_conversion_p (old_type, type));
    2706                 :            : #endif
    2707                 :            :     }
    2708                 :   11587500 : }
    2709                 :            : 
    2710                 :            : /* If a NOP conversion is changing a pointer to array of foo to a pointer
    2711                 :            :    to foo, embed that change in the ADDR_EXPR by converting
    2712                 :            :       T array[U];
    2713                 :            :       (T *)&array
    2714                 :            :    ==>
    2715                 :            :       &array[L]
    2716                 :            :    where L is the lower bound.  For simplicity, only do this for constant
    2717                 :            :    lower bound.
    2718                 :            :    The constraint is that the type of &array[L] is trivially convertible
    2719                 :            :    to T *.  */
    2720                 :            : 
    2721                 :            : static void
    2722                 :     207619 : canonicalize_addr_expr (tree *expr_p)
    2723                 :            : {
    2724                 :     207619 :   tree expr = *expr_p;
    2725                 :     207619 :   tree addr_expr = TREE_OPERAND (expr, 0);
    2726                 :     207619 :   tree datype, ddatype, pddatype;
    2727                 :            : 
    2728                 :            :   /* We simplify only conversions from an ADDR_EXPR to a pointer type.  */
    2729                 :     414933 :   if (!POINTER_TYPE_P (TREE_TYPE (expr))
    2730                 :     207619 :       || TREE_CODE (addr_expr) != ADDR_EXPR)
    2731                 :            :     return;
    2732                 :            : 
    2733                 :            :   /* The addr_expr type should be a pointer to an array.  */
    2734                 :        305 :   datype = TREE_TYPE (TREE_TYPE (addr_expr));
    2735                 :        305 :   if (TREE_CODE (datype) != ARRAY_TYPE)
    2736                 :            :     return;
    2737                 :            : 
    2738                 :            :   /* The pointer to element type shall be trivially convertible to
    2739                 :            :      the expression pointer type.  */
    2740                 :         23 :   ddatype = TREE_TYPE (datype);
    2741                 :         23 :   pddatype = build_pointer_type (ddatype);
    2742                 :         23 :   if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
    2743                 :            :                                   pddatype))
    2744                 :            :     return;
    2745                 :            : 
    2746                 :            :   /* The lower bound and element sizes must be constant.  */
    2747                 :          0 :   if (!TYPE_SIZE_UNIT (ddatype)
    2748                 :          0 :       || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
    2749                 :          0 :       || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
    2750                 :          0 :       || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
    2751                 :            :     return;
    2752                 :            : 
    2753                 :            :   /* All checks succeeded.  Build a new node to merge the cast.  */
    2754                 :          0 :   *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
    2755                 :          0 :                     TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
    2756                 :            :                     NULL_TREE, NULL_TREE);
    2757                 :          0 :   *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
    2758                 :            : 
    2759                 :            :   /* We can have stripped a required restrict qualifier above.  */
    2760                 :          0 :   if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
    2761                 :          0 :     *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
    2762                 :            : }
    2763                 :            : 
    2764                 :            : /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR.  Remove it and/or other conversions
    2765                 :            :    underneath as appropriate.  */
    2766                 :            : 
    2767                 :            : static enum gimplify_status
    2768                 :    8240440 : gimplify_conversion (tree *expr_p)
    2769                 :            : {
    2770                 :    8240440 :   location_t loc = EXPR_LOCATION (*expr_p);
    2771                 :    8240440 :   gcc_assert (CONVERT_EXPR_P (*expr_p));
    2772                 :            : 
    2773                 :            :   /* Then strip away all but the outermost conversion.  */
    2774                 :    8240440 :   STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
    2775                 :            : 
    2776                 :            :   /* And remove the outermost conversion if it's useless.  */
    2777                 :    8240440 :   if (tree_ssa_useless_type_conversion (*expr_p))
    2778                 :          0 :     *expr_p = TREE_OPERAND (*expr_p, 0);
    2779                 :            : 
    2780                 :            :   /* If we still have a conversion at the toplevel,
    2781                 :            :      then canonicalize some constructs.  */
    2782                 :    8240440 :   if (CONVERT_EXPR_P (*expr_p))
    2783                 :            :     {
    2784                 :    8240440 :       tree sub = TREE_OPERAND (*expr_p, 0);
    2785                 :            : 
    2786                 :            :       /* If a NOP conversion is changing the type of a COMPONENT_REF
    2787                 :            :          expression, then canonicalize its type now in order to expose more
    2788                 :            :          redundant conversions.  */
    2789                 :    8240440 :       if (TREE_CODE (sub) == COMPONENT_REF)
    2790                 :     167174 :         canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
    2791                 :            : 
    2792                 :            :       /* If a NOP conversion is changing a pointer to array of foo
    2793                 :            :          to a pointer to foo, embed that change in the ADDR_EXPR.  */
    2794                 :    8073260 :       else if (TREE_CODE (sub) == ADDR_EXPR)
    2795                 :     207619 :         canonicalize_addr_expr (expr_p);
    2796                 :            :     }
    2797                 :            : 
    2798                 :            :   /* If we have a conversion to a non-register type force the
    2799                 :            :      use of a VIEW_CONVERT_EXPR instead.  */
    2800                 :    8240440 :   if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
    2801                 :        163 :     *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
    2802                 :        163 :                                TREE_OPERAND (*expr_p, 0));
    2803                 :            : 
    2804                 :            :   /* Canonicalize CONVERT_EXPR to NOP_EXPR.  */
    2805                 :    8240440 :   if (TREE_CODE (*expr_p) == CONVERT_EXPR)
    2806                 :     145762 :     TREE_SET_CODE (*expr_p, NOP_EXPR);
    2807                 :            : 
    2808                 :    8240440 :   return GS_OK;
    2809                 :            : }
    2810                 :            : 
    2811                 :            : /* Gimplify a VAR_DECL or PARM_DECL.  Return GS_OK if we expanded a
    2812                 :            :    DECL_VALUE_EXPR, and it's worth re-examining things.  */
    2813                 :            : 
    2814                 :            : static enum gimplify_status
    2815                 :   80487500 : gimplify_var_or_parm_decl (tree *expr_p)
    2816                 :            : {
    2817                 :   80487500 :   tree decl = *expr_p;
    2818                 :            : 
    2819                 :            :   /* ??? If this is a local variable, and it has not been seen in any
    2820                 :            :      outer BIND_EXPR, then it's probably the result of a duplicate
    2821                 :            :      declaration, for which we've already issued an error.  It would
    2822                 :            :      be really nice if the front end wouldn't leak these at all.
    2823                 :            :      Currently the only known culprit is C++ destructors, as seen
    2824                 :            :      in g++.old-deja/g++.jason/binding.C.  */
    2825                 :   80487500 :   if (VAR_P (decl)
    2826                 :   63842800 :       && !DECL_SEEN_IN_BIND_EXPR_P (decl)
    2827                 :   15386200 :       && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
    2828                 :   80634200 :       && decl_function_context (decl) == current_function_decl)
    2829                 :            :     {
    2830                 :          2 :       gcc_assert (seen_error ());
    2831                 :            :       return GS_ERROR;
    2832                 :            :     }
    2833                 :            : 
    2834                 :            :   /* When within an OMP context, notice uses of variables.  */
    2835                 :   80487500 :   if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
    2836                 :            :     return GS_ALL_DONE;
    2837                 :            : 
    2838                 :            :   /* If the decl is an alias for another expression, substitute it now.  */
    2839                 :   97126700 :   if (DECL_HAS_VALUE_EXPR_P (decl))
    2840                 :            :     {
    2841                 :     210413 :       *expr_p = unshare_expr (DECL_VALUE_EXPR (decl));
    2842                 :     210413 :       return GS_OK;
    2843                 :            :     }
    2844                 :            : 
    2845                 :            :   return GS_ALL_DONE;
    2846                 :            : }
    2847                 :            : 
    2848                 :            : /* Recalculate the value of the TREE_SIDE_EFFECTS flag for T.  */
    2849                 :            : 
    2850                 :            : static void
    2851                 :   70689600 : recalculate_side_effects (tree t)
    2852                 :            : {
    2853                 :   70689600 :   enum tree_code code = TREE_CODE (t);
    2854                 :   70689600 :   int len = TREE_OPERAND_LENGTH (t);
    2855                 :   70689600 :   int i;
    2856                 :            : 
    2857                 :   70689600 :   switch (TREE_CODE_CLASS (code))
    2858                 :            :     {
    2859                 :     433413 :     case tcc_expression:
    2860                 :     433413 :       switch (code)
    2861                 :            :         {
    2862                 :            :         case INIT_EXPR:
    2863                 :            :         case MODIFY_EXPR:
    2864                 :            :         case VA_ARG_EXPR:
    2865                 :            :         case PREDECREMENT_EXPR:
    2866                 :            :         case PREINCREMENT_EXPR:
    2867                 :            :         case POSTDECREMENT_EXPR:
    2868                 :            :         case POSTINCREMENT_EXPR:
    2869                 :            :           /* All of these have side-effects, no matter what their
    2870                 :            :              operands are.  */
    2871                 :            :           return;
    2872                 :            : 
    2873                 :            :         default:
    2874                 :            :           break;
    2875                 :            :         }
    2876                 :            :       /* Fall through.  */
    2877                 :            : 
    2878                 :   70689600 :     case tcc_comparison:  /* a comparison expression */
    2879                 :   70689600 :     case tcc_unary:       /* a unary arithmetic expression */
    2880                 :   70689600 :     case tcc_binary:      /* a binary arithmetic expression */
    2881                 :   70689600 :     case tcc_reference:   /* a reference */
    2882                 :   70689600 :     case tcc_vl_exp:        /* a function call */
    2883                 :   70689600 :       TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
    2884                 :  228470000 :       for (i = 0; i < len; ++i)
    2885                 :            :         {
    2886                 :  157781000 :           tree op = TREE_OPERAND (t, i);
    2887                 :  284826000 :           if (op && TREE_SIDE_EFFECTS (op))
    2888                 :     908611 :             TREE_SIDE_EFFECTS (t) = 1;
    2889                 :            :         }
    2890                 :            :       break;
    2891                 :            : 
    2892                 :            :     case tcc_constant:
    2893                 :            :       /* No side-effects.  */
    2894                 :            :       return;
    2895                 :            : 
    2896                 :          0 :     default:
    2897                 :          0 :       gcc_unreachable ();
    2898                 :            :    }
    2899                 :            : }
    2900                 :            : 
    2901                 :            : /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
    2902                 :            :    node *EXPR_P.
    2903                 :            : 
    2904                 :            :       compound_lval
    2905                 :            :               : min_lval '[' val ']'
    2906                 :            :               | min_lval '.' ID
    2907                 :            :               | compound_lval '[' val ']'
    2908                 :            :               | compound_lval '.' ID
    2909                 :            : 
    2910                 :            :    This is not part of the original SIMPLE definition, which separates
    2911                 :            :    array and member references, but it seems reasonable to handle them
    2912                 :            :    together.  Also, this way we don't run into problems with union
    2913                 :            :    aliasing; gcc requires that for accesses through a union to alias, the
    2914                 :            :    union reference must be explicit, which was not always the case when we
    2915                 :            :    were splitting up array and member refs.
    2916                 :            : 
    2917                 :            :    PRE_P points to the sequence where side effects that must happen before
    2918                 :            :      *EXPR_P should be stored.
    2919                 :            : 
    2920                 :            :    POST_P points to the sequence where side effects that must happen after
    2921                 :            :      *EXPR_P should be stored.  */
    2922                 :            : 
    2923                 :            : static enum gimplify_status
    2924                 :   19533500 : gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
    2925                 :            :                         fallback_t fallback)
    2926                 :            : {
    2927                 :   19533500 :   tree *p;
    2928                 :   19533500 :   enum gimplify_status ret = GS_ALL_DONE, tret;
    2929                 :   19533500 :   int i;
    2930                 :   19533500 :   location_t loc = EXPR_LOCATION (*expr_p);
    2931                 :   19533500 :   tree expr = *expr_p;
    2932                 :            : 
    2933                 :            :   /* Create a stack of the subexpressions so later we can walk them in
    2934                 :            :      order from inner to outer.  */
    2935                 :   19533500 :   auto_vec<tree, 10> expr_stack;
    2936                 :            : 
    2937                 :            :   /* We can handle anything that get_inner_reference can deal with.  */
    2938                 :   46011100 :   for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
    2939                 :            :     {
    2940                 :   26477600 :     restart:
    2941                 :            :       /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs.  */
    2942                 :   46054200 :       if (TREE_CODE (*p) == INDIRECT_REF)
    2943                 :    2625220 :         *p = fold_indirect_ref_loc (loc, *p);
    2944                 :            : 
    2945                 :   46054200 :       if (handled_component_p (*p))
    2946                 :            :         ;
    2947                 :            :       /* Expand DECL_VALUE_EXPR now.  In some cases that may expose
    2948                 :            :          additional COMPONENT_REFs.  */
    2949                 :    8587900 :       else if ((VAR_P (*p) || TREE_CODE (*p) == PARM_DECL)
    2950                 :   20351000 :                && gimplify_var_or_parm_decl (p) == GS_OK)
    2951                 :      43126 :         goto restart;
    2952                 :            :       else
    2953                 :            :         break;
    2954                 :            : 
    2955                 :   26477600 :       expr_stack.safe_push (*p);
    2956                 :            :     }
    2957                 :            : 
    2958                 :   19533500 :   gcc_assert (expr_stack.length ());
    2959                 :            : 
    2960                 :            :   /* Now EXPR_STACK is a stack of pointers to all the refs we've
    2961                 :            :      walked through and P points to the innermost expression.
    2962                 :            : 
    2963                 :            :      Java requires that we elaborated nodes in source order.  That
    2964                 :            :      means we must gimplify the inner expression followed by each of
    2965                 :            :      the indices, in order.  But we can't gimplify the inner
    2966                 :            :      expression until we deal with any variable bounds, sizes, or
    2967                 :            :      positions in order to deal with PLACEHOLDER_EXPRs.
    2968                 :            : 
    2969                 :            :      So we do this in three steps.  First we deal with the annotations
    2970                 :            :      for any variables in the components, then we gimplify the base,
    2971                 :            :      then we gimplify any indices, from left to right.  */
    2972                 :   46011100 :   for (i = expr_stack.length () - 1; i >= 0; i--)
    2973                 :            :     {
    2974                 :   26477600 :       tree t = expr_stack[i];
    2975                 :            : 
    2976                 :   26477600 :       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
    2977                 :            :         {
    2978                 :            :           /* Gimplify the low bound and element type size and put them into
    2979                 :            :              the ARRAY_REF.  If these values are set, they have already been
    2980                 :            :              gimplified.  */
    2981                 :    5409360 :           if (TREE_OPERAND (t, 2) == NULL_TREE)
    2982                 :            :             {
    2983                 :    5409360 :               tree low = unshare_expr (array_ref_low_bound (t));
    2984                 :    5409360 :               if (!is_gimple_min_invariant (low))
    2985                 :            :                 {
    2986                 :          0 :                   TREE_OPERAND (t, 2) = low;
    2987                 :          0 :                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
    2988                 :            :                                         post_p, is_gimple_reg,
    2989                 :            :                                         fb_rvalue);
    2990                 :          0 :                   ret = MIN (ret, tret);
    2991                 :            :                 }
    2992                 :            :             }
    2993                 :            :           else
    2994                 :            :             {
    2995                 :          0 :               tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
    2996                 :            :                                     is_gimple_reg, fb_rvalue);
    2997                 :          0 :               ret = MIN (ret, tret);
    2998                 :            :             }
    2999                 :            : 
    3000                 :    5409360 :           if (TREE_OPERAND (t, 3) == NULL_TREE)
    3001                 :            :             {
    3002                 :    5381240 :               tree elmt_size = array_ref_element_size (t);
    3003                 :    5381240 :               if (!is_gimple_min_invariant (elmt_size))
    3004                 :            :                 {
    3005                 :      12344 :                   elmt_size = unshare_expr (elmt_size);
    3006                 :      12344 :                   tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
    3007                 :      12344 :                   tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
    3008                 :            : 
    3009                 :            :                   /* Divide the element size by the alignment of the element
    3010                 :            :                      type (above).  */
    3011                 :      12344 :                   elmt_size = size_binop_loc (loc, EXACT_DIV_EXPR,
    3012                 :            :                                               elmt_size, factor);
    3013                 :            : 
    3014                 :      12344 :                   TREE_OPERAND (t, 3) = elmt_size;
    3015                 :      12344 :                   tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
    3016                 :            :                                         post_p, is_gimple_reg,
    3017                 :            :                                         fb_rvalue);
    3018                 :      12344 :                   ret = MIN (ret, tret);
    3019                 :            :                 }
    3020                 :            :             }
    3021                 :            :           else
    3022                 :            :             {
    3023                 :      28117 :               tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
    3024                 :            :                                     is_gimple_reg, fb_rvalue);
    3025                 :      28117 :               ret = MIN (ret, tret);
    3026                 :            :             }
    3027                 :            :         }
    3028                 :   21068300 :       else if (TREE_CODE (t) == COMPONENT_REF)
    3029                 :            :         {
    3030                 :            :           /* Set the field offset into T and gimplify it.  */
    3031                 :   19958300 :           if (TREE_OPERAND (t, 2) == NULL_TREE)
    3032                 :            :             {
    3033                 :   19958000 :               tree offset = component_ref_field_offset (t);
    3034                 :   19958000 :               if (!is_gimple_min_invariant (offset))
    3035                 :            :                 {
    3036                 :        252 :                   offset = unshare_expr (offset);
    3037                 :        252 :                   tree field = TREE_OPERAND (t, 1);
    3038                 :        252 :                   tree factor
    3039                 :        252 :                     = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
    3040                 :            : 
    3041                 :            :                   /* Divide the offset by its alignment.  */
    3042                 :        252 :                   offset = size_binop_loc (loc, EXACT_DIV_EXPR,
    3043                 :            :                                            offset, factor);
    3044                 :            : 
    3045                 :        252 :                   TREE_OPERAND (t, 2) = offset;
    3046                 :        252 :                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
    3047                 :            :                                         post_p, is_gimple_reg,
    3048                 :            :                                         fb_rvalue);
    3049                 :        252 :                   ret = MIN (ret, tret);
    3050                 :            :                 }
    3051                 :            :             }
    3052                 :            :           else
    3053                 :            :             {
    3054                 :        326 :               tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
    3055                 :            :                                     is_gimple_reg, fb_rvalue);
    3056                 :        326 :               ret = MIN (ret, tret);
    3057                 :            :             }
    3058                 :            :         }
    3059                 :            :     }
    3060                 :            : 
    3061                 :            :   /* Step 2 is to gimplify the base expression.  Make sure lvalue is set
    3062                 :            :      so as to match the min_lval predicate.  Failure to do so may result
    3063                 :            :      in the creation of large aggregate temporaries.  */
    3064                 :   19533500 :   tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
    3065                 :            :                         fallback | fb_lvalue);
    3066                 :   19533500 :   ret = MIN (ret, tret);
    3067                 :            : 
    3068                 :            :   /* And finally, the indices and operands of ARRAY_REF.  During this
    3069                 :            :      loop we also remove any useless conversions.  */
    3070                 :   46011100 :   for (; expr_stack.length () > 0; )
    3071                 :            :     {
    3072                 :   26477600 :       tree t = expr_stack.pop ();
    3073                 :            : 
    3074                 :   26477600 :       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
    3075                 :            :         {
    3076                 :            :           /* Gimplify the dimension.  */
    3077                 :    5409360 :           if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
    3078                 :            :             {
    3079                 :    1713440 :               tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
    3080                 :            :                                     is_gimple_val, fb_rvalue);
    3081                 :    1713440 :               ret = MIN (ret, tret);
    3082                 :            :             }
    3083                 :            :         }
    3084                 :            : 
    3085                 :   26477600 :       STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
    3086                 :            : 
    3087                 :            :       /* The innermost expression P may have originally had
    3088                 :            :          TREE_SIDE_EFFECTS set which would have caused all the outer
    3089                 :            :          expressions in *EXPR_P leading to P to also have had
    3090                 :            :          TREE_SIDE_EFFECTS set.  */
    3091                 :   26477600 :       recalculate_side_effects (t);
    3092                 :            :     }
    3093                 :            : 
    3094                 :            :   /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
    3095                 :   19533500 :   if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
    3096                 :            :     {
    3097                 :   11420400 :       canonicalize_component_ref (expr_p);
    3098                 :            :     }
    3099                 :            : 
    3100                 :   19533500 :   expr_stack.release ();
    3101                 :            : 
    3102                 :   19533500 :   gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
    3103                 :            : 
    3104                 :   19533500 :   return ret;
    3105                 :            : }
    3106                 :            : 
    3107                 :            : /*  Gimplify the self modifying expression pointed to by EXPR_P
    3108                 :            :     (++, --, +=, -=).
    3109                 :            : 
    3110                 :            :     PRE_P points to the list where side effects that must happen before
    3111                 :            :         *EXPR_P should be stored.
    3112                 :            : 
    3113                 :            :     POST_P points to the list where side effects that must happen after
    3114                 :            :         *EXPR_P should be stored.
    3115                 :            : 
    3116                 :            :     WANT_VALUE is nonzero iff we want to use the value of this expression
    3117                 :            :         in another expression.
    3118                 :            : 
    3119                 :            :     ARITH_TYPE is the type the computation should be performed in.  */
    3120                 :            : 
    3121                 :            : enum gimplify_status
    3122                 :     664762 : gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
    3123                 :            :                         bool want_value, tree arith_type)
    3124                 :            : {
    3125                 :     664762 :   enum tree_code code;
    3126                 :     664762 :   tree lhs, lvalue, rhs, t1;
    3127                 :     664762 :   gimple_seq post = NULL, *orig_post_p = post_p;
    3128                 :     664762 :   bool postfix;
    3129                 :     664762 :   enum tree_code arith_code;
    3130                 :     664762 :   enum gimplify_status ret;
    3131                 :     664762 :   location_t loc = EXPR_LOCATION (*expr_p);
    3132                 :            : 
    3133                 :     664762 :   code = TREE_CODE (*expr_p);
    3134                 :            : 
    3135                 :     664762 :   gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
    3136                 :            :               || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
    3137                 :            : 
    3138                 :            :   /* Prefix or postfix?  */
    3139                 :     664762 :   if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
    3140                 :            :     /* Faster to treat as prefix if result is not used.  */
    3141                 :            :     postfix = want_value;
    3142                 :            :   else
    3143                 :            :     postfix = false;
    3144                 :            : 
    3145                 :            :   /* For postfix, make sure the inner expression's post side effects
    3146                 :            :      are executed after side effects from this expression.  */
    3147                 :     187506 :   if (postfix)
    3148                 :      36714 :     post_p = &post;
    3149                 :            : 
    3150                 :            :   /* Add or subtract?  */
    3151                 :     664762 :   if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
    3152                 :            :     arith_code = PLUS_EXPR;
    3153                 :            :   else
    3154                 :      32323 :     arith_code = MINUS_EXPR;
    3155                 :            : 
    3156                 :            :   /* Gimplify the LHS into a GIMPLE lvalue.  */
    3157                 :     664762 :   lvalue = TREE_OPERAND (*expr_p, 0);
    3158                 :     664762 :   ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
    3159                 :     664762 :   if (ret == GS_ERROR)
    3160                 :            :     return ret;
    3161                 :            : 
    3162                 :            :   /* Extract the operands to the arithmetic operation.  */
    3163                 :     664762 :   lhs = lvalue;
    3164                 :     664762 :   rhs = TREE_OPERAND (*expr_p, 1);
    3165                 :            : 
    3166                 :            :   /* For postfix operator, we evaluate the LHS to an rvalue and then use
    3167                 :            :      that as the result value and in the postqueue operation.  */
    3168                 :     664762 :   if (postfix)
    3169                 :            :     {
    3170                 :      36714 :       ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
    3171                 :      36714 :       if (ret == GS_ERROR)
    3172                 :            :         return ret;
    3173                 :            : 
    3174                 :      36714 :       lhs = get_initialized_tmp_var (lhs, pre_p);
    3175                 :            :     }
    3176                 :            : 
    3177                 :            :   /* For POINTERs increment, use POINTER_PLUS_EXPR.  */
    3178                 :     664762 :   if (POINTER_TYPE_P (TREE_TYPE (lhs)))
    3179                 :            :     {
    3180                 :      58985 :       rhs = convert_to_ptrofftype_loc (loc, rhs);
    3181                 :      58985 :       if (arith_code == MINUS_EXPR)
    3182                 :       4953 :         rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
    3183                 :      58985 :       t1 = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (*expr_p), lhs, rhs);
    3184                 :            :     }
    3185                 :            :   else
    3186                 :     605777 :     t1 = fold_convert (TREE_TYPE (*expr_p),
    3187                 :            :                        fold_build2 (arith_code, arith_type,
    3188                 :            :                                     fold_convert (arith_type, lhs),
    3189                 :            :                                     fold_convert (arith_type, rhs)));
    3190                 :            : 
    3191                 :     664762 :   if (postfix)
    3192                 :            :     {
    3193                 :      36714 :       gimplify_assign (lvalue, t1, pre_p);
    3194                 :      36714 :       gimplify_seq_add_seq (orig_post_p, post);
    3195                 :      36714 :       *expr_p = lhs;
    3196                 :      36714 :       return GS_ALL_DONE;
    3197                 :            :     }
    3198                 :            :   else
    3199                 :            :     {
    3200                 :     628048 :       *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
    3201                 :     628048 :       return GS_OK;
    3202                 :            :     }
    3203                 :            : }
    3204                 :            : 
    3205                 :            : /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR.  */
    3206                 :            : 
    3207                 :            : static void
    3208                 :   50897200 : maybe_with_size_expr (tree *expr_p)
    3209                 :            : {
    3210                 :   50897200 :   tree expr = *expr_p;
    3211                 :   50897200 :   tree type = TREE_TYPE (expr);
    3212                 :   50897200 :   tree size;
    3213                 :            : 
    3214                 :            :   /* If we've already wrapped this or the type is error_mark_node, we can't do
    3215                 :            :      anything.  */
    3216                 :   50897200 :   if (TREE_CODE (expr) == WITH_SIZE_EXPR
    3217                 :   50897000 :       || type == error_mark_node)
    3218                 :            :     return;
    3219                 :            : 
    3220                 :            :   /* If the size isn't known or is a constant, we have nothing to do.  */
    3221                 :   50897000 :   size = TYPE_SIZE_UNIT (type);
    3222                 :   50897000 :   if (!size || poly_int_tree_p (size))
    3223                 :            :     return;
    3224                 :            : 
    3225                 :            :   /* Otherwise, make a WITH_SIZE_EXPR.  */
    3226                 :       1331 :   size = unshare_expr (size);
    3227                 :       2662 :   size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
    3228                 :       1331 :   *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
    3229                 :            : }
    3230                 :            : 
    3231                 :            : /* Helper for gimplify_call_expr.  Gimplify a single argument *ARG_P
    3232                 :            :    Store any side-effects in PRE_P.  CALL_LOCATION is the location of
    3233                 :            :    the CALL_EXPR.  If ALLOW_SSA is set the actual parameter may be
    3234                 :            :    gimplified to an SSA name.  */
    3235                 :            : 
    3236                 :            : enum gimplify_status
    3237                 :   20333600 : gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location,
    3238                 :            :               bool allow_ssa)
    3239                 :            : {
    3240                 :   20333600 :   bool (*test) (tree);
    3241                 :   20333600 :   fallback_t fb;
    3242                 :            : 
    3243                 :            :   /* In general, we allow lvalues for function arguments to avoid
    3244                 :            :      extra overhead of copying large aggregates out of even larger
    3245                 :            :      aggregates into temporaries only to copy the temporaries to
    3246                 :            :      the argument list.  Make optimizers happy by pulling out to
    3247                 :            :      temporaries those types that fit in registers.  */
    3248                 :   20333600 :   if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
    3249                 :            :     test = is_gimple_val, fb = fb_rvalue;
    3250                 :            :   else
    3251                 :            :     {
    3252                 :    1053340 :       test = is_gimple_lvalue, fb = fb_either;
    3253                 :            :       /* Also strip a TARGET_EXPR that would force an extra copy.  */
    3254                 :    1053340 :       if (TREE_CODE (*arg_p) == TARGET_EXPR)
    3255                 :            :         {
    3256                 :     139802 :           tree init = TARGET_EXPR_INITIAL (*arg_p);
    3257                 :     139802 :           if (init
    3258                 :     279604 :               && !VOID_TYPE_P (TREE_TYPE (init)))
    3259                 :     127541 :             *arg_p = init;
    3260                 :            :         }
    3261                 :            :     }
    3262                 :            : 
    3263                 :            :   /* If this is a variable sized type, we must remember the size.  */
    3264                 :   20333600 :   maybe_with_size_expr (arg_p);
    3265                 :            : 
    3266                 :            :   /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c.  */
    3267                 :            :   /* Make sure arguments have the same location as the function call
    3268                 :            :      itself.  */
    3269                 :   20333600 :   protected_set_expr_location (*arg_p, call_location);
    3270                 :            : 
    3271                 :            :   /* There is a sequence point before a function call.  Side effects in
    3272                 :            :      the argument list must occur before the actual call. So, when
    3273                 :            :      gimplifying arguments, force gimplify_expr to use an internal
    3274                 :            :      post queue which is then appended to the end of PRE_P.  */
    3275                 :   20333600 :   return gimplify_expr (arg_p, pre_p, NULL, test, fb, allow_ssa);
    3276                 :            : }
    3277                 :            : 
    3278                 :            : /* Don't fold inside offloading or taskreg regions: it can break code by
    3279                 :            :    adding decl references that weren't in the source.  We'll do it during
    3280                 :            :    omplower pass instead.  */
    3281                 :            : 
    3282                 :            : static bool
    3283                 :   38067300 : maybe_fold_stmt (gimple_stmt_iterator *gsi)
    3284                 :            : {
    3285                 :   38067300 :   struct gimplify_omp_ctx *ctx;
    3286                 :   38488200 :   for (ctx = gimplify_omp_ctxp; ctx; ctx = ctx->outer_context)
    3287                 :     891290 :     if ((ctx->region_type & (ORT_TARGET | ORT_PARALLEL | ORT_TASK)) != 0)
    3288                 :            :       return false;
    3289                 :     422851 :     else if ((ctx->region_type & ORT_HOST_TEAMS) == ORT_HOST_TEAMS)
    3290                 :            :       return false;
    3291                 :            :   /* Delay folding of builtins until the IL is in consistent state
    3292                 :            :      so the diagnostic machinery can do a better job.  */
    3293                 :   37596900 :   if (gimple_call_builtin_p (gsi_stmt (*gsi)))
    3294                 :            :     return false;
    3295                 :   36101800 :   return fold_stmt (gsi);
    3296                 :            : }
    3297                 :            : 
    3298                 :            : /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
    3299                 :            :    WANT_VALUE is true if the result of the call is desired.  */
    3300                 :            : 
    3301                 :            : static enum gimplify_status
    3302                 :   10988100 : gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
    3303                 :            : {
    3304                 :   10988100 :   tree fndecl, parms, p, fnptrtype;
    3305                 :   10988100 :   enum gimplify_status ret;
    3306                 :   10988100 :   int i, nargs;
    3307                 :   10988100 :   gcall *call;
    3308                 :   10988100 :   bool builtin_va_start_p = false;
    3309                 :   10988100 :   location_t loc = EXPR_LOCATION (*expr_p);
    3310                 :            : 
    3311                 :   10988100 :   gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
    3312                 :            : 
    3313                 :            :   /* For reliable diagnostics during inlining, it is necessary that
    3314                 :            :      every call_expr be annotated with file and line.  */
    3315                 :   10988100 :   if (! EXPR_HAS_LOCATION (*expr_p))
    3316                 :     482987 :     SET_EXPR_LOCATION (*expr_p, input_location);
    3317                 :            : 
    3318                 :            :   /* Gimplify internal functions created in the FEs.  */
    3319                 :   10988100 :   if (CALL_EXPR_FN (*expr_p) == NULL_TREE)
    3320                 :            :     {
    3321                 :     292465 :       if (want_value)
    3322                 :            :         return GS_ALL_DONE;
    3323                 :            : 
    3324                 :      11302 :       nargs = call_expr_nargs (*expr_p);
    3325                 :      11302 :       enum internal_fn ifn = CALL_EXPR_IFN (*expr_p);
    3326                 :     303767 :       auto_vec<tree> vargs (nargs);
    3327                 :            : 
    3328                 :      35242 :       for (i = 0; i < nargs; i++)
    3329                 :            :         {
    3330                 :      23940 :           gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
    3331                 :      23940 :                         EXPR_LOCATION (*expr_p));
    3332                 :      23940 :           vargs.quick_push (CALL_EXPR_ARG (*expr_p, i));
    3333                 :            :         }
    3334                 :            : 
    3335                 :      11302 :       gcall *call = gimple_build_call_internal_vec (ifn, vargs);
    3336                 :      11302 :       gimple_call_set_nothrow (call, TREE_NOTHROW (*expr_p));
    3337                 :      11302 :       gimplify_seq_add_stmt (pre_p, call);
    3338                 :      11302 :       return GS_ALL_DONE;
    3339                 :            :     }
    3340                 :            : 
    3341                 :            :   /* This may be a call to a builtin function.
    3342                 :            : 
    3343                 :            :      Builtin function calls may be transformed into different
    3344                 :            :      (and more efficient) builtin function calls under certain
    3345                 :            :      circumstances.  Unfortunately, gimplification can muck things
    3346                 :            :      up enough that the builtin expanders are not aware that certain
    3347                 :            :      transformations are still valid.
    3348                 :            : 
    3349                 :            :      So we attempt transformation/gimplification of the call before
    3350                 :            :      we gimplify the CALL_EXPR.  At this time we do not manage to
    3351                 :            :      transform all calls in the same manner as the expanders do, but
    3352                 :            :      we do transform most of them.  */
    3353                 :   10695600 :   fndecl = get_callee_fndecl (*expr_p);
    3354                 :   10695600 :   if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
    3355                 :    2366310 :     switch (DECL_FUNCTION_CODE (fndecl))
    3356                 :            :       {
    3357                 :      18535 :       CASE_BUILT_IN_ALLOCA:
    3358                 :            :         /* If the call has been built for a variable-sized object, then we
    3359                 :            :            want to restore the stack level when the enclosing BIND_EXPR is
    3360                 :            :            exited to reclaim the allocated space; otherwise, we precisely
    3361                 :            :            need to do the opposite and preserve the latest stack level.  */
    3362                 :      18535 :         if (CALL_ALLOCA_FOR_VAR_P (*expr_p))
    3363                 :       8185 :           gimplify_ctxp->save_stack = true;
    3364                 :            :         else
    3365                 :      10350 :           gimplify_ctxp->keep_stack = true;
    3366                 :            :         break;
    3367                 :            : 
    3368                 :      15552 :       case BUILT_IN_VA_START:
    3369                 :      15552 :         {
    3370                 :      15552 :           builtin_va_start_p = TRUE;
    3371                 :      15552 :           if (call_expr_nargs (*expr_p) < 2)
    3372                 :            :             {
    3373                 :          1 :               error ("too few arguments to function %<va_start%>");
    3374                 :          1 :               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
    3375                 :          1 :               return GS_OK;
    3376                 :            :             }
    3377                 :            : 
    3378                 :      15551 :           if (fold_builtin_next_arg (*expr_p, true))
    3379                 :            :             {
    3380                 :         10 :               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
    3381                 :         10 :               return GS_OK;
    3382                 :            :             }
    3383                 :            :           break;
    3384                 :            :         }
    3385                 :            : 
    3386                 :         25 :       case BUILT_IN_EH_RETURN:
    3387                 :         25 :         cfun->calls_eh_return = true;
    3388                 :         25 :         break;
    3389                 :            : 
    3390                 :            :       default:
    3391                 :            :         ;
    3392                 :            :       }
    3393                 :   10695600 :   if (fndecl && fndecl_built_in_p (fndecl))
    3394                 :            :     {
    3395                 :    2559480 :       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
    3396                 :    2559480 :       if (new_tree && new_tree != *expr_p)
    3397                 :            :         {
    3398                 :            :           /* There was a transformation of this call which computes the
    3399                 :            :              same value, but in a more efficient way.  Return and try
    3400                 :            :              again.  */
    3401                 :       9958 :           *expr_p = new_tree;
    3402                 :       9958 :           return GS_OK;
    3403                 :            :         }
    3404                 :            :     }
    3405                 :            : 
    3406                 :            :   /* Remember the original function pointer type.  */
    3407                 :   10685600 :   fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
    3408                 :            : 
    3409                 :   10685600 :   if (flag_openmp
    3410                 :     285289 :       && fndecl
    3411                 :     285140 :       && cfun
    3412                 :     285140 :       && (cfun->curr_properties & PROP_gimple_any) == 0)
    3413                 :            :     {
    3414                 :     125730 :       tree variant = omp_resolve_declare_variant (fndecl);
    3415                 :     125730 :       if (variant != fndecl)
    3416                 :        157 :         CALL_EXPR_FN (*expr_p) = build1 (ADDR_EXPR, fnptrtype, variant);
    3417                 :            :     }
    3418                 :            : 
    3419                 :            :   /* There is a sequence point before the call, so any side effects in
    3420                 :            :      the calling expression must occur before the actual call.  Force
    3421                 :            :      gimplify_expr to use an internal post queue.  */
    3422                 :   10685600 :   ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
    3423                 :            :                        is_gimple_call_addr, fb_rvalue);
    3424                 :            : 
    3425                 :   10685600 :   nargs = call_expr_nargs (*expr_p);
    3426                 :            : 
    3427                 :            :   /* Get argument types for verification.  */
    3428                 :   10685600 :   fndecl = get_callee_fndecl (*expr_p);
    3429                 :   10685600 :   parms = NULL_TREE;
    3430                 :   10685600 :   if (fndecl)
    3431                 :   13003900 :     parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
    3432                 :            :   else
    3433                 :     218348 :     parms = TYPE_ARG_TYPES (TREE_TYPE (fnptrtype));
    3434                 :            : 
    3435                 :   21175600 :   if (fndecl && DECL_ARGUMENTS (fndecl))
    3436                 :   27590100 :     p = DECL_ARGUMENTS (fndecl);
    3437                 :    5276040 :   else if (parms)
    3438                 :            :     p = parms;
    3439                 :            :   else
    3440                 :      47594 :     p = NULL_TREE;
    3441                 :   27590100 :   for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
    3442                 :            :     ;
    3443                 :            : 
    3444                 :            :   /* If the last argument is __builtin_va_arg_pack () and it is not
    3445                 :            :      passed as a named argument, decrease the number of CALL_EXPR
    3446                 :            :      arguments and set instead the CALL_EXPR_VA_ARG_PACK flag.  */
    3447                 :   10685600 :   if (!p
    3448                 :   10685600 :       && i < nargs
    3449                 :   10685600 :       && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
    3450                 :            :     {
    3451                 :       5055 :       tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
    3452                 :       5055 :       tree last_arg_fndecl = get_callee_fndecl (last_arg);
    3453                 :            : 
    3454                 :       5055 :       if (last_arg_fndecl
    3455                 :       5055 :           && fndecl_built_in_p (last_arg_fndecl, BUILT_IN_VA_ARG_PACK))
    3456                 :            :         {
    3457                 :        114 :           tree call = *expr_p;
    3458                 :            : 
    3459                 :        114 :           --nargs;
    3460                 :        228 :           *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
    3461                 :        114 :                                           CALL_EXPR_FN (call),
    3462                 :        114 :                                           nargs, CALL_EXPR_ARGP (call));
    3463                 :            : 
    3464                 :            :           /* Copy all CALL_EXPR flags, location and block, except
    3465                 :            :              CALL_EXPR_VA_ARG_PACK flag.  */
    3466                 :        114 :           CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
    3467                 :        114 :           CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
    3468                 :        114 :           CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
    3469                 :        114 :             = CALL_EXPR_RETURN_SLOT_OPT (call);
    3470                 :        114 :           CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
    3471                 :        114 :           SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
    3472                 :            : 
    3473                 :            :           /* Set CALL_EXPR_VA_ARG_PACK.  */
    3474                 :        114 :           CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
    3475                 :            :         }
    3476                 :            :     }
    3477                 :            : 
    3478                 :            :   /* If the call returns twice then after building the CFG the call
    3479                 :            :      argument computations will no longer dominate the call because
    3480                 :            :      we add an abnormal incoming edge to the call.  So do not use SSA
    3481                 :            :      vars there.  */
    3482                 :   10685600 :   bool returns_twice = call_expr_flags (*expr_p) & ECF_RETURNS_TWICE;
    3483                 :            : 
    3484                 :            :   /* Gimplify the function arguments.  */
    3485                 :   10685600 :   if (nargs > 0)
    3486                 :            :     {
    3487                 :   26709200 :       for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
    3488                 :   26709200 :            PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
    3489                 :            :            PUSH_ARGS_REVERSED ? i-- : i++)
    3490                 :            :         {
    3491                 :   17482600 :           enum gimplify_status t;
    3492                 :            : 
    3493                 :            :           /* Avoid gimplifying the second argument to va_start, which needs to
    3494                 :            :              be the plain PARM_DECL.  */
    3495                 :   17482600 :           if ((i != 1) || !builtin_va_start_p)
    3496                 :            :             {
    3497                 :   17467000 :               t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
    3498                 :   17467000 :                                 EXPR_LOCATION (*expr_p), ! returns_twice);
    3499                 :            : 
    3500                 :   17467000 :               if (t == GS_ERROR)
    3501                 :          4 :                 ret = GS_ERROR;
    3502                 :            :             }
    3503                 :            :         }
    3504                 :            :     }
    3505                 :            : 
    3506                 :            :   /* Gimplify the static chain.  */
    3507                 :   10685600 :   if (CALL_EXPR_STATIC_CHAIN (*expr_p))
    3508                 :            :     {
    3509                 :      23889 :       if (fndecl && !DECL_STATIC_CHAIN (fndecl))
    3510                 :          3 :         CALL_EXPR_STATIC_CHAIN (*expr_p) = NULL;
    3511                 :            :       else
    3512                 :            :         {
    3513                 :      23328 :           enum gimplify_status t;
    3514                 :      23328 :           t = gimplify_arg (&CALL_EXPR_STATIC_CHAIN (*expr_p), pre_p,
    3515                 :      23328 :                             EXPR_LOCATION (*expr_p), ! returns_twice);
    3516                 :      23328 :           if (t == GS_ERROR)
    3517                 :          0 :             ret = GS_ERROR;
    3518                 :            :         }
    3519                 :            :     }
    3520                 :            : 
    3521                 :            :   /* Verify the function result.  */
    3522                 :   10685600 :   if (want_value && fndecl
    3523                 :   17167000 :       && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype))))
    3524                 :            :     {
    3525                 :          0 :       error_at (loc, "using result of function returning %<void%>");
    3526                 :          0 :       ret = GS_ERROR;
    3527                 :            :     }
    3528                 :            : 
    3529                 :            :   /* Try this again in case gimplification exposed something.  */
    3530                 :   10685600 :   if (ret != GS_ERROR)
    3531                 :            :     {
    3532                 :   10685600 :       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
    3533                 :            : 
    3534                 :   10685600 :       if (new_tree && new_tree != *expr_p)
    3535                 :            :         {
    3536                 :            :           /* There was a transformation of this call which computes the
    3537                 :            :              same value, but in a more efficient way.  Return and try
    3538                 :            :              again.  */
    3539                 :      10754 :           *expr_p = new_tree;
    3540                 :      10754 :           return GS_OK;
    3541                 :            :         }
    3542                 :            :     }
    3543                 :            :   else
    3544                 :            :     {
    3545                 :          4 :       *expr_p = error_mark_node;
    3546                 :          4 :       return GS_ERROR;
    3547                 :            :     }
    3548                 :            : 
    3549                 :            :   /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
    3550                 :            :      decl.  This allows us to eliminate redundant or useless
    3551                 :            :      calls to "const" functions.  */
    3552                 :   10674900 :   if (TREE_CODE (*expr_p) == CALL_EXPR)
    3553                 :            :     {
    3554                 :   10674900 :       int flags = call_expr_flags (*expr_p);
    3555                 :   10674900 :       if (flags & (ECF_CONST | ECF_PURE)
    3556                 :            :           /* An infinite loop is considered a side effect.  */
    3557                 :    1276350 :           && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
    3558                 :    1053110 :         TREE_SIDE_EFFECTS (*expr_p) = 0;
    3559                 :            :     }
    3560                 :            : 
    3561                 :            :   /* If the value is not needed by the caller, emit a new GIMPLE_CALL
    3562                 :            :      and clear *EXPR_P.  Otherwise, leave *EXPR_P in its gimplified
    3563                 :            :      form and delegate the creation of a GIMPLE_CALL to
    3564                 :            :      gimplify_modify_expr.  This is always possible because when
    3565                 :            :      WANT_VALUE is true, the caller wants the result of this call into
    3566                 :            :      a temporary, which means that we will emit an INIT_EXPR in
    3567                 :            :      internal_get_tmp_var which will then be handled by
    3568                 :            :      gimplify_modify_expr.  */
    3569                 :   10674900 :   if (!want_value)
    3570                 :            :     {
    3571                 :            :       /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
    3572                 :            :          have to do is replicate it as a GIMPLE_CALL tuple.  */
    3573                 :    4042070 :       gimple_stmt_iterator gsi;
    3574                 :    4042070 :       call = gimple_build_call_from_tree (*expr_p, fnptrtype);
    3575                 :    4042070 :       notice_special_calls (call);
    3576                 :    4042070 :       gimplify_seq_add_stmt (pre_p, call);
    3577                 :    4042070 :       gsi = gsi_last (*pre_p);
    3578                 :    4042070 :       maybe_fold_stmt (&gsi);
    3579                 :    4042070 :       *expr_p = NULL_TREE;
    3580                 :            :     }
    3581                 :            :   else
    3582                 :            :     /* Remember the original function type.  */
    3583                 :    6632800 :     CALL_EXPR_FN (*expr_p) = build1 (NOP_EXPR, fnptrtype,
    3584                 :    6632800 :                                      CALL_EXPR_FN (*expr_p));
    3585                 :            : 
    3586                 :            :   return ret;
    3587                 :            : }
    3588                 :            : 
    3589                 :            : /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
    3590                 :            :    rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
    3591                 :            : 
    3592                 :            :    TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
    3593                 :            :    condition is true or false, respectively.  If null, we should generate
    3594                 :            :    our own to skip over the evaluation of this specific expression.
    3595                 :            : 
    3596                 :            :    LOCUS is the source location of the COND_EXPR.
    3597                 :            : 
    3598                 :            :    This function is the tree equivalent of do_jump.
    3599                 :            : 
    3600                 :            :    shortcut_cond_r should only be called by shortcut_cond_expr.  */
    3601                 :            : 
    3602                 :            : static tree
    3603                 :     984419 : shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
    3604                 :            :                  location_t locus)
    3605                 :            : {
    3606                 :     984419 :   tree local_label = NULL_TREE;
    3607                 :     984419 :   tree t, expr = NULL;
    3608                 :            : 
    3609                 :            :   /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
    3610                 :            :      retain the shortcut semantics.  Just insert the gotos here;
    3611                 :            :      shortcut_cond_expr will append the real blocks later.  */
    3612                 :     984419 :   if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
    3613                 :            :     {
    3614                 :      79416 :       location_t new_locus;
    3615                 :            : 
    3616                 :            :       /* Turn if (a && b) into
    3617                 :            : 
    3618                 :            :          if (a); else goto no;
    3619                 :            :          if (b) goto yes; else goto no;
    3620                 :            :          (no:) */
    3621                 :            : 
    3622                 :      79416 :       if (false_label_p == NULL)
    3623                 :       2490 :         false_label_p = &local_label;
    3624                 :            : 
    3625                 :            :       /* Keep the original source location on the first 'if'.  */
    3626                 :      79416 :       t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
    3627                 :      79416 :       append_to_statement_list (t, &expr);
    3628                 :            : 
    3629                 :            :       /* Set the source location of the && on the second 'if'.  */
    3630                 :      79416 :       new_locus = rexpr_location (pred, locus);
    3631                 :      79416 :       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
    3632                 :            :                            new_locus);
    3633                 :      79416 :       append_to_statement_list (t, &expr);
    3634                 :            :     }
    3635                 :     905003 :   else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
    3636                 :            :     {
    3637                 :     302331 :       location_t new_locus;
    3638                 :            : 
    3639                 :            :       /* Turn if (a || b) into
    3640                 :            : 
    3641                 :            :          if (a) goto yes;
    3642                 :            :          if (b) goto yes; else goto no;
    3643                 :            :          (yes:) */
    3644                 :            : 
    3645                 :     302331 :       if (true_label_p == NULL)
    3646                 :     170530 :         true_label_p = &local_label;
    3647                 :            : 
    3648                 :            :       /* Keep the original source location on the first 'if'.  */
    3649                 :     302331 :       t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
    3650                 :     302331 :       append_to_statement_list (t, &expr);
    3651                 :            : 
    3652                 :            :       /* Set the source location of the || on the second 'if'.  */
    3653                 :     302331 :       new_locus = rexpr_location (pred, locus);
    3654                 :     302331 :       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
    3655                 :            :                            new_locus);
    3656                 :     302331 :       append_to_statement_list (t, &expr);
    3657                 :            :     }
    3658                 :     602672 :   else if (TREE_CODE (pred) == COND_EXPR
    3659                 :        225 :            && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 1)))
    3660                 :     602897 :            && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 2))))
    3661                 :            :     {
    3662                 :        217 :       location_t new_locus;
    3663                 :            : 
    3664                 :            :       /* As long as we're messing with gotos, turn if (a ? b : c) into
    3665                 :            :          if (a)
    3666                 :            :            if (b) goto yes; else goto no;
    3667                 :            :          else
    3668                 :            :            if (c) goto yes; else goto no;
    3669                 :            : 
    3670                 :            :          Don't do this if one of the arms has void type, which can happen
    3671                 :            :          in C++ when the arm is throw.  */
    3672                 :            : 
    3673                 :            :       /* Keep the original source location on the first 'if'.  Set the source
    3674                 :            :          location of the ? on the second 'if'.  */
    3675                 :        217 :       new_locus = rexpr_location (pred, locus);
    3676                 :        434 :       expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
    3677                 :        217 :                      shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
    3678                 :            :                                       false_label_p, locus),
    3679                 :        217 :                      shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
    3680                 :            :                                       false_label_p, new_locus));
    3681                 :            :     }
    3682                 :            :   else
    3683                 :            :     {
    3684                 :     602455 :       expr = build3 (COND_EXPR, void_type_node, pred,
    3685                 :            :                      build_and_jump (true_label_p),
    3686                 :            :                      build_and_jump (false_label_p));
    3687                 :     602455 :       SET_EXPR_LOCATION (expr, locus);
    3688                 :            :     }
    3689                 :            : 
    3690                 :     984419 :   if (local_label)
    3691                 :            :     {
    3692                 :     173020 :       t = build1 (LABEL_EXPR, void_type_node, local_label);
    3693                 :     173020 :       append_to_statement_list (t, &expr);
    3694                 :            :     }
    3695                 :            : 
    3696                 :     984419 :   return expr;
    3697                 :            : }
    3698                 :            : 
    3699                 :            : /* If EXPR is a GOTO_EXPR, return it.  If it is a STATEMENT_LIST, skip
    3700                 :            :    any of its leading DEBUG_BEGIN_STMTS and recurse on the subsequent
    3701                 :            :    statement, if it is the last one.  Otherwise, return NULL.  */
    3702                 :            : 
    3703                 :            : static tree
    3704                 :    7605110 : find_goto (tree expr)
    3705                 :            : {
    3706                 :    7779890 :   if (!expr)
    3707                 :            :     return NULL_TREE;
    3708                 :            : 
    3709                 :    6271170 :   if (TREE_CODE (expr) == GOTO_EXPR)
    3710                 :            :     return expr;
    3711                 :            : 
    3712                 :    4993010 :   if (TREE_CODE (expr) != STATEMENT_LIST)
    3713                 :            :     return NULL_TREE;
    3714                 :            : 
    3715                 :     556498 :   tree_stmt_iterator i = tsi_start (expr);
    3716                 :            : 
    3717                 :     853521 :   while (!tsi_end_p (i) && TREE_CODE (tsi_stmt (i)) == DEBUG_BEGIN_STMT)
    3718                 :     297023 :     tsi_next (&i);
    3719                 :            : 
    3720                 :     556498 :   if (!tsi_one_before_end_p (i))
    3721                 :            :     return NULL_TREE;
    3722                 :            : 
    3723                 :     174783 :   return find_goto (tsi_stmt (i));
    3724                 :            : }
    3725                 :            : 
    3726                 :            : /* Same as find_goto, except that it returns NULL if the destination
    3727                 :            :    is not a LABEL_DECL.  */
    3728                 :            : 
    3729                 :            : static inline tree
    3730                 :    7605110 : find_goto_label (tree expr)
    3731                 :            : {
    3732                 :    7605110 :   tree dest = find_goto (expr);
    3733                 :    8883270 :   if (dest && TREE_CODE (GOTO_DESTINATION (dest)) == LABEL_DECL)
    3734                 :    1278090 :     return dest;
    3735                 :            :   return NULL_TREE;
    3736                 :            : }
    3737                 :            : 
    3738                 :            : /* Given a conditional expression EXPR with short-circuit boolean
    3739                 :            :    predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
    3740                 :            :    predicate apart into the equivalent sequence of conditionals.  */
    3741                 :            : 
    3742                 :            : static tree
    3743                 :     271452 : shortcut_cond_expr (tree expr)
    3744                 :            : {
    3745                 :     271452 :   tree pred = TREE_OPERAND (expr, 0);
    3746                 :     271452 :   tree then_ = TREE_OPERAND (expr, 1);
    3747                 :     271452 :   tree else_ = TREE_OPERAND (expr, 2);
    3748                 :     271452 :   tree true_label, false_label, end_label, t;
    3749                 :     271452 :   tree *true_label_p;
    3750                 :     271452 :   tree *false_label_p;
    3751                 :     271452 :   bool emit_end, emit_false, jump_over_else;
    3752                 :     542824 :   bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
    3753                 :     427968 :   bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
    3754                 :            : 
    3755                 :            :   /* First do simple transformations.  */
    3756                 :            :   if (!else_se)
    3757                 :            :     {
    3758                 :            :       /* If there is no 'else', turn
    3759                 :            :            if (a && b) then c
    3760                 :            :          into
    3761                 :            :            if (a) if (b) then c.  */
    3762                 :     193614 :       while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
    3763                 :            :         {
    3764                 :            :           /* Keep the original source location on the first 'if'.  */
    3765                 :      28251 :           location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
    3766                 :      28251 :           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
    3767                 :            :           /* Set the source location of the && on the second 'if'.  */
    3768                 :      28251 :           if (rexpr_has_location (pred))
    3769                 :      27931 :             SET_EXPR_LOCATION (expr, rexpr_location (pred));
    3770                 :      28251 :           then_ = shortcut_cond_expr (expr);
    3771                 :      56502 :           then_se = then_ && TREE_SIDE_EFFECTS (then_);
    3772                 :      28251 :           pred = TREE_OPERAND (pred, 0);
    3773                 :      28251 :           expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
    3774                 :      28251 :           SET_EXPR_LOCATION (expr, locus);
    3775                 :            :         }
    3776                 :            :     }
    3777                 :            : 
    3778                 :     271452 :   if (!then_se)
    3779                 :            :     {
    3780                 :            :       /* If there is no 'then', turn
    3781                 :            :            if (a || b); else d
    3782                 :            :          into
    3783                 :            :            if (a); else if (b); else d.  */
    3784                 :      14299 :       while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
    3785                 :            :         {
    3786                 :            :           /* Keep the original source location on the first 'if'.  */
    3787                 :        669 :           location_t locus = EXPR_LOC_OR_LOC (expr, input_location);
    3788                 :        669 :           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
    3789                 :            :           /* Set the source location of the || on the second 'if'.  */
    3790                 :        669 :           if (rexpr_has_location (pred))
    3791                 :        668 :             SET_EXPR_LOCATION (expr, rexpr_location (pred));
    3792                 :        669 :           else_ = shortcut_cond_expr (expr);
    3793                 :       1338 :           else_se = else_ && TREE_SIDE_EFFECTS (else_);
    3794                 :        669 :           pred = TREE_OPERAND (pred, 0);
    3795                 :        669 :           expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
    3796                 :        669 :           SET_EXPR_LOCATION (expr, locus);
    3797                 :            :         }
    3798                 :            :     }
    3799                 :            : 
    3800                 :            :   /* If we're done, great.  */
    3801                 :     271452 :   if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
    3802                 :     271452 :       && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
    3803                 :      50961 :     return expr;
    3804                 :            : 
    3805                 :            :   /* Otherwise we need to mess with gotos.  Change
    3806                 :            :        if (a) c; else d;
    3807                 :            :      to
    3808                 :            :        if (a); else goto no;
    3809                 :            :        c; goto end;
    3810                 :            :        no: d; end:
    3811                 :            :      and recursively gimplify the condition.  */
    3812                 :            : 
    3813                 :     220491 :   true_label = false_label = end_label = NULL_TREE;
    3814                 :            : 
    3815                 :            :   /* If our arms just jump somewhere, hijack those labels so we don't
    3816                 :            :      generate jumps to jumps.  */
    3817                 :            : 
    3818                 :     220491 :   if (tree then_goto = find_goto_label (then_))
    3819                 :            :     {
    3820                 :       3465 :       true_label = GOTO_DESTINATION (then_goto);
    3821                 :       3465 :       then_ = NULL;
    3822                 :       3465 :       then_se = false;
    3823                 :            :     }
    3824                 :            : 
    3825                 :     220491 :   if (tree else_goto = find_goto_label (else_))
    3826                 :            :     {
    3827                 :       2502 :       false_label = GOTO_DESTINATION (else_goto);
    3828                 :       2502 :       else_ = NULL;
    3829                 :       2502 :       else_se = false;
    3830                 :            :     }
    3831                 :            : 
    3832                 :            :   /* If we aren't hijacking a label for the 'then' branch, it falls through.  */
    3833                 :     220491 :   if (true_label)
    3834                 :            :     true_label_p = &true_label;
    3835                 :            :   else
    3836                 :     217026 :     true_label_p = NULL;
    3837                 :            : 
    3838                 :            :   /* The 'else' branch also needs a label if it contains interesting code.  */
    3839                 :     220491 :   if (false_label || else_se)
    3840                 :            :     false_label_p = &false_label;
    3841                 :            :   else
    3842                 :     115115 :     false_label_p = NULL;
    3843                 :            : 
    3844                 :            :   /* If there was nothing else in our arms, just forward the label(s).  */
    3845                 :     220491 :   if (!then_se && !else_se)
    3846                 :       6149 :     return shortcut_cond_r (pred, true_label_p, false_label_p,
    3847                 :       9306 :                             EXPR_LOC_OR_LOC (expr, input_location));
    3848                 :            : 
    3849                 :            :   /* If our last subexpression already has a terminal label, reuse it.  */
    3850                 :     217334 :   if (else_se)
    3851                 :     102874 :     t = expr_last (else_);
    3852                 :     114460 :   else if (then_se)
    3853                 :     114460 :     t = expr_last (then_);
    3854                 :            :   else
    3855                 :            :     t = NULL;
    3856                 :     217334 :   if (t && TREE_CODE (t) == LABEL_EXPR)
    3857                 :        772 :     end_label = LABEL_EXPR_LABEL (t);
    3858                 :            : 
    3859                 :            :   /* If we don't care about jumping to the 'else' branch, jump to the end
    3860                 :            :      if the condition is false.  */
    3861                 :     217334 :   if (!false_label_p)
    3862                 :     114217 :     false_label_p = &end_label;
    3863                 :            : 
    3864                 :            :   /* We only want to emit these labels if we aren't hijacking them.  */
    3865                 :     217334 :   emit_end = (end_label == NULL_TREE);
    3866                 :     217334 :   emit_false = (false_label == NULL_TREE);
    3867                 :            : 
    3868                 :            :   /* We only emit the jump over the else clause if we have to--if the
    3869                 :            :      then clause may fall through.  Otherwise we can wind up with a
    3870                 :            :      useless jump and a useless label at the end of gimplified code,
    3871                 :            :      which will cause us to think that this conditional as a whole
    3872                 :            :      falls through even if it doesn't.  If we then inline a function
    3873                 :            :      which ends with such a condition, that can cause us to issue an
    3874                 :            :      inappropriate warning about control reaching the end of a
    3875                 :            :      non-void function.  */
    3876                 :     217334 :   jump_over_else = block_may_fallthru (then_);
    3877                 :            : 
    3878                 :     434548 :   pred = shortcut_cond_r (pred, true_label_p, false_label_p,
    3879                 :     434548 :                           EXPR_LOC_OR_LOC (expr, input_location));
    3880                 :            : 
    3881                 :     217334 :   expr = NULL;
    3882                 :     217334 :   append_to_statement_list (pred, &expr);
    3883                 :            : 
    3884                 :     217334 :   append_to_statement_list (then_, &expr);
    3885                 :     217334 :   if (else_se)
    3886                 :            :     {
    3887                 :     102874 :       if (jump_over_else)
    3888                 :            :         {
    3889                 :     100922 :           tree last = expr_last (expr);
    3890                 :     100922 :           t = build_and_jump (&end_label);
    3891                 :     100922 :           if (rexpr_has_location (last))
    3892                 :      19969 :             SET_EXPR_LOCATION (t, rexpr_location (last));
    3893                 :     100922 :           append_to_statement_list (t, &expr);
    3894                 :            :         }
    3895                 :     102874 :       if (emit_false)
    3896                 :            :         {
    3897                 :     102874 :           t = build1 (LABEL_EXPR, void_type_node, false_label);
    3898                 :     102874 :           append_to_statement_list (t, &expr);
    3899                 :            :         }
    3900                 :     102874 :       append_to_statement_list (else_, &expr);
    3901                 :            :     }
    3902                 :     217334 :   if (emit_end && end_label)
    3903                 :            :     {
    3904                 :     214372 :       t = build1 (LABEL_EXPR, void_type_node, end_label);
    3905                 :     214372 :       append_to_statement_list (t, &expr);
    3906                 :            :     }
    3907                 :            : 
    3908                 :     217334 :   return expr;
    3909                 :            : }
    3910                 :            : 
    3911                 :            : /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE.  */
    3912                 :            : 
    3913                 :            : tree
    3914                 :   11106200 : gimple_boolify (tree expr)
    3915                 :            : {
    3916                 :   11106200 :   tree type = TREE_TYPE (expr);
    3917                 :   11106200 :   location_t loc = EXPR_LOCATION (expr);
    3918                 :            : 
    3919                 :   11106200 :   if (TREE_CODE (expr) == NE_EXPR
    3920                 :    3814890 :       && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
    3921                 :   11799900 :       && integer_zerop (TREE_OPERAND (expr, 1)))
    3922                 :            :     {
    3923                 :     295852 :       tree call = TREE_OPERAND (expr, 0);
    3924                 :     295852 :       tree fn = get_callee_fndecl (call);
    3925                 :            : 
    3926                 :            :       /* For __builtin_expect ((long) (x), y) recurse into x as well
    3927                 :            :          if x is truth_value_p.  */
    3928                 :     295852 :       if (fn
    3929                 :     295410 :           && fndecl_built_in_p (fn, BUILT_IN_EXPECT)
    3930                 :     347701 :           && call_expr_nargs (call) == 2)
    3931                 :            :         {
    3932                 :      51849 :           tree arg = CALL_EXPR_ARG (call, 0);
    3933                 :      51849 :           if (arg)
    3934                 :            :             {
    3935                 :      51849 :               if (TREE_CODE (arg) == NOP_EXPR
    3936                 :      81655 :                   && TREE_TYPE (arg) == TREE_TYPE (call))
    3937                 :      29806 :                 arg = TREE_OPERAND (arg, 0);
    3938                 :      51849 :               if (truth_value_p (TREE_CODE (arg)))
    3939                 :            :                 {
    3940                 :      48087 :                   arg = gimple_boolify (arg);
    3941                 :      96174 :                   CALL_EXPR_ARG (call, 0)
    3942                 :      96174 :                     = fold_convert_loc (loc, TREE_TYPE (call), arg);
    3943                 :            :                 }
    3944                 :            :             }
    3945                 :            :         }
    3946                 :            :     }
    3947                 :            : 
    3948                 :   11106200 :   switch (TREE_CODE (expr))
    3949                 :            :     {
    3950                 :     911168 :     case TRUTH_AND_EXPR:
    3951                 :     911168 :     case TRUTH_OR_EXPR:
    3952                 :     911168 :     case TRUTH_XOR_EXPR:
    3953                 :     911168 :     case TRUTH_ANDIF_EXPR:
    3954                 :     911168 :     case TRUTH_ORIF_EXPR:
    3955                 :            :       /* Also boolify the arguments of truth exprs.  */
    3956                 :     911168 :       TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
    3957                 :            :       /* FALLTHRU */
    3958                 :            : 
    3959                 :    1176270 :     case TRUTH_NOT_EXPR:
    3960                 :    1176270 :       TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
    3961                 :            : 
    3962                 :            :       /* These expressions always produce boolean results.  */
    3963                 :    1176270 :       if (TREE_CODE (type) != BOOLEAN_TYPE)
    3964                 :     238840 :         TREE_TYPE (expr) = boolean_type_node;
    3965                 :            :       return expr;
    3966                 :            : 
    3967                 :        385 :     case ANNOTATE_EXPR:
    3968                 :        385 :       switch ((enum annot_expr_kind) TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)))
    3969                 :            :         {
    3970                 :        385 :         case annot_expr_ivdep_kind:
    3971                 :        385 :         case annot_expr_unroll_kind:
    3972                 :        385 :         case annot_expr_no_vector_kind:
    3973                 :        385 :         case annot_expr_vector_kind:
    3974                 :        385 :         case annot_expr_parallel_kind:
    3975                 :        385 :           TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
    3976                 :        385 :           if (TREE_CODE (type) != BOOLEAN_TYPE)
    3977                 :        154 :             TREE_TYPE (expr) = boolean_type_node;
    3978                 :            :           return expr;
    3979                 :          0 :         default:
    3980                 :          0 :           gcc_unreachable ();
    3981                 :            :         }
    3982                 :            : 
    3983                 :    9929520 :     default:
    3984                 :    9929520 :       if (COMPARISON_CLASS_P (expr))
    3985                 :            :         {
    3986                 :            :           /* There expressions always prduce boolean results.  */
    3987                 :    8744740 :           if (TREE_CODE (type) != BOOLEAN_TYPE)
    3988                 :    1107370 :             TREE_TYPE (expr) = boolean_type_node;
    3989                 :    8744740 :           return expr;
    3990                 :            :         }
    3991                 :            :       /* Other expressions that get here must have boolean values, but
    3992                 :            :          might need to be converted to the appropriate mode.  */
    3993                 :    1184790 :       if (TREE_CODE (type) == BOOLEAN_TYPE)
    3994                 :            :         return expr;
    3995                 :     154626 :       return fold_convert_loc (loc, boolean_type_node, expr);
    3996                 :            :     }
    3997                 :            : }
    3998                 :            : 
    3999                 :            : /* Given a conditional expression *EXPR_P without side effects, gimplify
    4000                 :            :    its operands.  New statements are inserted to PRE_P.  */
    4001                 :            : 
    4002                 :            : static enum gimplify_status
    4003                 :      51020 : gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
    4004                 :            : {
    4005                 :      51020 :   tree expr = *expr_p, cond;
    4006                 :      51020 :   enum gimplify_status ret, tret;
    4007                 :      51020 :   enum tree_code code;
    4008                 :            : 
    4009                 :      51020 :   cond = gimple_boolify (COND_EXPR_COND (expr));
    4010                 :            : 
    4011                 :            :   /* We need to handle && and || specially, as their gimplification
    4012                 :            :      creates pure cond_expr, thus leading to an infinite cycle otherwise.  */
    4013                 :      51020 :   code = TREE_CODE (cond);
    4014                 :      51020 :   if (code == TRUTH_ANDIF_EXPR)
    4015                 :         10 :     TREE_SET_CODE (cond, TRUTH_AND_EXPR);
    4016                 :      51010 :   else if (code == TRUTH_ORIF_EXPR)
    4017                 :        419 :     TREE_SET_CODE (cond, TRUTH_OR_EXPR);
    4018                 :      51020 :   ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
    4019                 :      51020 :   COND_EXPR_COND (*expr_p) = cond;
    4020                 :            : 
    4021                 :      51020 :   tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
    4022                 :            :                                    is_gimple_val, fb_rvalue);
    4023                 :      51020 :   ret = MIN (ret, tret);
    4024                 :      51020 :   tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
    4025                 :            :                                    is_gimple_val, fb_rvalue);
    4026                 :            : 
    4027                 :      51020 :   return MIN (ret, tret);
    4028                 :            : }
    4029                 :            : 
    4030                 :            : /* Return true if evaluating EXPR could trap.
    4031                 :            :    EXPR is GENERIC, while tree_could_trap_p can be called
    4032                 :            :    only on GIMPLE.  */
    4033                 :            : 
    4034                 :            : bool
    4035                 :    3493160 : generic_expr_could_trap_p (tree expr)
    4036                 :            : {
    4037                 :    3493160 :   unsigned i, n;
    4038                 :            : 
    4039                 :    3493160 :   if (!expr || is_gimple_val (expr))
    4040                 :    1589480 :     return false;
    4041                 :            : 
    4042                 :    1903680 :   if (!EXPR_P (expr) || tree_could_trap_p (expr))
    4043                 :     463697 :     return true;
    4044                 :            : 
    4045                 :    1439990 :   n = TREE_OPERAND_LENGTH (expr);
    4046                 :    3318890 :   for (i = 0; i < n; i++)
    4047                 :    2524060 :     if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
    4048                 :            :       return true;
    4049                 :            : 
    4050                 :            :   return false;
    4051                 :            : }
    4052                 :            : 
    4053                 :            : /*  Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
    4054                 :            :     into
    4055                 :            : 
    4056                 :            :     if (p)                      if (p)
    4057                 :            :       t1 = a;                     a;
    4058                 :            :     else                or      else
    4059                 :            :       t1 = b;                     b;
    4060                 :            :     t1;
    4061                 :            : 
    4062                 :            :     The second form is used when *EXPR_P is of type void.
    4063                 :            : 
    4064                 :            :     PRE_P points to the list where side effects that must happen before
    4065                 :            :       *EXPR_P should be stored.  */
    4066                 :            : 
    4067                 :            : static enum gimplify_status
    4068                 :    4221940 : gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
    4069                 :            : {
    4070                 :    4221940 :   tree expr = *expr_p;
    4071                 :    4221940 :   tree type = TREE_TYPE (expr);
    4072                 :    4221940 :   location_t loc = EXPR_LOCATION (expr);
    4073                 :    4221940 :   tree tmp, arm1, arm2;
    4074                 :    4221940 :   enum gimplify_status ret;
    4075                 :    4221940 :   tree label_true, label_false, label_cont;
    4076                 :    4221940 :   bool have_then_clause_p, have_else_clause_p;
    4077                 :    4221940 :   gcond *cond_stmt;
    4078                 :    4221940 :   enum tree_code pred_code;
    4079                 :    4221940 :   gimple_seq seq = NULL;
    4080                 :            : 
    4081                 :            :   /* If this COND_EXPR has a value, copy the values into a temporary within
    4082                 :            :      the arms.  */
    4083                 :    4221940 :   if (!VOID_TYPE_P (type))
    4084                 :            :     {
    4085                 :     396705 :       tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
    4086                 :     396705 :       tree result;
    4087                 :            : 
    4088                 :            :       /* If either an rvalue is ok or we do not require an lvalue, create the
    4089                 :            :          temporary.  But we cannot do that if the type is addressable.  */
    4090                 :     396705 :       if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
    4091                 :     396698 :           && !TREE_ADDRESSABLE (type))
    4092                 :            :         {
    4093                 :     396698 :           if (gimplify_ctxp->allow_rhs_cond_expr
    4094                 :            :               /* If either branch has side effects or could trap, it can't be
    4095                 :            :                  evaluated unconditionally.  */
    4096                 :      51020 :               && !TREE_SIDE_EFFECTS (then_)
    4097                 :      51020 :               && !generic_expr_could_trap_p (then_)
    4098                 :      51020 :               && !TREE_SIDE_EFFECTS (else_)
    4099                 :     447718 :               && !generic_expr_could_trap_p (else_))
    4100                 :      51020 :             return gimplify_pure_cond_expr (expr_p, pre_p);
    4101                 :            : 
    4102                 :     345678 :           tmp = create_tmp_var (type, "iftmp");
    4103                 :     345678 :           result = tmp;
    4104                 :            :         }
    4105                 :            : 
    4106                 :            :       /* Otherwise, only create and copy references to the values.  */
    4107                 :            :       else
    4108                 :            :         {
    4109                 :          7 :           type = build_pointer_type (type);
    4110                 :            : 
    4111                 :          7 :           if (!VOID_TYPE_P (TREE_TYPE (then_)))
    4112                 :          7 :             then_ = build_fold_addr_expr_loc (loc, then_);
    4113                 :            : 
    4114                 :          7 :           if (!VOID_TYPE_P (TREE_TYPE (else_)))
    4115                 :          7 :             else_ = build_fold_addr_expr_loc (loc, else_);
    4116                 :            :  
    4117                 :          7 :           expr
    4118                 :          7 :             = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
    4119                 :            : 
    4120                 :          7 :           tmp = create_tmp_var (type, "iftmp");
    4121                 :          7 :           result = build_simple_mem_ref_loc (loc, tmp);
    4122                 :            :         }
    4123                 :            : 
    4124                 :            :       /* Build the new then clause, `tmp = then_;'.  But don't build the
    4125                 :            :          assignment if the value is void; in C++ it can be if it's a throw.  */
    4126                 :     345685 :       if (!VOID_TYPE_P (TREE_TYPE (then_)))
    4127                 :     271745 :         TREE_OPERAND (expr, 1) = build2 (INIT_EXPR, type, tmp, then_);
    4128                 :            : 
    4129                 :            :       /* Similarly, build the new else clause, `tmp = else_;'.  */
    4130                 :     345685 :       if (!VOID_TYPE_P (TREE_TYPE (else_)))
    4131                 :     341529 :         TREE_OPERAND (expr, 2) = build2 (INIT_EXPR, type, tmp, else_);
    4132                 :            : 
    4133                 :     345685 :       TREE_TYPE (expr) = void_type_node;
    4134                 :     345685 :       recalculate_side_effects (expr);
    4135                 :            : 
    4136                 :            :       /* Move the COND_EXPR to the prequeue.  */
    4137                 :     345685 :       gimplify_stmt (&expr, pre_p);
    4138                 :            : 
    4139                 :     345685 :       *expr_p = result;
    4140                 :     345685 :       return GS_ALL_DONE;
    4141                 :            :     }
    4142                 :            : 
    4143                 :            :   /* Remove any COMPOUND_EXPR so the following cases will be caught.  */
    4144                 :    3832730 :   STRIP_TYPE_NOPS (TREE_OPERAND (expr, 0));
    4145                 :    3825240 :   if (TREE_CODE (TREE_OPERAND (expr, 0)) == COMPOUND_EXPR)
    4146                 :      58088 :     gimplify_compound_expr (&TREE_OPERAND (expr, 0), pre_p, true);
    4147                 :            : 
    4148                 :            :   /* Make sure the condition has BOOLEAN_TYPE.  */
    4149                 :    3825240 :   TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
    4150                 :            : 
    4151                 :            :   /* Break apart && and || conditions.  */
    4152                 :    3825240 :   if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
    4153                 :    3825240 :       || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
    4154                 :            :     {
    4155                 :     242532 :       expr = shortcut_cond_expr (expr);
    4156                 :            : 
    4157                 :     242532 :       if (expr != *expr_p)
    4158                 :            :         {
    4159                 :     242532 :           *expr_p = expr;
    4160                 :            : 
    4161                 :            :           /* We can't rely on gimplify_expr to re-gimplify the expanded
    4162                 :            :              form properly, as cleanups might cause the target labels to be
    4163                 :            :              wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
    4164                 :            :              set up a conditional context.  */
    4165                 :     242532 :           gimple_push_condition ();
    4166                 :     242532 :           gimplify_stmt (expr_p, &seq);
    4167                 :     242532 :           gimple_pop_condition (pre_p);
    4168                 :     242532 :           gimple_seq_add_seq (pre_p, seq);
    4169                 :            : 
    4170                 :     242532 :           return GS_ALL_DONE;
    4171                 :            :         }
    4172                 :            :     }
    4173                 :            : 
    4174                 :            :   /* Now do the normal gimplification.  */
    4175                 :            : 
    4176                 :            :   /* Gimplify condition.  */
    4177                 :    3582710 :   ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
    4178                 :            :                        is_gimple_condexpr_for_cond, fb_rvalue);
    4179                 :    3582710 :   if (ret == GS_ERROR)
    4180                 :            :     return GS_ERROR;
    4181                 :    3582060 :   gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
    4182                 :            : 
    4183                 :    3582060 :   gimple_push_condition ();
    4184                 :            : 
    4185                 :    3582060 :   have_then_clause_p = have_else_clause_p = false;
    4186                 :    3582060 :   label_true = find_goto_label (TREE_OPERAND (expr, 1));
    4187                 :    3582060 :   if (label_true
    4188                 :     832549 :       && DECL_CONTEXT (GOTO_DESTINATION (label_true)) == current_function_decl
    4189                 :            :       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
    4190                 :            :          have different locations, otherwise we end up with incorrect
    4191                 :            :          location information on the branches.  */
    4192                 :    4414610 :       && (optimize
    4193                 :     139796 :           || !EXPR_HAS_LOCATION (expr)
    4194                 :     121876 :           || !rexpr_has_location (label_true)
    4195                 :      38648 :           || EXPR_LOCATION (expr) == rexpr_location (label_true)))
    4196                 :            :     {
    4197                 :     831882 :       have_then_clause_p = true;
    4198                 :     831882 :       label_true = GOTO_DESTINATION (label_true);
    4199                 :            :     }
    4200                 :            :   else
    4201                 :    2750180 :     label_true = create_artificial_label (UNKNOWN_LOCATION);
    4202                 :    3582060 :   label_false = find_goto_label (TREE_OPERAND (expr, 2));
    4203                 :    3582060 :   if (label_false
    4204                 :     439571 :       && DECL_CONTEXT (GOTO_DESTINATION (label_false)) == current_function_decl
    4205                 :            :       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
    4206                 :            :          have different locations, otherwise we end up with incorrect
    4207                 :            :          location information on the branches.  */
    4208                 :    4021630 :       && (optimize
    4209                 :      64588 :           || !EXPR_HAS_LOCATION (expr)
    4210                 :      64257 :           || !rexpr_has_location (label_false)
    4211                 :       1017 :           || EXPR_LOCATION (expr) == rexpr_location (label_false)))
    4212                 :            :     {
    4213                 :     439481 :       have_else_clause_p = true;
    4214                 :     439481 :       label_false = GOTO_DESTINATION (label_false);
    4215                 :            :     }
    4216                 :            :   else
    4217                 :    3142580 :     label_false = create_artificial_label (UNKNOWN_LOCATION);
    4218                 :            : 
    4219                 :    3582060 :   gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
    4220                 :            :                                  &arm2);
    4221                 :    3582060 :   cond_stmt = gimple_build_cond (pred_code, arm1, arm2, label_true,
    4222                 :            :                                  label_false);
    4223                 :    3582060 :   gimple_set_no_warning (cond_stmt, TREE_NO_WARNING (COND_EXPR_COND (expr)));
    4224                 :    3582060 :   gimplify_seq_add_stmt (&seq, cond_stmt);
    4225                 :    3582060 :   gimple_stmt_iterator gsi = gsi_last (seq);
    4226                 :    3582060 :   maybe_fold_stmt (&gsi);
    4227                 :            : 
    4228                 :    3582060 :   label_cont = NULL_TREE;
    4229                 :    3582060 :   if (!have_then_clause_p)
    4230                 :            :     {
    4231                 :            :       /* For if (...) {} else { code; } put label_true after
    4232                 :            :          the else block.  */
    4233                 :    2750180 :       if (TREE_OPERAND (expr, 1) == NULL_TREE
    4234                 :     126954 :           && !have_else_clause_p
    4235                 :    2750840 :           && TREE_OPERAND (expr, 2) != NULL_TREE)
    4236                 :            :         label_cont = label_true;
    4237                 :            :       else
    4238                 :            :         {
    4239                 :    2749520 :           gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
    4240                 :    2749520 :           have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
    4241                 :            :           /* For if (...) { code; } else {} or
    4242                 :            :              if (...) { code; } else goto label; or
    4243                 :            :              if (...) { code; return; } else { ... }
    4244                 :            :              label_cont isn't needed.  */
    4245                 :    2749520 :           if (!have_else_clause_p
    4246                 :    2607320 :               && TREE_OPERAND (expr, 2) != NULL_TREE
    4247                 :    4396330 :               && gimple_seq_may_fallthru (seq))
    4248                 :            :             {
    4249                 :    1174050 :               gimple *g;
    4250                 :    1174050 :               label_cont = create_artificial_label (UNKNOWN_LOCATION);
    4251                 :            : 
    4252                 :    1174050 :               g = gimple_build_goto (label_cont);
    4253                 :            : 
    4254                 :            :               /* GIMPLE_COND's are very low level; they have embedded
    4255                 :            :                  gotos.  This particular embedded goto should not be marked
    4256                 :            :                  with the location of the original COND_EXPR, as it would
    4257                 :            :                  correspond to the COND_EXPR's condition, not the ELSE or the
    4258                 :            :                  THEN arms.  To avoid marking it with the wrong location, flag
    4259                 :            :                  it as "no location".  */
    4260                 :    1174050 :               gimple_set_do_not_emit_location (g);
    4261                 :            : 
    4262                 :    1174050 :               gimplify_seq_add_stmt (&seq, g);
    4263                 :            :             }
    4264                 :            :         }
    4265                 :            :     }
    4266                 :    3582060 :   if (!have_else_clause_p)
    4267                 :            :     {
    4268                 :    3142580 :       gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
    4269                 :    3142580 :       have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
    4270                 :            :     }
    4271                 :    3582060 :   if (label_cont)
    4272                 :    1174710 :     gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
    4273                 :            : 
    4274                 :    3582060 :   gimple_pop_condition (pre_p);
    4275                 :    3582060 :   gimple_seq_add_seq (pre_p, seq);
    4276                 :            : 
    4277                 :    3582060 :   if (ret == GS_ERROR)
    4278                 :            :     ; /* Do nothing.  */
    4279                 :    3582060 :   else if (have_then_clause_p || have_else_clause_p)
    4280                 :            :     ret = GS_ALL_DONE;
    4281                 :            :   else
    4282                 :            :     {
    4283                 :            :       /* Both arms are empty; replace the COND_EXPR with its predicate.  */
    4284                 :       2585 :       expr = TREE_OPERAND (expr, 0);
    4285                 :       2585 :       gimplify_stmt (&expr, pre_p);
    4286                 :            :     }
    4287                 :            : 
    4288                 :    3582060 :   *expr_p = NULL;
    4289                 :    3582060 :   return ret;
    4290                 :            : }
    4291                 :            : 
    4292                 :            : /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
    4293                 :            :    to be marked addressable.
    4294                 :            : 
    4295                 :            :    We cannot rely on such an expression being directly markable if a temporary
    4296                 :            :    has been created by the gimplification.  In this case, we create another
    4297                 :            :    temporary and initialize it with a copy, which will become a store after we
    4298                 :            :    mark it addressable.  This can happen if the front-end passed us something
    4299                 :            :    that it could not mark addressable yet, like a Fortran pass-by-reference
    4300                 :            :    parameter (int) floatvar.  */
    4301                 :            : 
    4302                 :            : static void
    4303                 :   20764600 : prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
    4304                 :            : {
    4305                 :   24200200 :   while (handled_component_p (*expr_p))
    4306                 :    3435540 :     expr_p = &TREE_OPERAND (*expr_p, 0);
    4307                 :   20764600 :   if (is_gimple_reg (*expr_p))
    4308                 :            :     {
    4309                 :            :       /* Do not allow an SSA name as the temporary.  */
    4310                 :      11031 :       tree var = get_initialized_tmp_var (*expr_p, seq_p, NULL, false);
    4311                 :      11031 :       DECL_GIMPLE_REG_P (var) = 0;
    4312                 :      11031 :       *expr_p = var;
    4313                 :            :     }
    4314                 :   20764600 : }
    4315                 :            : 
    4316                 :            : /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
    4317                 :            :    a call to __builtin_memcpy.  */
    4318                 :            : 
    4319                 :            : static enum gimplify_status
    4320                 :       1035 : gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
    4321                 :            :                                 gimple_seq *seq_p)
    4322                 :            : {
    4323                 :       1035 :   tree t, to, to_ptr, from, from_ptr;
    4324                 :       1035 :   gcall *gs;
    4325                 :       1035 :   location_t loc = EXPR_LOCATION (*expr_p);
    4326                 :            : 
    4327                 :       1035 :   to = TREE_OPERAND (*expr_p, 0);
    4328                 :       1035 :   from = TREE_OPERAND (*expr_p, 1);
    4329                 :            : 
    4330                 :            :   /* Mark the RHS addressable.  Beware that it may not be possible to do so
    4331                 :            :      directly if a temporary has been created by the gimplification.  */
    4332                 :       1035 :   prepare_gimple_addressable (&from, seq_p);
    4333                 :            : 
    4334                 :       1035 :   mark_addressable (from);
    4335                 :       1035 :   from_ptr = build_fold_addr_expr_loc (loc, from);
    4336                 :       1035 :   gimplify_arg (&from_ptr, seq_p, loc);
    4337                 :            : 
    4338                 :       1035 :   mark_addressable (to);
    4339                 :       1035 :   to_ptr = build_fold_addr_expr_loc (loc, to);
    4340                 :       1035 :   gimplify_arg (&to_ptr, seq_p, loc);
    4341                 :            : 
    4342                 :       1035 :   t = builtin_decl_implicit (BUILT_IN_MEMCPY);
    4343                 :            : 
    4344                 :       1035 :   gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
    4345                 :            : 
    4346                 :       1035 :   if (want_value)
    4347                 :            :     {
    4348                 :            :       /* tmp = memcpy() */
    4349                 :          8 :       t = create_tmp_var (TREE_TYPE (to_ptr));
    4350                 :          8 :       gimple_call_set_lhs (gs, t);
    4351                 :          8 :       gimplify_seq_add_stmt (seq_p, gs);
    4352                 :            : 
    4353                 :          8 :       *expr_p = build_simple_mem_ref (t);
    4354                 :          8 :       return GS_ALL_DONE;
    4355                 :            :     }
    4356                 :            : 
    4357                 :       1027 :   gimplify_seq_add_stmt (seq_p, gs);
    4358                 :       1027 :   *expr_p = NULL;
    4359                 :       1027 :   return GS_ALL_DONE;
    4360                 :            : }
    4361                 :            : 
    4362                 :            : /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
    4363                 :            :    a call to __builtin_memset.  In this case we know that the RHS is
    4364                 :            :    a CONSTRUCTOR with an empty element list.  */
    4365                 :            : 
    4366                 :            : static enum gimplify_status
    4367                 :          0 : gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
    4368                 :            :                                 gimple_seq *seq_p)
    4369                 :            : {
    4370                 :          0 :   tree t, from, to, to_ptr;
    4371                 :          0 :   gcall *gs;
    4372                 :          0 :   location_t loc = EXPR_LOCATION (*expr_p);
    4373                 :            : 
    4374                 :            :   /* Assert our assumptions, to abort instead of producing wrong code
    4375                 :            :      silently if they are not met.  Beware that the RHS CONSTRUCTOR might
    4376                 :            :      not be immediately exposed.  */
    4377                 :          0 :   from = TREE_OPERAND (*expr_p, 1);
    4378                 :          0 :   if (TREE_CODE (from) == WITH_SIZE_EXPR)
    4379                 :          0 :     from = TREE_OPERAND (from, 0);
    4380                 :            : 
    4381                 :          0 :   gcc_assert (TREE_CODE (from) == CONSTRUCTOR
    4382                 :            :               && vec_safe_is_empty (CONSTRUCTOR_ELTS (from)));
    4383                 :            : 
    4384                 :            :   /* Now proceed.  */
    4385                 :          0 :   to = TREE_OPERAND (*expr_p, 0);
    4386                 :            : 
    4387                 :          0 :   to_ptr = build_fold_addr_expr_loc (loc, to);
    4388                 :          0 :   gimplify_arg (&to_ptr, seq_p, loc);
    4389                 :          0 :   t = builtin_decl_implicit (BUILT_IN_MEMSET);
    4390                 :            : 
    4391                 :          0 :   gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
    4392                 :            : 
    4393                 :          0 :   if (want_value)
    4394                 :            :     {
    4395                 :            :       /* tmp = memset() */
    4396                 :          0 :       t = create_tmp_var (TREE_TYPE (to_ptr));
    4397                 :          0 :       gimple_call_set_lhs (gs, t);
    4398                 :          0 :       gimplify_seq_add_stmt (seq_p, gs);
    4399                 :            : 
    4400                 :          0 :       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
    4401                 :          0 :       return GS_ALL_DONE;
    4402                 :            :     }
    4403                 :            : 
    4404                 :          0 :   gimplify_seq_add_stmt (seq_p, gs);
    4405                 :          0 :   *expr_p = NULL;
    4406                 :          0 :   return GS_ALL_DONE;
    4407                 :            : }
    4408                 :            : 
    4409                 :            : /* A subroutine of gimplify_init_ctor_preeval.  Called via walk_tree,
    4410                 :            :    determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
    4411                 :            :    assignment.  Return non-null if we detect a potential overlap.  */
    4412                 :            : 
    4413                 :            : struct gimplify_init_ctor_preeval_data
    4414                 :            : {
    4415                 :            :   /* The base decl of the lhs object.  May be NULL, in which case we
    4416                 :            :      have to assume the lhs is indirect.  */
    4417                 :            :   tree lhs_base_decl;
    4418                 :            : 
    4419                 :            :   /* The alias set of the lhs object.  */
    4420                 :            :   alias_set_type lhs_alias_set;
    4421                 :            : };
    4422                 :            : 
    4423                 :            : static tree
    4424                 :      61947 : gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
    4425                 :            : {
    4426                 :      61947 :   struct gimplify_init_ctor_preeval_data *data
    4427                 :            :     = (struct gimplify_init_ctor_preeval_data *) xdata;
    4428                 :      61947 :   tree t = *tp;
    4429                 :            : 
    4430                 :            :   /* If we find the base object, obviously we have overlap.  */
    4431                 :      61947 :   if (data->lhs_base_decl == t)
    4432                 :            :     return t;
    4433                 :            : 
    4434                 :            :   /* If the constructor component is indirect, determine if we have a
    4435                 :            :      potential overlap with the lhs.  The only bits of information we
    4436                 :            :      have to go on at this point are addressability and alias sets.  */
    4437                 :      61947 :   if ((INDIRECT_REF_P (t)
    4438                 :      61947 :        || TREE_CODE (t) == MEM_REF)
    4439                 :        163 :       && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
    4440                 :      62110 :       && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
    4441                 :            :     return t;
    4442                 :            : 
    4443                 :            :   /* If the constructor component is a call, determine if it can hide a
    4444                 :            :      potential overlap with the lhs through an INDIRECT_REF like above.
    4445                 :            :      ??? Ugh - this is completely broken.  In fact this whole analysis
    4446                 :            :      doesn't look conservative.  */
    4447                 :      61784 :   if (TREE_CODE (t) == CALL_EXPR)
    4448                 :            :     {
    4449                 :          0 :       tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
    4450                 :            : 
    4451                 :          0 :       for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
    4452                 :          0 :         if (POINTER_TYPE_P (TREE_VALUE (type))
    4453                 :          0 :             && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
    4454                 :          0 :             && alias_sets_conflict_p (data->lhs_alias_set,
    4455                 :            :                                       get_alias_set
    4456                 :          0 :                                         (TREE_TYPE (TREE_VALUE (type)))))
    4457                 :            :           return t;
    4458                 :            :     }
    4459                 :            : 
    4460                 :      61784 :   if (IS_TYPE_OR_DECL_P (t))
    4461                 :        211 :     *walk_subtrees = 0;
    4462                 :            :   return NULL;
    4463                 :            : }
    4464                 :            : 
    4465                 :            : /* A subroutine of gimplify_init_constructor.  Pre-evaluate EXPR,
    4466                 :            :    force values that overlap with the lhs (as described by *DATA)
    4467                 :            :    into temporaries.  */
    4468                 :            : 
    4469                 :            : static void
    4470                 :     272458 : gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
    4471                 :            :                             struct gimplify_init_ctor_preeval_data *data)
    4472                 :            : {
    4473                 :     272458 :   enum gimplify_status one;
    4474                 :            : 
    4475                 :            :   /* If the value is constant, then there's nothing to pre-evaluate.  */
    4476                 :     272458 :   if (TREE_CONSTANT (*expr_p))
    4477                 :            :     {
    4478                 :            :       /* Ensure it does not have side effects, it might contain a reference to
    4479                 :            :          the object we're initializing.  */
    4480                 :     102383 :       gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
    4481                 :            :       return;
    4482                 :            :     }
    4483                 :            : 
    4484                 :            :   /* If the type has non-trivial constructors, we can't pre-evaluate.  */
    4485                 :     170075 :   if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
    4486                 :            :     return;
    4487                 :            : 
    4488                 :            :   /* Recurse for nested constructors.  */
    4489                 :     170075 :   if (TREE_CODE (*expr_p) == CONSTRUCTOR)
    4490                 :            :     {
    4491                 :      53064 :       unsigned HOST_WIDE_INT ix;
    4492                 :      53064 :       constructor_elt *ce;
    4493                 :      53064 :       vec<constructor_elt, va_gc> *v = CONSTRUCTOR_ELTS (*expr_p);
    4494                 :            : 
    4495                 :     189381 :       FOR_EACH_VEC_SAFE_ELT (v, ix, ce)
    4496                 :     136317 :         gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
    4497                 :            : 
    4498                 :            :       return;
    4499                 :            :     }
    4500                 :            : 
    4501                 :            :   /* If this is a variable sized type, we must remember the size.  */
    4502                 :     117011 :   maybe_with_size_expr (expr_p);
    4503                 :            : 
    4504                 :            :   /* Gimplify the constructor element to something appropriate for the rhs
    4505                 :            :      of a MODIFY_EXPR.  Given that we know the LHS is an aggregate, we know
    4506                 :            :      the gimplifier will consider this a store to memory.  Doing this
    4507                 :            :      gimplification now means that we won't have to deal with complicated
    4508                 :            :      language-specific trees, nor trees like SAVE_EXPR that can induce
    4509                 :            :      exponential search behavior.  */
    4510                 :     117011 :   one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
    4511                 :     117011 :   if (one == GS_ERROR)
    4512                 :            :     {
    4513                 :          0 :       *expr_p = NULL;
    4514                 :          0 :       return;
    4515                 :            :     }
    4516                 :            : 
    4517                 :            :   /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
    4518                 :            :      with the lhs, since "a = { .x=a }" doesn't make sense.  This will
    4519                 :            :      always be true for all scalars, since is_gimple_mem_rhs insists on a
    4520                 :            :      temporary variable for them.  */
    4521                 :     117011 :   if (DECL_P (*expr_p))
    4522                 :            :     return;
    4523                 :            : 
    4524                 :            :   /* If this is of variable size, we have no choice but to assume it doesn't
    4525                 :            :      overlap since we can't make a temporary for it.  */
    4526                 :      61729 :   if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
    4527                 :            :     return;
    4528                 :            : 
    4529                 :            :   /* Otherwise, we must search for overlap ...  */
    4530                 :      61729 :   if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
    4531                 :            :     return;
    4532                 :            : 
    4533                 :            :   /* ... and if found, force the value into a temporary.  */
    4534                 :        163 :   *expr_p = get_formal_tmp_var (*expr_p, pre_p);
    4535                 :            : }
    4536                 :            : 
    4537                 :            : /* A subroutine of gimplify_init_ctor_eval.  Create a loop for
    4538                 :            :    a RANGE_EXPR in a CONSTRUCTOR for an array.
    4539                 :            : 
    4540                 :            :       var = lower;
    4541                 :            :     loop_entry:
    4542                 :            :       object[var] = value;
    4543                 :            :       if (var == upper)
    4544                 :            :         goto loop_exit;
    4545                 :            :       var = var + 1;
    4546                 :            :       goto loop_entry;
    4547                 :            :     loop_exit:
    4548                 :            : 
    4549                 :            :    We increment var _after_ the loop exit check because we might otherwise
    4550                 :            :    fail if upper == TYPE_MAX_VALUE (type for upper).
    4551                 :            : 
    4552                 :            :    Note that we never have to deal with SAVE_EXPRs here, because this has
    4553                 :            :    already been taken care of for us, in gimplify_init_ctor_preeval().  */
    4554                 :            : 
    4555                 :            : static void gimplify_init_ctor_eval (tree, vec<constructor_elt, va_gc> *,
    4556                 :            :                                      gimple_seq *, bool);
    4557                 :            : 
    4558                 :            : static void
    4559                 :        401 : gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
    4560                 :            :                                tree value, tree array_elt_type,
    4561                 :            :                                gimple_seq *pre_p, bool cleared)
    4562                 :            : {
    4563                 :        401 :   tree loop_entry_label, loop_exit_label, fall_thru_label;
    4564                 :        401 :   tree var, var_type, cref, tmp;
    4565                 :            : 
    4566                 :        401 :   loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
    4567                 :        401 :   loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
    4568                 :        401 :   fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
    4569                 :            : 
    4570                 :            :   /* Create and initialize the index variable.  */
    4571                 :        401 :   var_type = TREE_TYPE (upper);
    4572                 :        401 :   var = create_tmp_var (var_type);
    4573                 :        401 :   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
    4574                 :            : 
    4575                 :            :   /* Add the loop entry label.  */
    4576                 :        401 :   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
    4577                 :            : 
    4578                 :            :   /* Build the reference.  */
    4579                 :        401 :   cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
    4580                 :            :                  var, NULL_TREE, NULL_TREE);
    4581                 :            : 
    4582                 :            :   /* If we are a constructor, just call gimplify_init_ctor_eval to do
    4583                 :            :      the store.  Otherwise just assign value to the reference.  */
    4584                 :            : 
    4585                 :        401 :   if (TREE_CODE (value) == CONSTRUCTOR)
    4586                 :            :     /* NB we might have to call ourself recursively through
    4587                 :            :        gimplify_init_ctor_eval if the value is a constructor.  */
    4588                 :         82 :     gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
    4589                 :            :                              pre_p, cleared);
    4590                 :            :   else
    4591                 :        319 :     gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
    4592                 :            : 
    4593                 :            :   /* We exit the loop when the index var is equal to the upper bound.  */
    4594                 :        802 :   gimplify_seq_add_stmt (pre_p,
    4595                 :        401 :                          gimple_build_cond (EQ_EXPR, var, upper,
    4596                 :            :                                             loop_exit_label, fall_thru_label));
    4597                 :            : 
    4598                 :        401 :   gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
    4599                 :            : 
    4600                 :            :   /* Otherwise, increment the index var...  */
    4601                 :        401 :   tmp = build2 (PLUS_EXPR, var_type, var,
    4602                 :            :                 fold_convert (var_type, integer_one_node));
    4603                 :        401 :   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
    4604                 :            : 
    4605                 :            :   /* ...and jump back to the loop entry.  */
    4606                 :        401 :   gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
    4607                 :            : 
    4608                 :            :   /* Add the loop exit label.  */
    4609                 :        401 :   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
    4610                 :        401 : }
    4611                 :            : 
    4612                 :            : /* Return true if FDECL is accessing a field that is zero sized.  */
    4613                 :            : 
    4614                 :            : static bool
    4615                 :    2049990 : zero_sized_field_decl (const_tree fdecl)
    4616                 :            : {
    4617                 :    1685780 :   if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
    4618                 :    3735770 :       && integer_zerop (DECL_SIZE (fdecl)))
    4619                 :       1878 :     return true;
    4620                 :            :   return false;
    4621                 :            : }
    4622                 :            : 
    4623                 :            : /* Return true if TYPE is zero sized.  */
    4624                 :            : 
    4625                 :            : static bool
    4626                 :   30447700 : zero_sized_type (const_tree type)
    4627                 :            : {
    4628                 :    1756930 :   if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
    4629                 :   32204700 :       && integer_zerop (TYPE_SIZE (type)))
    4630                 :       1233 :     return true;
    4631                 :            :   return false;
    4632                 :            : }
    4633                 :            : 
    4634                 :            : /* A subroutine of gimplify_init_constructor.  Generate individual
    4635                 :            :    MODIFY_EXPRs for a CONSTRUCTOR.  OBJECT is the LHS against which the
    4636                 :            :    assignments should happen.  ELTS is the CONSTRUCTOR_ELTS of the
    4637                 :            :    CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
    4638                 :            :    zeroed first.  */
    4639                 :            : 
    4640                 :            : static void
    4641                 :     898478 : gimplify_init_ctor_eval (tree object, vec<constructor_elt, va_gc> *elts,
    4642                 :            :                          gimple_seq *pre_p, bool cleared)
    4643                 :            : {
    4644                 :     898478 :   tree array_elt_type = NULL;
    4645                 :     898478 :   unsigned HOST_WIDE_INT ix;
    4646                 :     898478 :   tree purpose, value;
    4647                 :            : 
    4648                 :     898478 :   if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
    4649                 :     106061 :     array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
    4650                 :            : 
    4651                 :    6374080 :   FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
    4652                 :            :     {
    4653                 :    2288810 :       tree cref;
    4654                 :            : 
    4655                 :            :       /* NULL values are created above for gimplification errors.  */
    4656                 :    2288810 :       if (value == NULL)
    4657                 :          0 :         continue;
    4658                 :            : 
    4659                 :    2288810 :       if (cleared && initializer_zerop (value))
    4660                 :      79193 :         continue;
    4661                 :            : 
    4662                 :            :       /* ??? Here's to hoping the front end fills in all of the indices,
    4663                 :            :          so we don't have to figure out what's missing ourselves.  */
    4664                 :    2209620 :       gcc_assert (purpose);
    4665                 :            : 
    4666                 :            :       /* Skip zero-sized fields, unless value has side-effects.  This can
    4667                 :            :          happen with calls to functions returning a zero-sized type, which
    4668                 :            :          we shouldn't discard.  As a number of downstream passes don't
    4669                 :            :          expect sets of zero-sized fields, we rely on the gimplification of
    4670                 :            :          the MODIFY_EXPR we make below to drop the assignment statement.  */
    4671                 :    2209620 :       if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
    4672                 :       1878 :         continue;
    4673                 :            : 
    4674                 :            :       /* If we have a RANGE_EXPR, we have to build a loop to assign the
    4675                 :            :          whole range.  */
    4676                 :    2207740 :       if (TREE_CODE (purpose) == RANGE_EXPR)
    4677                 :            :         {
    4678                 :        411 :           tree lower = TREE_OPERAND (purpose, 0);
    4679                 :        411 :           tree upper = TREE_OPERAND (purpose, 1);
    4680                 :            : 
    4681                 :            :           /* If the lower bound is equal to upper, just treat it as if
    4682                 :            :              upper was the index.  */
    4683                 :        411 :           if (simple_cst_equal (lower, upper))
    4684                 :            :             purpose = upper;
    4685                 :            :           else
    4686                 :            :             {
    4687                 :        401 :               gimplify_init_ctor_eval_range (object, lower, upper, value,
    4688                 :            :                                              array_elt_type, pre_p, cleared);
    4689                 :        401 :               continue;
    4690                 :            :             }
    4691                 :            :         }
    4692                 :            : 
    4693                 :    2207340 :       if (array_elt_type)
    4694                 :            :         {
    4695                 :            :           /* Do not use bitsizetype for ARRAY_REF indices.  */
    4696                 :     368967 :           if (TYPE_DOMAIN (TREE_TYPE (object)))
    4697                 :     368967 :             purpose
    4698                 :     368967 :               = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
    4699                 :            :                               purpose);
    4700                 :     368967 :           cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
    4701                 :            :                          purpose, NULL_TREE, NULL_TREE);
    4702                 :            :         }
    4703                 :            :       else
    4704                 :            :         {
    4705                 :    1838380 :           gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
    4706                 :    1838380 :           cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
    4707                 :            :                          unshare_expr (object), purpose, NULL_TREE);
    4708                 :            :         }
    4709                 :            : 
    4710                 :    2207340 :       if (TREE_CODE (value) == CONSTRUCTOR
    4711                 :    2275880 :           && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
    4712                 :      68539 :         gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
    4713                 :            :                                  pre_p, cleared);
    4714                 :            :       else
    4715                 :            :         {
    4716                 :    2138800 :           tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
    4717                 :    2138800 :           gimplify_and_add (init, pre_p);
    4718                 :    2138800 :           ggc_free (init);
    4719                 :            :         }
    4720                 :            :     }
    4721                 :     898478 : }
    4722                 :            : 
    4723                 :            : /* Return the appropriate RHS predicate for this LHS.  */
    4724                 :            : 
    4725                 :            : gimple_predicate
    4726                 :   31155200 : rhs_predicate_for (tree lhs)
    4727                 :            : {
    4728                 :   31155200 :   if (is_gimple_reg (lhs))
    4729                 :            :     return is_gimple_reg_rhs_or_call;
    4730                 :            :   else
    4731                 :    7777570 :     return is_gimple_mem_rhs_or_call;
    4732                 :            : }
    4733                 :            : 
    4734                 :            : /* Return the initial guess for an appropriate RHS predicate for this LHS,
    4735                 :            :    before the LHS has been gimplified.  */
    4736                 :            : 
    4737                 :            : static gimple_predicate
    4738                 :   30446500 : initial_rhs_predicate_for (tree lhs)
    4739                 :            : {
    4740                 :   30446500 :   if (is_gimple_reg_type (TREE_TYPE (lhs)))
    4741                 :            :     return is_gimple_reg_rhs_or_call;
    4742                 :            :   else
    4743                 :    1755740 :     return is_gimple_mem_rhs_or_call;
    4744                 :            : }
    4745                 :            : 
    4746                 :            : /* Gimplify a C99 compound literal expression.  This just means adding
    4747                 :            :    the DECL_EXPR before the current statement and using its anonymous
    4748                 :            :    decl instead.  */
    4749                 :            : 
    4750                 :            : static enum gimplify_status
    4751                 :      22152 : gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p,
    4752                 :            :                                 bool (*gimple_test_f) (tree),
    4753                 :            :                                 fallback_t fallback)
    4754                 :            : {
    4755                 :      22152 :   tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
    4756                 :      22152 :   tree decl = DECL_EXPR_DECL (decl_s);
    4757                 :      22152 :   tree init = DECL_INITIAL (decl);
    4758                 :            :   /* Mark the decl as addressable if the compound literal
    4759                 :            :      expression is addressable now, otherwise it is marked too late
    4760                 :            :      after we gimplify the initialization expression.  */
    4761                 :      22152 :   if (TREE_ADDRESSABLE (*expr_p))
    4762                 :        302 :     TREE_ADDRESSABLE (decl) = 1;
    4763                 :            :   /* Otherwise, if we don't need an lvalue and have a literal directly
    4764                 :            :      substitute it.  Check if it matches the gimple predicate, as
    4765                 :            :      otherwise we'd generate a new temporary, and we can as well just
    4766                 :            :      use the decl we already have.  */
    4767                 :      21850 :   else if (!TREE_ADDRESSABLE (decl)
    4768                 :      21850 :            && !TREE_THIS_VOLATILE (decl)
    4769                 :      21845 :            && init
    4770                 :      21837 :            && (fallback & fb_lvalue) == 0
    4771                 :      43609 :            && gimple_test_f (init))
    4772                 :            :     {
    4773                 :      20957 :       *expr_p = init;
    4774                 :      20957 :       return GS_OK;
    4775                 :            :     }
    4776                 :            : 
    4777                 :            :   /* Preliminarily mark non-addressed complex variables as eligible
    4778                 :            :      for promotion to gimple registers.  We'll transform their uses
    4779                 :            :      as we find them.  */
    4780                 :       1195 :   if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
    4781                 :       1188 :        || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
    4782                 :        845 :       && !TREE_THIS_VOLATILE (decl)
    4783                 :       2040 :       && !needs_to_live_in_memory (decl))
    4784                 :        778 :     DECL_GIMPLE_REG_P (decl) = 1;
    4785                 :            : 
    4786                 :            :   /* If the decl is not addressable, then it is being used in some
    4787                 :            :      expression or on the right hand side of a statement, and it can
    4788                 :            :      be put into a readonly data section.  */
    4789                 :       1195 :   if (!TREE_ADDRESSABLE (decl) && (fallback & fb_lvalue) == 0)
    4790                 :        807 :     TREE_READONLY (decl) = 1;
    4791                 :            : 
    4792                 :            :   /* This decl isn't mentioned in the enclosing block, so add it to the
    4793                 :            :      list of temps.  FIXME it seems a bit of a kludge to say that
    4794                 :            :      anonymous artificial vars aren't pushed, but everything else is.  */
    4795                 :       2389 :   if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
    4796                 :          0 :     gimple_add_tmp_var (decl);
    4797                 :            : 
    4798                 :       1195 :   gimplify_and_add (decl_s, pre_p);
    4799                 :       1195 :   *expr_p = decl;
    4800                 :       1195 :   return GS_OK;
    4801                 :            : }
    4802                 :            : 
    4803                 :            : /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
    4804                 :            :    return a new CONSTRUCTOR if something changed.  */
    4805                 :            : 
    4806                 :            : static tree
    4807                 :    1275240 : optimize_compound_literals_in_ctor (tree orig_ctor)
    4808                 :            : {
    4809                 :    1275240 :   tree ctor = orig_ctor;
    4810                 :    1275240 :   vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (ctor);
    4811                 :    1275240 :   unsigned int idx, num = vec_safe_length (elts);
    4812                 :            : 
    4813                 :    4227900 :   for (idx = 0; idx < num; idx++)
    4814                 :            :     {
    4815                 :    2952660 :       tree value = (*elts)[idx].value;
    4816                 :    2952660 :       tree newval = value;
    4817                 :    2952660 :       if (TREE_CODE (value) == CONSTRUCTOR)
    4818                 :     227589 :         newval = optimize_compound_literals_in_ctor (value);
    4819                 :    2725070 :       else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
    4820                 :            :         {
    4821                 :         48 :           tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
    4822                 :         48 :           tree decl = DECL_EXPR_DECL (decl_s);
    4823                 :         48 :           tree init = DECL_INITIAL (decl);
    4824                 :            : 
    4825                 :         48 :           if (!TREE_ADDRESSABLE (value)
    4826                 :         48 :               && !TREE_ADDRESSABLE (decl)
    4827                 :         48 :               && init
    4828                 :         48 :               && TREE_CODE (init) == CONSTRUCTOR)
    4829                 :         47 :             newval = optimize_compound_literals_in_ctor (init);
    4830                 :            :         }
    4831                 :    2952660 :       if (newval == value)
    4832                 :    2952600 :         continue;
    4833                 :            : 
    4834                 :         55 :       if (ctor == orig_ctor)
    4835                 :            :         {
    4836                 :         44 :           ctor = copy_node (orig_ctor);
    4837                 :         44 :           CONSTRUCTOR_ELTS (ctor) = vec_safe_copy (elts);
    4838                 :         44 :           elts = CONSTRUCTOR_ELTS (ctor);
    4839                 :            :         }
    4840                 :         55 :       (*elts)[idx].value = newval;
    4841                 :            :     }
    4842                 :    1275240 :   return ctor;
    4843                 :            : }
    4844                 :            : 
    4845                 :            : /* A subroutine of gimplify_modify_expr.  Break out elements of a
    4846                 :            :    CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
    4847                 :            : 
    4848                 :            :    Note that we still need to clear any elements that don't have explicit
    4849                 :            :    initializers, so if not all elements are initialized we keep the
    4850                 :            :    original MODIFY_EXPR, we just remove all of the constructor elements.
    4851                 :            : 
    4852                 :            :    If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
    4853                 :            :    GS_ERROR if we would have to create a temporary when gimplifying
    4854                 :            :    this constructor.  Otherwise, return GS_OK.
    4855                 :            : 
    4856                 :            :    If NOTIFY_TEMP_CREATION is false, just do the gimplification.  */
    4857                 :            : 
    4858                 :            : static enum gimplify_status
    4859                 :    1047610 : gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
    4860                 :            :                            bool want_value, bool notify_temp_creation)
    4861                 :            : {
    4862                 :    1047610 :   tree object, ctor, type;
    4863                 :    1047610 :   enum gimplify_status ret;
    4864                 :    1047610 :   vec<constructor_elt, va_gc> *elts;
    4865                 :            : 
    4866                 :    1047610 :   gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
    4867                 :            : 
    4868                 :    1047610 :   if (!notify_temp_creation)
    4869                 :            :     {
    4870                 :    1046040 :       ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
    4871                 :            :                            is_gimple_lvalue, fb_lvalue);
    4872                 :    1046040 :       if (ret == GS_ERROR)
    4873                 :            :         return ret;
    4874                 :            :     }
    4875                 :            : 
    4876                 :    1047610 :   object = TREE_OPERAND (*expr_p, 0);
    4877                 :    3142820 :   ctor = TREE_OPERAND (*expr_p, 1)
    4878                 :    1047610 :     = optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
    4879                 :    1047610 :   type = TREE_TYPE (ctor);
    4880                 :    1047610 :   elts = CONSTRUCTOR_ELTS (ctor);
    4881                 :    1047610 :   ret = GS_ALL_DONE;
    4882                 :            : 
    4883                 :    1047610 :   switch (TREE_CODE (type))
    4884                 :            :     {
    4885                 :    1042360 :     case RECORD_TYPE:
    4886                 :    1042360 :     case UNION_TYPE:
    4887                 :    1042360 :     case QUAL_UNION_TYPE:
    4888                 :    1042360 :     case ARRAY_TYPE:
    4889                 :    1042360 :       {
    4890                 :    1042360 :         struct gimplify_init_ctor_preeval_data preeval_data;
    4891                 :    1042360 :         HOST_WIDE_INT num_ctor_elements, num_nonzero_elements;
    4892                 :    1042360 :         HOST_WIDE_INT num_unique_nonzero_elements;
    4893                 :    1042360 :         bool cleared, complete_p, valid_const_initializer;
    4894                 :            :         /* Use readonly data for initializers of this or smaller size
    4895                 :            :            regardless of the num_nonzero_elements / num_unique_nonzero_elements
    4896                 :            :            ratio.  */
    4897                 :    1042360 :         const HOST_WIDE_INT min_unique_size = 64;
    4898                 :            :         /* If num_nonzero_elements / num_unique_nonzero_elements ratio
    4899                 :            :            is smaller than this, use readonly data.  */
    4900                 :    1042360 :         const int unique_nonzero_ratio = 8;
    4901                 :            : 
    4902                 :            :         /* Aggregate types must lower constructors to initialization of
    4903                 :            :            individual elements.  The exception is that a CONSTRUCTOR node
    4904                 :            :            with no elements indicates zero-initialization of the whole.  */
    4905                 :    1042360 :         if (vec_safe_is_empty (elts))
    4906                 :            :           {
    4907                 :     206718 :             if (notify_temp_creation)
    4908                 :       3015 :               return GS_OK;
    4909                 :     206876 :             break;
    4910                 :            :           }
    4911                 :            : 
    4912                 :            :         /* Fetch information about the constructor to direct later processing.
    4913                 :            :            We might want to make static versions of it in various cases, and
    4914                 :            :            can only do so if it known to be a valid constant initializer.  */
    4915                 :     835647 :         valid_const_initializer
    4916                 :     835647 :           = categorize_ctor_elements (ctor, &num_nonzero_elements,
    4917                 :            :                                       &num_unique_nonzero_elements,
    4918                 :            :                                       &num_ctor_elements, &complete_p);
    4919                 :            : 
    4920                 :            :         /* If a const aggregate variable is being initialized, then it
    4921                 :            :            should never be a lose to promote the variable to be static.  */
    4922                 :     835647 :         if (valid_const_initializer
    4923                 :     397465 :             && num_nonzero_elements > 1
    4924                 :     319330 :             && TREE_READONLY (object)
    4925                 :       1803 :             && VAR_P (object)
    4926                 :       1494 :             && !DECL_REGISTER (object)
    4927                 :       1487 :             && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object))
    4928                 :            :             /* For ctors that have many repeated nonzero elements
    4929                 :            :                represented through RANGE_EXPRs, prefer initializing
    4930                 :            :                those through runtime loops over copies of large amounts
    4931                 :            :                of data from readonly data section.  */
    4932                 :     835647 :             && (num_unique_nonzero_elements
    4933                 :        158 :                 > num_nonzero_elements / unique_nonzero_ratio
    4934                 :          0 :                 || ((unsigned HOST_WIDE_INT) int_size_in_bytes (type)
    4935                 :            :                     <= (unsigned HOST_WIDE_INT) min_unique_size)))
    4936                 :            :           {
    4937                 :        158 :             if (notify_temp_creation)
    4938                 :            :               return GS_ERROR;
    4939                 :        158 :             DECL_INITIAL (object) = ctor;
    4940                 :        158 :             TREE_STATIC (object) = 1;
    4941                 :        158 :             if (!DECL_NAME (object))
    4942                 :         62 :               DECL_NAME (object) = create_tmp_var_name ("C");
    4943                 :        158 :             walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
    4944                 :            : 
    4945                 :            :             /* ??? C++ doesn't automatically append a .<number> to the
    4946                 :            :                assembler name, and even when it does, it looks at FE private
    4947                 :            :                data structures to figure out what that number should be,
    4948                 :            :                which are not set for this variable.  I suppose this is
    4949                 :            :                important for local statics for inline functions, which aren't
    4950                 :            :                "local" in the object file sense.  So in order to get a unique
    4951                 :            :                TU-local symbol, we must invoke the lhd version now.  */
    4952                 :        158 :             lhd_set_decl_assembler_name (object);
    4953                 :            : 
    4954                 :        158 :             *expr_p = NULL_TREE;
    4955                 :        158 :             break;
    4956                 :            :           }
    4957                 :            : 
    4958                 :            :         /* If there are "lots" of initialized elements, even discounting
    4959                 :            :            those that are not address constants (and thus *must* be
    4960                 :            :            computed at runtime), then partition the constructor into
    4961                 :            :            constant and non-constant parts.  Block copy the constant
    4962                 :            :            parts in, then generate code for the non-constant parts.  */
    4963                 :            :         /* TODO.  There's code in cp/typeck.c to do this.  */
    4964                 :            : 
    4965                 :     835489 :         if (int_size_in_bytes (TREE_TYPE (ctor)) < 0)
    4966                 :            :           /* store_constructor will ignore the clearing of variable-sized
    4967                 :            :              objects.  Initializers for such objects must explicitly set
    4968                 :            :              every field that needs to be set.  */
    4969                 :            :           cleared = false;
    4970                 :     835469 :         else if (!complete_p)
    4971                 :            :           /* If the constructor isn't complete, clear the whole object
    4972                 :            :              beforehand, unless CONSTRUCTOR_NO_CLEARING is set on it.
    4973                 :            : 
    4974                 :            :              ??? This ought not to be needed.  For any element not present
    4975                 :            :              in the initializer, we should simply set them to zero.  Except
    4976                 :            :              we'd need to *find* the elements that are not present, and that
    4977                 :            :              requires trickery to avoid quadratic compile-time behavior in
    4978                 :            :              large cases or excessive memory use in small cases.  */
    4979                 :      93382 :           cleared = !CONSTRUCTOR_NO_CLEARING (ctor);
    4980                 :     742087 :         else if (num_ctor_elements - num_nonzero_elements
    4981                 :     742087 :                  > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
    4982                 :     742087 :                  && num_nonzero_elements < num_ctor_elements / 4)
    4983                 :            :           /* If there are "lots" of zeros, it's more efficient to clear
    4984                 :            :              the memory and then set the nonzero elements.  */
    4985                 :            :           cleared = true;
    4986                 :            :         else
    4987                 :            :           cleared = false;
    4988                 :            : 
    4989                 :            :         /* If there are "lots" of initialized elements, and all of them
    4990                 :            :            are valid address constants, then the entire initializer can
    4991                 :            :            be dropped to memory, and then memcpy'd out.  Don't do this
    4992                 :            :            for sparse arrays, though, as it's more efficient to follow
    4993                 :            :            the standard CONSTRUCTOR behavior of memset followed by
    4994                 :            :            individual element initialization.  Also don't do this for small
    4995                 :            :            all-zero initializers (which aren't big enough to merit
    4996                 :            :            clearing), and don't try to make bitwise copies of
    4997                 :            :            TREE_ADDRESSABLE types.  */
    4998                 :            : 
    4999                 :     835489 :         if (valid_const_initializer
    5000                 :     835489 :             && !(cleared || num_nonzero_elements == 0)
    5001                 :     265494 :             && !TREE_ADDRESSABLE (type))
    5002                 :            :           {
    5003                 :     264758 :             HOST_WIDE_INT size = int_size_in_bytes (type);
    5004                 :     264758 :             unsigned int align;
    5005                 :            : 
    5006                 :            :             /* ??? We can still get unbounded array types, at least
    5007                 :            :                from the C++ front end.  This seems wrong, but attempt
    5008                 :            :                to work around it for now.  */
    5009                 :     264758 :             if (size < 0)
    5010                 :            :               {
    5011                 :         16 :                 size = int_size_in_bytes (TREE_TYPE (object));
    5012                 :         16 :                 if (size >= 0)
    5013                 :          0 :                   TREE_TYPE (ctor) = type = TREE_TYPE (object);
    5014                 :            :               }
    5015                 :            : 
    5016                 :            :             /* Find the maximum alignment we can assume for the object.  */
    5017                 :            :             /* ??? Make use of DECL_OFFSET_ALIGN.  */
    5018                 :     264758 :             if (DECL_P (object))
    5019                 :     252791 :               align = DECL_ALIGN (object);
    5020                 :            :             else
    5021                 :      11967 :               align = TYPE_ALIGN (type);
    5022                 :            : 
    5023                 :            :             /* Do a block move either if the size is so small as to make
    5024                 :            :                each individual move a sub-unit move on average, or if it
    5025                 :            :                is so large as to make individual moves inefficient.  */
    5026                 :     264758 :             if (size > 0
    5027                 :     264742 :                 && num_nonzero_elements > 1
    5028                 :            :                 /* For ctors that have many repeated nonzero elements
    5029                 :            :                    represented through RANGE_EXPRs, prefer initializing
    5030                 :            :                    those through runtime loops over copies of large amounts
    5031                 :            :                    of data from readonly data section.  */
    5032                 :     243942 :                 && (num_unique_nonzero_elements
    5033                 :     243942 :                     > num_nonzero_elements / unique_nonzero_ratio
    5034                 :         28 :                     || size <= min_unique_size)
    5035                 :     508672 :                 && (size < num_nonzero_elements
    5036                 :     243906 :                     || !can_move_by_pieces (size, align)))
    5037                 :            :               {
    5038                 :       2746 :                 if (notify_temp_creation)
    5039                 :            :                   return GS_ERROR;
    5040                 :            : 
    5041                 :       1373 :                 walk_tree (&ctor, force_labels_r, NULL, NULL);
    5042                 :       1373 :                 ctor = tree_output_constant_def (ctor);
    5043                 :       1373 :                 if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
    5044                 :          0 :                   ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
    5045                 :       1373 :                 TREE_OPERAND (*expr_p, 1) = ctor;
    5046                 :            : 
    5047                 :            :                 /* This is no longer an assignment of a CONSTRUCTOR, but
    5048                 :            :                    we still may have processing to do on the LHS.  So
    5049                 :            :                    pretend we didn't do anything here to let that happen.  */
    5050                 :       1373 :                 return GS_UNHANDLED;
    5051                 :            :               }
    5052                 :            :           }
    5053                 :            : 
    5054                 :            :         /* If the target is volatile, we have non-zero elements and more than
    5055                 :            :            one field to assign, initialize the target from a temporary.  */
    5056                 :     832743 :         if (TREE_THIS_VOLATILE (object)
    5057                 :         95 :             && !TREE_ADDRESSABLE (type)
    5058                 :         90 :             && (num_nonzero_elements > 0 || !cleared)
    5059                 :     832833 :             && vec_safe_length (elts) > 1)
    5060                 :            :           {
    5061                 :         77 :             tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type));
    5062                 :         77 :             TREE_OPERAND (*expr_p, 0) = temp;
    5063                 :         77 :             *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
    5064                 :            :                               *expr_p,
    5065                 :            :                               build2 (MODIFY_EXPR, void_type_node,
    5066                 :            :                                       object, temp));
    5067                 :         77 :             return GS_OK;
    5068                 :            :           }
    5069                 :            : 
    5070                 :     832666 :         if (notify_temp_creation)
    5071                 :            :           return GS_OK;
    5072                 :            : 
    5073                 :            :         /* If there are nonzero elements and if needed, pre-evaluate to capture
    5074                 :            :            elements overlapping with the lhs into temporaries.  We must do this
    5075                 :            :            before clearing to fetch the values before they are zeroed-out.  */
    5076                 :     832474 :         if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
    5077                 :            :           {
    5078                 :     136141 :             preeval_data.lhs_base_decl = get_base_address (object);
    5079                 :     136141 :             if (!DECL_P (preeval_data.lhs_base_decl))
    5080                 :      32858 :               preeval_data.lhs_base_decl = NULL;
    5081                 :     136141 :             preeval_data.lhs_alias_set = get_alias_set (object);
    5082                 :            : 
    5083                 :     136141 :             gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
    5084                 :            :                                         pre_p, post_p, &preeval_data);
    5085                 :            :           }
    5086                 :            : 
    5087                 :     832474 :         bool ctor_has_side_effects_p
    5088                 :     832474 :           = TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1));
    5089                 :            : 
    5090                 :     832474 :         if (cleared)
    5091                 :            :           {
    5092                 :            :             /* Zap the CONSTRUCTOR element list, which simplifies this case.
    5093                 :            :                Note that we still have to gimplify, in order to handle the
    5094                 :            :                case of variable sized types.  Avoid shared tree structures.  */
    5095                 :      94587 :             CONSTRUCTOR_ELTS (ctor) = NULL;
    5096                 :      94587 :             TREE_SIDE_EFFECTS (ctor) = 0;
    5097                 :      94587 :             object = unshare_expr (object);
    5098                 :      94587 :             gimplify_stmt (expr_p, pre_p);
    5099                 :            :           }
    5100                 :            : 
    5101                 :            :         /* If we have not block cleared the object, or if there are nonzero
    5102                 :            :            elements in the constructor, or if the constructor has side effects,
    5103                 :            :            add assignments to the individual scalar fields of the object.  */
    5104                 :     832474 :         if (!cleared
    5105                 :      94587 :             || num_nonzero_elements > 0
    5106                 :       2633 :             || ctor_has_side_effects_p)
    5107                 :     829857 :           gimplify_init_ctor_eval (object, elts, pre_p, cleared);
    5108                 :            : 
    5109                 :     832474 :         *expr_p = NULL_TREE;
    5110                 :            :       }
    5111                 :     832474 :       break;
    5112                 :            : 
    5113                 :          0 :     case COMPLEX_TYPE:
    5114                 :          0 :       {
    5115                 :          0 :         tree r, i;
    5116                 :            : 
    5117                 :          0 :         if (notify_temp_creation)
    5118                 :            :           return GS_OK;
    5119                 :            : 
    5120                 :            :         /* Extract the real and imaginary parts out of the ctor.  */
    5121                 :          0 :         gcc_assert (elts->length () == 2);
    5122                 :          0 :         r = (*elts)[0].value;
    5123                 :          0 :         i = (*elts)[1].value;
    5124                 :          0 :         if (r == NULL || i == NULL)
    5125                 :            :           {
    5126                 :          0 :             tree zero = build_zero_cst (TREE_TYPE (type));
    5127                 :          0 :             if (r == NULL)
    5128                 :          0 :               r = zero;
    5129                 :          0 :             if (i == NULL)
    5130                 :          0 :               i = zero;
    5131                 :            :           }
    5132                 :            : 
    5133                 :            :         /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
    5134                 :            :            represent creation of a complex value.  */
    5135                 :          0 :         if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
    5136                 :            :           {
    5137                 :          0 :             ctor = build_complex (type, r, i);
    5138                 :          0 :             TREE_OPERAND (*expr_p, 1) = ctor;
    5139                 :            :           }
    5140                 :            :         else
    5141                 :            :           {
    5142                 :          0 :             ctor = build2 (COMPLEX_EXPR, type, r, i);
    5143                 :          0 :             TREE_OPERAND (*expr_p, 1) = ctor;
    5144                 :          0 :             ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
    5145                 :            :                                  pre_p,
    5146                 :            :                                  post_p,
    5147                 :          0 :                                  rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
    5148                 :            :                                  fb_rvalue);
    5149                 :            :           }
    5150                 :            :       }
    5151                 :            :       break;
    5152                 :            : 
    5153                 :       5242 :     case VECTOR_TYPE:
    5154                 :       5242 :       {
    5155                 :       5242 :         unsigned HOST_WIDE_INT ix;
    5156                 :       5242 :         constructor_elt *ce;
    5157                 :            : 
    5158                 :       5242 :         if (notify_temp_creation)
    5159                 :    1047610 :           return GS_OK;
    5160                 :            : 
    5161                 :            :         /* Go ahead and simplify constant constructors to VECTOR_CST.  */
    5162                 :       5242 :         if (TREE_CONSTANT (ctor))
    5163                 :            :           {
    5164                 :        150 :             bool constant_p = true;
    5165                 :            :             tree value;
    5166                 :            : 
    5167                 :            :             /* Even when ctor is constant, it might contain non-*_CST
    5168                 :            :                elements, such as addresses or trapping values like
    5169                 :            :                1.0/0.0 - 1.0/0.0.  Such expressions don't belong
    5170                 :            :                in VECTOR_CST nodes.  */
    5171                 :        211 :             FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
    5172                 :         56 :               if (!CONSTANT_CLASS_P (value))
    5173                 :            :                 {
    5174                 :            :                   constant_p = false;
    5175                 :            :                   break;
    5176                 :            :                 }
    5177                 :            : 
    5178                 :        140 :             if (constant_p)
    5179                 :            :               {
    5180                 :         94 :                 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
    5181                 :         94 :                 break;
    5182                 :            :               }
    5183                 :            : 
    5184                 :         46 :             TREE_CONSTANT (ctor) = 0;
    5185                 :            :           }
    5186                 :            : 
    5187                 :            :         /* Vector types use CONSTRUCTOR all the way through gimple
    5188                 :            :            compilation as a general initializer.  */
    5189                 :      38907 :         FOR_EACH_VEC_SAFE_ELT (elts, ix, ce)
    5190                 :            :           {
    5191                 :      33759 :             enum gimplify_status tret;
    5192                 :      33759 :             tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
    5193                 :            :                                   fb_rvalue);
    5194                 :      33759 :             if (tret == GS_ERROR)
    5195                 :            :               ret = GS_ERROR;
    5196                 :      33759 :             else if (TREE_STATIC (ctor)
    5197                 :         30 :                      && !initializer_constant_valid_p (ce->value,
    5198                 :      33759 :                                                        TREE_TYPE (ce->value)))
    5199                 :         30 :               TREE_STATIC (ctor) = 0;
    5200                 :            :           }
    5201                 :       5148 :         if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
    5202                 :        506 :           TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
    5203                 :            :       }
    5204                 :            :       break;
    5205                 :            : 
    5206                 :          0 :     default:
    5207                 :            :       /* So how did we get a CONSTRUCTOR for a scalar type?  */
    5208                 :          0 :       gcc_unreachable ();
    5209                 :            :     }
    5210                 :            : 
    5211                 :    1044590 :   if (ret == GS_ERROR)
    5212                 :            :     return GS_ERROR;
    5213                 :            :   /* If we have gimplified both sides of the initializer but have
    5214                 :            :      not emitted an assignment, do so now.  */
    5215                 :    1044590 :   if (*expr_p)
    5216                 :            :     {
    5217                 :     211960 :       tree lhs = TREE_OPERAND (*expr_p, 0);
    5218                 :     211960 :       tree rhs = TREE_OPERAND (*expr_p, 1);
    5219                 :     211960 :       if (want_value && object == lhs)
    5220                 :         12 :         lhs = unshare_expr (lhs);
    5221                 :     211960 :       gassign *init = gimple_build_assign (lhs, rhs);
    5222                 :     211960 :       gimplify_seq_add_stmt (pre_p, init);
    5223                 :            :     }
    5224                 :    1044590 :   if (want_value)
    5225                 :            :     {
    5226                 :         19 :       *expr_p = object;
    5227                 :         19 :       return GS_OK;
    5228                 :            :     }
    5229                 :            :   else
    5230                 :            :     {
    5231                 :    1044570 :       *expr_p = NULL;
    5232                 :    1044570 :       return GS_ALL_DONE;
    5233                 :            :     }
    5234                 :            : }
    5235                 :            : 
    5236                 :            : /* Given a pointer value OP0, return a simplified version of an
    5237                 :            :    indirection through OP0, or NULL_TREE if no simplification is
    5238                 :            :    possible.  This may only be applied to a rhs of an expression.
    5239                 :            :    Note that the resulting type may be different from the type pointed
    5240                 :            :    to in the sense that it is still compatible from the langhooks
    5241                 :            :    point of view. */
    5242                 :            : 
    5243                 :            : static tree
    5244                 :     237651 : gimple_fold_indirect_ref_rhs (tree t)
    5245                 :            : {
    5246                 :          0 :   return gimple_fold_indirect_ref (t);
    5247                 :            : }
    5248                 :            : 
    5249                 :            : /* Subroutine of gimplify_modify_expr to do simplifications of
    5250                 :            :    MODIFY_EXPRs based on the code of the RHS.  We loop for as long as
    5251                 :            :    something changes.  */
    5252                 :            : 
    5253                 :            : static enum gimplify_status
    5254                 :   62293100 : gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p,
    5255                 :            :                           gimple_seq *pre_p, gimple_seq *post_p,
    5256                 :            :                           bool want_value)
    5257                 :            : {
    5258                 :   62293100 :   enum gimplify_status ret = GS_UNHANDLED;
    5259                 :   62662400 :   bool changed;
    5260                 :            : 
    5261                 :   63200000 :   do
    5262                 :            :     {
    5263                 :   62662400 :       changed = false;
    5264                 :   62662400 :       switch (TREE_CODE (*from_p))
    5265                 :            :         {
    5266                 :    8556840 :         case VAR_DECL:
    5267                 :            :           /* If we're assigning from a read-only variable initialized with
    5268                 :            :              a constructor, do the direct assignment from the constructor,
    5269                 :            :              but only if neither source nor target are volatile since this
    5270                 :            :              latter assignment might end up being done on a per-field basis.  */
    5271                 :    8556840 :           if (DECL_INITIAL (*from_p)
    5272                 :     407861 :               && TREE_READONLY (*from_p)
    5273                 :      57870 :               && !TREE_THIS_VOLATILE (*from_p)
    5274                 :      15381 :               && !TREE_THIS_VOLATILE (*to_p)
    5275                 :    8572200 :               && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
    5276                 :            :             {
    5277                 :       1565 :               tree old_from = *from_p;
    5278                 :       1565 :               enum gimplify_status subret;
    5279                 :            : 
    5280                 :            :               /* Move the constructor into the RHS.  */
    5281                 :       1565 :               *from_p = unshare_expr (DECL_INITIAL (*from_p));
    5282                 :            : 
    5283                 :            :               /* Let's see if gimplify_init_constructor will need to put
    5284                 :            :                  it in memory.  */
    5285                 :       1565 :               subret = gimplify_init_constructor (expr_p, NULL, NULL,
    5286                 :            :                                                   false, true);
    5287                 :       1565 :               if (subret == GS_ERROR)
    5288                 :            :                 {
    5289                 :            :                   /* If so, revert the change.  */
    5290                 :       1373 :                   *from_p = old_from;
    5291                 :            :                 }
    5292                 :            :               else
    5293                 :            :                 {
    5294                 :            :                   ret = GS_OK;
    5295                 :            :                   changed = true;
    5296                 :            :                 }
    5297                 :            :             }
    5298                 :            :           break;
    5299                 :     237651 :         case INDIRECT_REF:
    5300                 :     237651 :           {
    5301                 :            :             /* If we have code like
    5302                 :            : 
    5303                 :            :              *(const A*)(A*)&x
    5304                 :            : 
    5305                 :            :              where the type of "x" is a (possibly cv-qualified variant
    5306                 :            :              of "A"), treat the entire expression as identical to "x".
    5307                 :            :              This kind of code arises in C++ when an object is bound
    5308                 :            :              to a const reference, and if "x" is a TARGET_EXPR we want
    5309                 :            :              to take advantage of the optimization below.  */
    5310                 :     237651 :             bool volatile_p = TREE_THIS_VOLATILE (*from_p);
    5311                 :     237651 :             tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
    5312                 :     237651 :             if (t)
    5313                 :            :               {
    5314                 :      60631 :                 if (TREE_THIS_VOLATILE (t) != volatile_p)
    5315                 :            :                   {
    5316                 :         11 :                     if (DECL_P (t))
    5317                 :          0 :                       t = build_simple_mem_ref_loc (EXPR_LOCATION (*from_p),
    5318                 :            :                                                     build_fold_addr_expr (t));
    5319                 :         11 :                     if (REFERENCE_CLASS_P (t))
    5320                 :         11 :                       TREE_THIS_VOLATILE (t) = volatile_p;
    5321                 :            :                   }
    5322                 :      60631 :                 *from_p = t;
    5323                 :      60631 :                 ret = GS_OK;
    5324                 :      60631 :                 changed = true;
    5325                 :            :               }
    5326                 :            :             break;
    5327                 :            :           }
    5328                 :            : 
    5329                 :      62277 :         case TARGET_EXPR:
    5330                 :      62277 :           {
    5331                 :            :             /* If we are initializing something from a TARGET_EXPR, strip the
    5332                 :            :                TARGET_EXPR and initialize it directly, if possible.  This can't
    5333                 :            :                be done if the initializer is void, since that implies that the
    5334                 :            :                temporary is set in some non-trivial way.
    5335                 :            : 
    5336                 :            :                ??? What about code that pulls out the temp and uses it
    5337                 :            :                elsewhere? I think that such code never uses the TARGET_EXPR as
    5338                 :            :                an initializer.  If I'm wrong, we'll die because the temp won't
    5339                 :            :                have any RTL.  In that case, I guess we'll need to replace
    5340                 :            :                references somehow.  */
    5341                 :      62277 :             tree init = TARGET_EXPR_INITIAL (*from_p);
    5342                 :            : 
    5343                 :      62277 :             if (init
    5344                 :      62173 :                 && (TREE_CODE (*expr_p) != MODIFY_EXPR
    5345                 :      15389 :                     || !TARGET_EXPR_NO_ELIDE (*from_p))
    5346                 :     124444 :                 && !VOID_TYPE_P (TREE_TYPE (init)))
    5347                 :            :               {
    5348                 :      54936 :                 *from_p = init;
    5349                 :      54936 :                 ret = GS_OK;
    5350                 :      54936 :                 changed = true;
    5351                 :            :               }
    5352                 :            :           }
    5353                 :            :           break;
    5354                 :            : 
    5355                 :     253385 :         case COMPOUND_EXPR:
    5356                 :            :           /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
    5357                 :            :              caught.  */
    5358                 :     253385 :           gimplify_compound_expr (from_p, pre_p, true);
    5359                 :     253385 :           ret = GS_OK;
    5360                 :     253385 :           changed = true;
    5361                 :     253385 :           break;
    5362                 :            : 
    5363                 :    1050320 :         case CONSTRUCTOR:
    5364                 :            :           /* If we already made some changes, let the front end have a
    5365                 :            :              crack at this before we break it down.  */
    5366                 :    1050320 :           if (ret != GS_UNHANDLED)
    5367                 :            :             break;
    5368                 :            :           /* If we're initializing from a CONSTRUCTOR, break this into
    5369                 :            :              individual MODIFY_EXPRs.  */
    5370                 :    1046040 :           return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
    5371                 :    1046040 :                                             false);
    5372                 :            : 
    5373                 :     141176 :         case COND_EXPR:
    5374                 :            :           /* If we're assigning to a non-register type, push the assignment
    5375                 :            :              down into the branches.  This is mandatory for ADDRESSABLE types,
    5376                 :            :              since we cannot generate temporaries for such, but it saves a
    5377                 :            :              copy in other cases as well.  */
    5378                 :     141176 :           if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
    5379                 :            :             {
    5380                 :            :               /* This code should mirror the code in gimplify_cond_expr. */
    5381                 :       4076 :               enum tree_code code = TREE_CODE (*expr_p);
    5382                 :       4076 :               tree cond = *from_p;
    5383                 :       4076 :               tree result = *to_p;
    5384                 :            : 
    5385                 :       4076 :               ret = gimplify_expr (&result, pre_p, post_p,
    5386                 :            :                                    is_gimple_lvalue, fb_lvalue);
    5387                 :       4076 :               if (ret != GS_ERROR)
    5388                 :       4076 :                 ret = GS_OK;
    5389                 :            : 
    5390                 :            :               /* If we are going to write RESULT more than once, clear
    5391                 :            :                  TREE_READONLY flag, otherwise we might incorrectly promote
    5392                 :            :                  the variable to static const and initialize it at compile
    5393                 :            :                  time in one of the branches.  */
    5394                 :       4076 :               if (VAR_P (result)
    5395                 :       3827 :                   && TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node
    5396                 :       7887 :                   && TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
    5397                 :       3779 :                 TREE_READONLY (result) = 0;
    5398                 :       4076 :               if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
    5399                 :       8120 :                 TREE_OPERAND (cond, 1)
    5400                 :       4060 :                   = build2 (code, void_type_node, result,
    5401                 :       4060 :                             TREE_OPERAND (cond, 1));
    5402                 :       4076 :               if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
    5403                 :       8088 :                 TREE_OPERAND (cond, 2)
    5404                 :       4044 :                   = build2 (code, void_type_node, unshare_expr (result),
    5405                 :       4044 :                             TREE_OPERAND (cond, 2));
    5406                 :            : 
    5407                 :       4076 :               TREE_TYPE (cond) = void_type_node;
    5408                 :       4076 :               recalculate_side_effects (cond);
    5409                 :            : 
    5410                 :       4076 :               if (want_value)
    5411                 :            :                 {
    5412                 :          0 :                   gimplify_and_add (cond, pre_p);
    5413                 :          0 :                   *expr_p = unshare_expr (result);
    5414                 :            :                 }
    5415                 :            :               else
    5416                 :       4076 :                 *expr_p = cond;
    5417                 :       4076 :               return ret;
    5418                 :            :             }
    5419                 :            :           break;
    5420                 :            : 
    5421                 :    6177830 :         case CALL_EXPR:
    5422                 :            :           /* For calls that return in memory, give *to_p as the CALL_EXPR's
    5423                 :            :              return slot so that we don't generate a temporary.  */
    5424                 :    6177830 :           if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
    5425                 :    6177830 :               && aggregate_value_p (*from_p, *from_p))
    5426                 :            :             {
    5427                 :     178969 :               bool use_target;
    5428                 :            : 
    5429                 :     178969 :               if (!(rhs_predicate_for (*to_p))(*from_p))
    5430                 :            :                 /* If we need a temporary, *to_p isn't accurate.  */
    5431                 :            :                 use_target = false;
    5432                 :            :               /* It's OK to use the return slot directly unless it's an NRV. */
    5433                 :     178181 :               else if (TREE_CODE (*to_p) == RESULT_DECL
    5434                 :       1266 :                        && DECL_NAME (*to_p) == NULL_TREE
    5435                 :     179375 :                        && needs_to_live_in_memory (*to_p))
    5436                 :            :                 use_target = true;
    5437                 :     176987 :               else if (is_gimple_reg_type (TREE_TYPE (*to_p))
    5438                 :     176987 :                        || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
    5439                 :            :                 /* Don't force regs into memory.  */
    5440                 :            :                 use_target = false;
    5441                 :     172267 :               else if (TREE_CODE (*expr_p) == INIT_EXPR)
    5442                 :            :                 /* It's OK to use the target directly if it's being
    5443                 :            :                    initialized. */
    5444                 :            :                 use_target = true;
    5445                 :       7984 :               else if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (*to_p)))
    5446                 :            :                        != INTEGER_CST)
    5447                 :            :                 /* Always use the target and thus RSO for variable-sized types.
    5448                 :            :                    GIMPLE cannot deal with a variable-sized assignment
    5449                 :            :                    embedded in a call statement.  */
    5450                 :            :                 use_target = true;
    5451                 :       7958 :               else if (TREE_CODE (*to_p) != SSA_NAME
    5452                 :       7958 :                       && (!is_gimple_variable (*to_p)
    5453                 :       5602 :                           || needs_to_live_in_memory (*to_p)))
    5454                 :            :                 /* Don't use the original target if it's already addressable;
    5455                 :            :                    if its address escapes, and the called function uses the
    5456                 :            :                    NRV optimization, a conforming program could see *to_p
    5457                 :            :                    change before the called function returns; see c++/19317.
    5458                 :            :                    When optimizing, the return_slot pass marks more functions
    5459                 :            :                    as safe after we have escape info.  */
    5460                 :            :                 use_target = false;
    5461                 :            :               else
    5462                 :            :                 use_target = true;
    5463                 :            : 
    5464                 :            :               if (use_target)
    5465                 :            :                 {
    5466                 :     167153 :                   CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
    5467                 :     167153 :                   mark_addressable (*to_p);
    5468                 :            :                 }
    5469                 :            :             }
    5470                 :            :           break;
    5471                 :            : 
    5472                 :       1272 :         case WITH_SIZE_EXPR:
    5473                 :            :           /* Likewise for calls that return an aggregate of non-constant size,
    5474                 :            :              since we would not be able to generate a temporary at all.  */
    5475                 :       1272 :           if (TREE_CODE (TREE_OPERAND (*from_p, 0)) == CALL_EXPR)
    5476                 :            :             {
    5477                 :        138 :               *from_p = TREE_OPERAND (*from_p, 0);
    5478                 :            :               /* We don't change ret in this case because the
    5479                 :            :                  WITH_SIZE_EXPR might have been added in
    5480                 :            :                  gimplify_modify_expr, so returning GS_OK would lead to an
    5481                 :            :                  infinite loop.  */
    5482                 :        138 :               changed = true;
    5483                 :            :             }
    5484                 :            :           break;
    5485                 :            : 
    5486                 :            :           /* If we're initializing from a container, push the initialization
    5487                 :            :              inside it.  */
    5488                 :        619 :         case CLEANUP_POINT_EXPR:
    5489                 :        619 :         case BIND_EXPR:
    5490                 :        619 :         case STATEMENT_LIST:
    5491                 :        619 :           {
    5492                 :        619 :             tree wrap = *from_p;
    5493                 :        619 :             tree t;
    5494                 :            : 
    5495                 :        619 :             ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
    5496                 :            :                                  fb_lvalue);
    5497                 :        619 :             if (ret != GS_ERROR)
    5498                 :        619 :               ret = GS_OK;
    5499                 :            : 
    5500                 :        619 :             t = voidify_wrapper_expr (wrap, *expr_p);
    5501                 :        619 :             gcc_assert (t == *expr_p);
    5502                 :            : 
    5503                 :        619 :             if (want_value)
    5504                 :            :               {
    5505                 :          8 :                 gimplify_and_add (wrap, pre_p);
    5506                 :          8 :                 *expr_p = unshare_expr (*to_p);
    5507                 :            :               }
    5508                 :            :             else
    5509                 :        611 :               *expr_p = wrap;
    5510                 :            :             return GS_OK;
    5511                 :            :           }
    5512                 :            : 
    5513                 :       2552 :         case COMPOUND_LITERAL_EXPR:
    5514                 :       2552 :           {
    5515                 :       2552 :             tree complit = TREE_OPERAND (*expr_p, 1);
    5516                 :       2552 :             tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
    5517                 :       2552 :             tree decl = DECL_EXPR_DECL (decl_s);
    5518                 :       2552 :             tree init = DECL_INITIAL (decl);
    5519                 :            : 
    5520                 :            :             /* struct T x = (struct T) { 0, 1, 2 } can be optimized
    5521                 :            :                into struct T x = { 0, 1, 2 } if the address of the
    5522                 :            :                compound literal has never been taken.  */
    5523                 :       2552 :             if (!TREE_ADDRESSABLE (complit)
    5524                 :       2552 :                 && !TREE_ADDRESSABLE (decl)
    5525                 :       2552 :                 && init)
    5526                 :            :               {
    5527                 :       2552 :                 *expr_p = copy_node (*expr_p);
    5528                 :       2552 :                 TREE_OPERAND (*expr_p, 1) = init;
    5529                 :       2552 :                 return GS_OK;
    5530                 :            :               }
    5531                 :            :           }
    5532                 :            : 
    5533                 :            :         default:
    5534                 :            :           break;
    5535                 :            :         }
    5536                 :            :     }
    5537                 :            :   while (changed);
    5538                 :            : 
    5539                 :            :   return ret;
    5540                 :            : }
    5541                 :            : 
    5542                 :            : 
    5543                 :            : /* Return true if T looks like a valid GIMPLE statement.  */
    5544                 :            : 
    5545                 :            : static bool
    5546                 :   12740800 : is_gimple_stmt (tree t)
    5547                 :            : {
    5548                 :   12740800 :   const enum tree_code code = TREE_CODE (t);
    5549                 :            : 
    5550                 :   12740800 :   switch (code)
    5551                 :            :     {
    5552                 :     989824 :     case NOP_EXPR:
    5553                 :            :       /* The only valid NOP_EXPR is the empty statement.  */
    5554                 :    1979650 :       return IS_EMPTY_STMT (t);
    5555                 :            : 
    5556                 :          0 :     case BIND_EXPR:
    5557                 :          0 :     case COND_EXPR:
    5558                 :            :       /* These are only valid if they're void.  */
    5559                 :          0 :       return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
    5560                 :            : 
    5561                 :            :     case SWITCH_EXPR:
    5562                 :            :     case GOTO_EXPR:
    5563                 :            :     case RETURN_EXPR:
    5564                 :            :     case LABEL_EXPR:
    5565                 :            :     case CASE_LABEL_EXPR:
    5566                 :            :     case TRY_CATCH_EXPR:
    5567                 :            :     case TRY_FINALLY_EXPR:
    5568                 :            :     case EH_FILTER_EXPR:
    5569                 :            :     case CATCH_EXPR:
    5570                 :            :     case ASM_EXPR:
    5571                 :            :     case STATEMENT_LIST:
    5572                 :            :     case OACC_PARALLEL:
    5573                 :            :     case OACC_KERNELS:
    5574                 :            :     case OACC_SERIAL:
    5575                 :            :     case OACC_DATA:
    5576                 :            :     case OACC_HOST_DATA:
    5577                 :            :     case OACC_DECLARE:
    5578                 :            :     case OACC_UPDATE:
    5579                 :            :     case OACC_ENTER_DATA:
    5580                 :            :     case OACC_EXIT_DATA:
    5581                 :            :     case OACC_CACHE:
    5582                 :            :     case OMP_PARALLEL:
    5583                 :            :     case OMP_FOR:
    5584                 :            :     case OMP_SIMD:
    5585                 :            :     case OMP_DISTRIBUTE:
    5586                 :            :     case OMP_LOOP:
    5587                 :            :     case OACC_LOOP:
    5588                 :            :     case OMP_SCAN:
    5589                 :            :     case OMP_SECTIONS:
    5590                 :            :     case OMP_SECTION:
    5591                 :            :     case OMP_SINGLE:
    5592                 :            :     case OMP_MASTER:
    5593                 :            :     case OMP_TASKGROUP:
    5594                 :            :     case OMP_ORDERED:
    5595                 :            :     case OMP_CRITICAL:
    5596                 :            :     case OMP_TASK:
    5597                 :            :     case OMP_TARGET:
    5598                 :            :     case OMP_TARGET_DATA:
    5599                 :            :     case OMP_TARGET_UPDATE:
    5600                 :            :     case OMP_TARGET_ENTER_DATA:
    5601                 :            :     case OMP_TARGET_EXIT_DATA:
    5602                 :            :     case OMP_TASKLOOP:
    5603                 :            :     case OMP_TEAMS:
    5604                 :            :       /* These are always void.  */
    5605                 :            :       return true;
    5606                 :            : 
    5607                 :            :     case CALL_EXPR:
    5608                 :            :     case MODIFY_EXPR:
    5609                 :            :     case PREDICT_EXPR:
    5610                 :            :       /* These are valid regardless of their type.  */
    5611                 :            :       return true;
    5612                 :            : 
    5613                 :     732627 :     default:
    5614                 :     732627 :       return false;
    5615                 :            :     }
    5616                 :            : }
    5617                 :            : 
    5618                 :            : 
    5619                 :            : /* Promote partial stores to COMPLEX variables to total stores.  *EXPR_P is
    5620                 :            :    a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
    5621                 :            :    DECL_GIMPLE_REG_P set.
    5622                 :            : 
    5623                 :            :    IMPORTANT NOTE: This promotion is performed by introducing a load of the
    5624                 :            :    other, unmodified part of the complex object just before the total store.
    5625                 :            :    As a consequence, if the object is still uninitialized, an undefined value
    5626                 :            :    will be loaded into a register, which may result in a spurious exception
    5627                 :            :    if the register is floating-point and the value happens to be a signaling
    5628                 :            :    NaN for example.  Then the fully-fledged complex operations lowering pass
    5629                 :            :    followed by a DCE pass are necessary in order to fix things up.  */
    5630                 :            : 
    5631                 :            : static enum gimplify_status
    5632                 :       1941 : gimplify_modify_expr_complex_part (tree *expr_p, gimple_seq *pre_p,
    5633                 :            :                                    bool want_value)
    5634                 :            : {
    5635                 :       1941 :   enum tree_code code, ocode;
    5636                 :       1941 :   tree lhs, rhs, new_rhs, other, realpart, imagpart;
    5637                 :            : 
    5638                 :       1941 :   lhs = TREE_OPERAND (*expr_p, 0);
    5639                 :       1941 :   rhs = TREE_OPERAND (*expr_p, 1);
    5640                 :       1941 :   code = TREE_CODE (lhs);
    5641                 :       1941 :   lhs = TREE_OPERAND (lhs, 0);
    5642                 :            : 
    5643                 :       1941 :   ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
    5644                 :       1941 :   other = build1 (ocode, TREE_TYPE (rhs), lhs);
    5645                 :       1941 :   TREE_NO_WARNING (other) = 1;
    5646                 :       1941 :   other = get_formal_tmp_var (other, pre_p);
    5647                 :            : 
    5648                 :       1941 :   realpart = code == REALPART_EXPR ? rhs : other;
    5649                 :       1941 :   imagpart = code == REALPART_EXPR ? other : rhs;
    5650                 :            : 
    5651                 :       2273 :   if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
    5652                 :          0 :     new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
    5653                 :            :   else
    5654                 :       1941 :     new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
    5655                 :            : 
    5656                 :       1941 :   gimplify_seq_add_stmt (pre_p, gimple_build_assign (lhs, new_rhs));
    5657                 :       1941 :   *expr_p = (want_value) ? rhs : NULL_TREE;
    5658                 :            : 
    5659                 :       1941 :   return GS_ALL_DONE;
    5660                 :            : }
    5661                 :            : 
    5662                 :            : /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
    5663                 :            : 
    5664                 :            :       modify_expr
    5665                 :            :               : varname '=' rhs
    5666                 :            :               | '*' ID '=' rhs
    5667                 :            : 
    5668                 :            :     PRE_P points to the list where side effects that must happen before
    5669                 :            :         *EXPR_P should be stored.
    5670                 :            : 
    5671                 :            :     POST_P points to the list where side effects that must happen after
    5672                 :            :         *EXPR_P should be stored.
    5673                 :            : 
    5674                 :            :     WANT_VALUE is nonzero iff we want to use the value of this expression
    5675                 :            :         in another expression.  */
    5676                 :            : 
    5677                 :            : static enum gimplify_status
    5678                 :   32235000 : gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
    5679                 :            :                       bool want_value)
    5680                 :            : {
    5681                 :   32235000 :   tree *from_p = &TREE_OPERAND (*expr_p, 1);
    5682                 :   32235000 :   tree *to_p = &TREE_OPERAND (*expr_p, 0);
    5683                 :   32235000 :   enum gimplify_status ret = GS_UNHANDLED;
    5684                 :   32235000 :   gimple *assign;
    5685                 :   32235000 :   location_t loc = EXPR_LOCATION (*expr_p);
    5686                 :   32235000 :   gimple_stmt_iterator gsi;
    5687                 :            : 
    5688                 :   32235000 :   gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
    5689                 :            :               || TREE_CODE (*expr_p) == INIT_EXPR);
    5690                 :            : 
    5691                 :            :   /* Trying to simplify a clobber using normal logic doesn't work,
    5692                 :            :      so handle it here.  */
    5693                 :   32235000 :   if (TREE_CLOBBER_P (*from_p))
    5694                 :            :     {
    5695                 :     388306 :       ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
    5696                 :     388306 :       if (ret == GS_ERROR)
    5697                 :            :         return ret;
    5698                 :     388306 :       gcc_assert (!want_value);
    5699                 :     388306 :       if (!VAR_P (*to_p) && TREE_CODE (*to_p) != MEM_REF)
    5700                 :            :         {
    5701                 :        139 :           tree addr = get_initialized_tmp_var (build_fold_addr_expr (*to_p),
    5702                 :            :                                                pre_p, post_p);
    5703                 :        139 :           *to_p = build_simple_mem_ref_loc (EXPR_LOCATION (*to_p), addr);
    5704                 :            :         }
    5705                 :     388306 :       gimplify_seq_add_stmt (pre_p, gimple_build_assign (*to_p, *from_p));
    5706                 :     388306 :       *expr_p = NULL;
    5707                 :     388306 :       return GS_ALL_DONE;
    5708                 :            :     }
    5709                 :            : 
    5710                 :            :   /* Insert pointer conversions required by the middle-end that are not
    5711                 :            :      required by the frontend.  This fixes middle-end type checking for
    5712                 :            :      for example gcc.dg/redecl-6.c.  */
    5713                 :   31846700 :   if (POINTER_TYPE_P (TREE_TYPE (*to_p)))
    5714                 :            :     {
    5715                 :    8729760 :       STRIP_USELESS_TYPE_CONVERSION (*from_p);
    5716                 :    8729760 :       if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
    5717                 :        246 :         *from_p = fold_convert_loc (loc, TREE_TYPE (*to_p), *from_p);
    5718                 :            :     }
    5719                 :            : 
    5720                 :            :   /* See if any simplifications can be done based on what the RHS is.  */
    5721                 :   31846700 :   ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
    5722                 :            :                                   want_value);
    5723                 :   31846700 :   if (ret != GS_UNHANDLED)
    5724                 :            :     return ret;
    5725                 :            : 
    5726                 :            :   /* For zero sized types only gimplify the left hand side and right hand
    5727                 :            :      side as statements and throw away the assignment.  Do this after
    5728                 :            :      gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
    5729                 :            :      types properly.  */
    5730                 :   30447700 :   if (zero_sized_type (TREE_TYPE (*from_p))
    5731                 :       1233 :       && !want_value
    5732                 :            :       /* Don't do this for calls that return addressable types, expand_call
    5733                 :            :          relies on those having a lhs.  */
    5734                 :   30449000 :       && !(TREE_ADDRESSABLE (TREE_TYPE (*from_p))
    5735                 :       1226 :            && TREE_CODE (*from_p) == CALL_EXPR))
    5736                 :            :     {
    5737                 :       1218 :       gimplify_stmt (from_p, pre_p);
    5738                 :       1218 :       gimplify_stmt (to_p, pre_p);
    5739                 :       1218 :       *expr_p = NULL_TREE;
    5740                 :       1218 :       return GS_ALL_DONE;
    5741                 :            :     }
    5742                 :            : 
    5743                 :            :   /* If the value being copied is of variable width, compute the length
    5744                 :            :      of the copy into a WITH_SIZE_EXPR.   Note that we need to do this
    5745                 :            :      before gimplifying any of the operands so that we can resolve any
    5746                 :            :      PLACEHOLDER_EXPRs in the size.  Also note that the RTL expander uses
    5747                 :            :      the size of the expression to be copied, not of the destination, so
    5748                 :            :      that is what we must do here.  */
    5749                 :   30446500 :   maybe_with_size_expr (from_p);
    5750                 :            : 
    5751                 :            :   /* As a special case, we have to temporarily allow for assignments
    5752                 :            :      with a CALL_EXPR on the RHS.  Since in GIMPLE a function call is
    5753                 :            :      a toplevel statement, when gimplifying the GENERIC expression
    5754                 :            :      MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
    5755                 :            :      GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
    5756                 :            : 
    5757                 :            :      Instead, we need to create the tuple GIMPLE_CALL <a, foo>.  To
    5758                 :            :      prevent gimplify_expr from trying to create a new temporary for
    5759                 :            :      foo's LHS, we tell it that it should only gimplify until it
    5760                 :            :      reaches the CALL_EXPR.  On return from gimplify_expr, the newly
    5761                 :            :      created GIMPLE_CALL <foo> will be the last statement in *PRE_P
    5762                 :            :      and all we need to do here is set 'a' to be its LHS.  */
    5763                 :            : 
    5764                 :            :   /* Gimplify the RHS first for C++17 and bug 71104.  */
    5765                 :   30446500 :   gimple_predicate initial_pred = initial_rhs_predicate_for (*to_p);
    5766                 :   30446500 :   ret = gimplify_expr (from_p, pre_p, post_p, initial_pred, fb_rvalue);
    5767                 :   30446500 :   if (ret == GS_ERROR)
    5768                 :            :     return ret;
    5769                 :            : 
    5770                 :            :   /* Then gimplify the LHS.  */
    5771                 :            :   /* If we gimplified the RHS to a CALL_EXPR and that call may return
    5772                 :            :      twice we have to make sure to gimplify into non-SSA as otherwise
    5773                 :            :      the abnormal edge added later will make those defs not dominate
    5774                 :            :      their uses.
    5775                 :            :      ???  Technically this applies only to the registers used in the
    5776                 :            :      resulting non-register *TO_P.  */
    5777                 :   30446500 :   bool saved_into_ssa = gimplify_ctxp->into_ssa;
    5778                 :   30446500 :   if (saved_into_ssa
    5779                 :   28826400 :       && TREE_CODE (*from_p) == CALL_EXPR
    5780                 :   33608100 :       && call_expr_flags (*from_p) & ECF_RETURNS_TWICE)
    5781                 :       1144 :     gimplify_ctxp->into_ssa = false;
    5782                 :   30446500 :   ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
    5783                 :   30446500 :   gimplify_ctxp->into_ssa = saved_into_ssa;
    5784                 :   30446500 :   if (ret == GS_ERROR)
    5785                 :            :     return ret;
    5786                 :            : 
    5787                 :            :   /* Now that the LHS is gimplified, re-gimplify the RHS if our initial
    5788                 :            :      guess for the predicate was wrong.  */
    5789                 :   30446500 :   gimple_predicate final_pred = rhs_predicate_for (*to_p);
    5790                 :   30446500 :   if (final_pred != initial_pred)
    5791                 :            :     {
    5792                 :    5398600 :       ret = gimplify_expr (from_p, pre_p, post_p, final_pred, fb_rvalue);
    5793                 :    5398600 :       if (ret == GS_ERROR)
    5794                 :            :         return ret;
    5795                 :            :     }
    5796                 :            : 
    5797                 :            :   /* In case of va_arg internal fn wrappped in a WITH_SIZE_EXPR, add the type
    5798                 :            :      size as argument to the call.  */
    5799                 :   30446500 :   if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
    5800                 :            :     {
    5801                 :       1173 :       tree call = TREE_OPERAND (*from_p, 0);
    5802                 :       1173 :       tree vlasize = TREE_OPERAND (*from_p, 1);
    5803                 :            : 
    5804                 :       1173 :       if (TREE_CODE (call) == CALL_EXPR
    5805                 :       1173 :           && CALL_EXPR_IFN (call) == IFN_VA_ARG)
    5806                 :            :         {
    5807                 :         95 :           int nargs = call_expr_nargs (call);
    5808                 :         95 :           tree type = TREE_TYPE (call);
    5809                 :         95 :           tree ap = CALL_EXPR_ARG (call, 0);
    5810                 :         95 :           tree tag = CALL_EXPR_ARG (call, 1);
    5811                 :         95 :           tree aptag = CALL_EXPR_ARG (call, 2);
    5812                 :         95 :           tree newcall = build_call_expr_internal_loc (EXPR_LOCATION (call),
    5813                 :            :                                                        IFN_VA_ARG, type,
    5814                 :            :                                                        nargs + 1, ap, tag,
    5815                 :            :                                                        aptag, vlasize);
    5816                 :         95 :           TREE_OPERAND (*from_p, 0) = newcall;
    5817                 :            :         }
    5818                 :            :     }
    5819                 :            : 
    5820                 :            :   /* Now see if the above changed *from_p to something we handle specially.  */
    5821                 :   30446500 :   ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
    5822                 :            :                                   want_value);
    5823                 :   30446500 :   if (ret != GS_UNHANDLED)
    5824                 :            :     return ret;
    5825                 :            : 
    5826                 :            :   /* If we've got a variable sized assignment between two lvalues (i.e. does
    5827                 :            :      not involve a call), then we can make things a bit more straightforward
    5828                 :            :      by converting the assignment to memcpy or memset.  */
    5829                 :   30446100 :   if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
    5830                 :            :     {
    5831                 :       1035 :       tree from = TREE_OPERAND (*from_p, 0);
    5832                 :       1035 :       tree size = TREE_OPERAND (*from_p, 1);
    5833                 :            : 
    5834                 :       1035 :       if (TREE_CODE (from) == CONSTRUCTOR)
    5835                 :          0 :         return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
    5836                 :            : 
    5837                 :       1035 :       if (is_gimple_addressable (from))
    5838                 :            :         {
    5839                 :       1035 :           *from_p = from;
    5840                 :       1035 :           return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
    5841                 :       1035 :                                                  pre_p);
    5842                 :            :         }
    5843                 :            :     }
    5844                 :            : 
    5845                 :            :   /* Transform partial stores to non-addressable complex variables into
    5846                 :            :      total stores.  This allows us to use real instead of virtual operands
    5847                 :            :      for these variables, which improves optimization.  */
    5848                 :   30445100 :   if ((TREE_CODE (*to_p) == REALPART_EXPR
    5849                 :   30445100 :        || TREE_CODE (*to_p) == IMAGPART_EXPR)
    5850                 :   30445100 :       && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
    5851                 :       1941 :     return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
    5852                 :            : 
    5853                 :            :   /* Try to alleviate the effects of the gimplification creating artificial
    5854                 :            :      temporaries (see for example is_gimple_reg_rhs) on the debug info, but
    5855                 :            :      make sure not to create DECL_DEBUG_EXPR links across functions.  */
    5856                 :   30443100 :   if (!gimplify_ctxp->into_ssa
    5857                 :    1619180 :       && VAR_P (*from_p)
    5858                 :     324879 :       && DECL_IGNORED_P (*from_p)
    5859                 :     236185 :       && DECL_P (*to_p)
    5860                 :      89943 :       && !DECL_IGNORED_P (*to_p)
    5861                 :      20372 :       && decl_function_context (*to_p) == current_function_decl
    5862                 :   30461600 :       && decl_function_context (*from_p) == current_function_decl)
    5863                 :            :     {
    5864                 :      18479 :       if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
    5865                 :      28160 :         DECL_NAME (*from_p)
    5866                 :      14080 :           = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
    5867                 :      18479 :       DECL_HAS_DEBUG_EXPR_P (*from_p) = 1;
    5868                 :      18479 :       SET_DECL_DEBUG_EXPR (*from_p, *to_p);
    5869                 :            :    }
    5870                 :            : 
    5871                 :   30443100 :   if (want_value && TREE_THIS_VOLATILE (*to_p))
    5872                 :        635 :     *from_p = get_initialized_tmp_var (*from_p, pre_p, post_p);
    5873                 :            : 
    5874                 :   30443100 :   if (TREE_CODE (*from_p) == CALL_EXPR)
    5875                 :            :     {
    5876                 :            :       /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
    5877                 :            :          instead of a GIMPLE_ASSIGN.  */
    5878                 :    2956960 :       gcall *call_stmt;
    5879                 :    2956960 :       if (CALL_EXPR_FN (*from_p) == NULL_TREE)
    5880                 :            :         {
    5881                 :            :           /* Gimplify internal functions created in the FEs.  */
    5882                 :     137637 :           int nargs = call_expr_nargs (*from_p), i;
    5883                 :     137637 :           enum internal_fn ifn = CALL_EXPR_IFN (*from_p);
    5884                 :     275274 :           auto_vec<tree> vargs (nargs);
    5885                 :            : 
    5886                 :     553719 :           for (i = 0; i < nargs; i++)
    5887                 :            :             {
    5888                 :     416082 :               gimplify_arg (&CALL_EXPR_ARG (*from_p, i), pre_p,
    5889                 :     416082 :                             EXPR_LOCATION (*from_p));
    5890                 :     416082 :               vargs.quick_push (CALL_EXPR_ARG (*from_p, i));
    5891                 :            :             }
    5892                 :     137637 :           call_stmt = gimple_build_call_internal_vec (ifn, vargs);
    5893                 :     137637 :           gimple_call_set_nothrow (call_stmt, TREE_NOTHROW (*from_p));
    5894                 :     137637 :           gimple_set_location (call_stmt, EXPR_LOCATION (*expr_p));
    5895                 :            :         }
    5896                 :            :       else
    5897                 :            :         {
    5898                 :    2819320 :           tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*from_p));
    5899                 :    2819320 :           CALL_EXPR_FN (*from_p) = TREE_OPERAND (CALL_EXPR_FN (*from_p), 0);
    5900                 :    2819320 :           STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p));
    5901                 :    2819320 :           tree fndecl = get_callee_fndecl (*from_p);
    5902                 :    2819320 :           if (fndecl
    5903                 :    2712130 :               && fndecl_built_in_p (fndecl, BUILT_IN_EXPECT)
    5904                 :    2884260 :               && call_expr_nargs (*from_p) == 3)
    5905                 :      39303 :             call_stmt = gimple_build_call_internal (IFN_BUILTIN_EXPECT, 3,
    5906                 :      39303 :                                                     CALL_EXPR_ARG (*from_p, 0),
    5907                 :      39303 :                                                     CALL_EXPR_ARG (*from_p, 1),
    5908                 :      39303 :                                                     CALL_EXPR_ARG (*from_p, 2));
    5909                 :            :           else
    5910                 :            :             {
    5911                 :    2780020 :               call_stmt = gimple_build_call_from_tree (*from_p, fnptrtype);
    5912                 :            :             }
    5913                 :            :         }
    5914                 :    2956960 :       notice_special_calls (call_stmt);
    5915                 :    2956960 :       if (!gimple_call_noreturn_p (call_stmt) || !should_remove_lhs_p (*to_p))
    5916                 :    2955700 :         gimple_call_set_lhs (call_stmt, *to_p);
    5917                 :       1263 :       else if (TREE_CODE (*to_p) == SSA_NAME)
    5918                 :            :         /* The above is somewhat premature, avoid ICEing later for a
    5919                 :            :            SSA name w/o a definition.  We may have uses in the GIMPLE IL.
    5920                 :            :            ???  This doesn't make it a default-def.  */
    5921                 :          9 :         SSA_NAME_DEF_STMT (*to_p) = gimple_build_nop ();
    5922                 :            : 
    5923                 :            :       assign = call_stmt;
    5924                 :            :     }
    5925                 :            :   else
    5926                 :            :     {
    5927                 :   27486200 :       assign = gimple_build_assign (*to_p, *from_p);
    5928                 :   27486200 :       gimple_set_location (assign, EXPR_LOCATION (*expr_p));
    5929                 :   27486200 :       if (COMPARISON_CLASS_P (*from_p))
    5930                 :     811981 :         gimple_set_no_warning (assign, TREE_NO_WARNING (*from_p));
    5931                 :            :     }
    5932                 :            : 
    5933                 :   30443100 :   if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
    5934                 :            :     {
    5935                 :            :       /* We should have got an SSA name from the start.  */
    5936                 :   21990100 :       gcc_assert (TREE_CODE (*to_p) == SSA_NAME
    5937                 :            :                   || ! gimple_in_ssa_p (cfun));
    5938                 :            :     }
    5939                 :            : 
    5940                 :   30443100 :   gimplify_seq_add_stmt (pre_p, assign);
    5941                 :   30443100 :   gsi = gsi_last (*pre_p);
    5942                 :   30443100 :   maybe_fold_stmt (&gsi);
    5943                 :            : 
    5944                 :   30443100 :   if (want_value)
    5945                 :            :     {
    5946                 :     272678 :       *expr_p = TREE_THIS_VOLATILE (*to_p) ? *from_p : unshare_expr (*to_p);
    5947                 :     272678 :       return GS_OK;
    5948                 :            :     }
    5949                 :            :   else
    5950                 :   30170500 :     *expr_p = NULL;
    5951                 :            : 
    5952                 :   30170500 :   return GS_ALL_DONE;
    5953                 :            : }
    5954                 :            : 
    5955                 :            : /* Gimplify a comparison between two variable-sized objects.  Do this
    5956                 :            :    with a call to BUILT_IN_MEMCMP.  */
    5957                 :            : 
    5958                 :            : static enum gimplify_status
    5959                 :          0 : gimplify_variable_sized_compare (tree *expr_p)
    5960                 :            : {
    5961                 :          0 :   location_t loc = EXPR_LOCATION (*expr_p);
    5962                 :          0 :   tree op0 = TREE_OPERAND (*expr_p, 0);
    5963                 :          0 :   tree op1 = TREE_OPERAND (*expr_p, 1);
    5964                 :          0 :   tree t, arg, dest, src, expr;
    5965                 :            : 
    5966                 :          0 :   arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
    5967                 :          0 :   arg = unshare_expr (arg);
    5968                 :          0 :   arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
    5969                 :          0 :   src = build_fold_addr_expr_loc (loc, op1);
    5970                 :          0 :   dest = build_fold_addr_expr_loc (loc, op0);
    5971                 :          0 :   t = builtin_decl_implicit (BUILT_IN_MEMCMP);
    5972                 :          0 :   t = build_call_expr_loc (loc, t, 3, dest, src, arg);
    5973                 :            : 
    5974                 :          0 :   expr
    5975                 :          0 :     = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
    5976                 :          0 :   SET_EXPR_LOCATION (expr, loc);
    5977                 :          0 :   *expr_p = expr;
    5978                 :            : 
    5979                 :          0 :   return GS_OK;
    5980                 :            : }
    5981                 :            : 
    5982                 :            : /* Gimplify a comparison between two aggregate objects of integral scalar
    5983                 :            :    mode as a comparison between the bitwise equivalent scalar values.  */
    5984                 :            : 
    5985                 :            : static enum gimplify_status
    5986                 :          0 : gimplify_scalar_mode_aggregate_compare (tree *expr_p)
    5987                 :            : {
    5988                 :          0 :   location_t loc = EXPR_LOCATION (*expr_p);
    5989                 :          0 :   tree op0 = TREE_OPERAND (*expr_p, 0);
    5990                 :          0 :   tree op1 = TREE_OPERAND (*expr_p, 1);
    5991                 :            : 
    5992                 :          0 :   tree type = TREE_TYPE (op0);
    5993                 :          0 :   tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
    5994                 :            : 
    5995                 :          0 :   op0 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op0);
    5996                 :          0 :   op1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op1);
    5997                 :            : 
    5998                 :          0 :   *expr_p
    5999                 :          0 :     = fold_build2_loc (loc, TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
    6000                 :            : 
    6001                 :          0 :   return GS_OK;
    6002                 :            : }
    6003                 :            : 
    6004                 :            : /* Gimplify an expression sequence.  This function gimplifies each
    6005                 :            :    expression and rewrites the original expression with the last
    6006                 :            :    expression of the sequence in GIMPLE form.
    6007                 :            : 
    6008                 :            :    PRE_P points to the list where the side effects for all the
    6009                 :            :        expressions in the sequence will be emitted.
    6010                 :            : 
    6011                 :            :    WANT_VALUE is true when the result of the last COMPOUND_EXPR is used.  */
    6012                 :            : 
    6013                 :            : static enum gimplify_status
    6014                 :     727003 : gimplify_compound_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
    6015                 :            : {
    6016                 :     727003 :   tree t = *expr_p;
    6017                 :            : 
    6018                 :     769030 :   do
    6019                 :            :     {
    6020                 :     769030 :       tree *sub_p = &TREE_OPERAND (t, 0);
    6021                 :            : 
    6022                 :     769030 :       if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
    6023                 :     124629 :         gimplify_compound_expr (sub_p, pre_p, false);
    6024                 :            :       else
    6025                 :     644401 :         gimplify_stmt (sub_p, pre_p);
    6026                 :            : 
    6027                 :     769030 :       t = TREE_OPERAND (t, 1);
    6028                 :            :     }
    6029                 :     769030 :   while (TREE_CODE (t) == COMPOUND_EXPR);
    6030                 :            : 
    6031                 :     727003 :   *expr_p = t;
    6032                 :     727003 :   if (want_value)
    6033                 :            :     return GS_OK;
    6034                 :            :   else
    6035                 :            :     {
    6036                 :     349459 :       gimplify_stmt (expr_p, pre_p);
    6037                 :     349459 :       return GS_ALL_DONE;
    6038                 :            :     }
    6039                 :            : }
    6040                 :            : 
    6041                 :            : /* Gimplify a SAVE_EXPR node.  EXPR_P points to the expression to
    6042                 :            :    gimplify.  After gimplification, EXPR_P will point to a new temporary
    6043                 :            :    that holds the original value of the SAVE_EXPR node.
    6044                 :            : 
    6045                 :            :    PRE_P points to the list where side effects that must happen before
    6046                 :            :    *EXPR_P should be stored.  */
    6047                 :            : 
    6048                 :            : static enum gimplify_status
    6049                 :     395676 : gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
    6050                 :            : {
    6051                 :     395676 :   enum gimplify_status ret = GS_ALL_DONE;
    6052                 :     395676 :   tree val;
    6053                 :            : 
    6054                 :     395676 :   gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
    6055                 :     395676 :   val = TREE_OPERAND (*expr_p, 0);
    6056                 :            : 
    6057                 :            :   /* If the SAVE_EXPR has not been resolved, then evaluate it once.  */
    6058                 :     395676 :   if (!SAVE_EXPR_RESOLVED_P (*expr_p))
    6059                 :            :     {
    6060                 :            :       /* The operand may be a void-valued expression.  It is
    6061                 :            :          being executed only for its side-effects.  */
    6062                 :     164009 :       if (TREE_TYPE (val) == void_type_node)
    6063                 :            :         {
    6064                 :          0 :           ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
    6065                 :            :                                is_gimple_stmt, fb_none);
    6066                 :          0 :           val = NULL;
    6067                 :            :         }
    6068                 :            :       else
    6069                 :            :         /* The temporary may not be an SSA name as later abnormal and EH
    6070                 :            :            control flow may invalidate use/def domination.  When in SSA
    6071                 :            :            form then assume there are no such issues and SAVE_EXPRs only
    6072                 :            :            appear via GENERIC foldings.  */
    6073                 :     328018 :         val = get_initialized_tmp_var (val, pre_p, post_p,
    6074                 :     328018 :                                        gimple_in_ssa_p (cfun));
    6075                 :            : 
    6076                 :     164009 :       TREE_OPERAND (*expr_p, 0) = val;
    6077                 :     164009 :       SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
    6078                 :            :     }
    6079                 :            : 
    6080                 :     395676 :   *expr_p = val;
    6081                 :            : 
    6082                 :     395676 :   return ret;
    6083                 :            : }
    6084                 :            : 
    6085                 :            : /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
    6086                 :            : 
    6087                 :            :       unary_expr
    6088                 :            :               : ...
    6089                 :            :               | '&' varname
    6090                 :            :               ...
    6091                 :            : 
    6092                 :            :     PRE_P points to the list where side effects that must happen before
    6093                 :            :         *EXPR_P should be stored.
    6094                 :            : 
    6095                 :            :     POST_P points to the list where side effects that must happen after
    6096                 :            :         *EXPR_P should be stored.  */
    6097                 :            : 
    6098                 :            : static enum gimplify_status
    6099                 :   20807000 : gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
    6100                 :            : {
    6101                 :   20807000 :   tree expr = *expr_p;
    6102                 :   20807000 :   tree op0 = TREE_OPERAND (expr, 0);
    6103                 :   20807000 :   enum gimplify_status ret;
    6104                 :   20807000 :   location_t loc = EXPR_LOCATION (*expr_p);
    6105                 :            : 
    6106                 :   20807000 :   switch (TREE_CODE (op0))
    6107                 :            :     {
    6108                 :      43002 :     case INDIRECT_REF:
    6109                 :      43002 :     do_indirect_ref:
    6110                 :            :       /* Check if we are dealing with an expression of the form '&*ptr'.
    6111                 :            :          While the front end folds away '&*ptr' into 'ptr', these
    6112                 :            :          expressions may be generated internally by the compiler (e.g.,
    6113                 :            :          builtins like __builtin_va_end).  */
    6114                 :            :       /* Caution: the silent array decomposition semantics we allow for
    6115                 :            :          ADDR_EXPR means we can't always discard the pair.  */
    6116                 :            :       /* Gimplification of the ADDR_EXPR operand may drop
    6117                 :            :          cv-qualification conversions, so make sure we add them if
    6118                 :            :          needed.  */
    6119                 :      43002 :       {
    6120                 :      43002 :         tree op00 = TREE_OPERAND (op0, 0);
    6121                 :      43002 :         tree t_expr = TREE_TYPE (expr);
    6122                 :      43002 :         tree t_op00 = TREE_TYPE (op00);
    6123                 :            : 
    6124                 :      43002 :         if (!useless_type_conversion_p (t_expr, t_op00))
    6125                 :          0 :           op00 = fold_convert_loc (loc, TREE_TYPE (expr), op00);
    6126                 :      43002 :         *expr_p = op00;
    6127                 :      43002 :         ret = GS_OK;
    6128                 :            :       }
    6129                 :      43002 :       break;
    6130                 :            : 
    6131                 :          0 :     case VIEW_CONVERT_EXPR:
    6132                 :            :       /* Take the address of our operand and then convert it to the type of
    6133                 :            :          this ADDR_EXPR.
    6134                 :            : 
    6135                 :            :          ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
    6136                 :            :          all clear.  The impact of this transformation is even less clear.  */
    6137                 :            : 
    6138                 :            :       /* If the operand is a useless conversion, look through it.  Doing so
    6139                 :            :          guarantees that the ADDR_EXPR and its operand will remain of the
    6140                 :            :          same type.  */
    6141                 :          0 :       if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
    6142                 :          0 :         op0 = TREE_OPERAND (op0, 0);
    6143                 :            : 
    6144                 :          0 :       *expr_p = fold_convert_loc (loc, TREE_TYPE (expr),
    6145                 :            :                                   build_fold_addr_expr_loc (loc,
    6146                 :          0 :                                                         TREE_OPERAND (op0, 0)));
    6147                 :          0 :       ret = GS_OK;
    6148                 :          0 :       break;
    6149                 :            : 
    6150                 :      15633 :     case MEM_REF:
    6151                 :      15633 :       if (integer_zerop (TREE_OPERAND (op0, 1)))
    6152                 :      13102 :         goto do_indirect_ref;
    6153                 :            : 
    6154                 :            :       /* fall through */
    6155                 :            : 
    6156                 :   20764000 :     default:
    6157                 :            :       /* If we see a call to a declared builtin or see its address
    6158                 :            :          being taken (we can unify those cases here) then we can mark
    6159                 :            :          the builtin for implicit generation by GCC.  */
    6160                 :   20764000 :       if (TREE_CODE (op0) == FUNCTION_DECL
    6161                 :   10686900 :           && fndecl_built_in_p (op0, BUILT_IN_NORMAL)
    6162                 :   23120800 :           && builtin_decl_declared_p (DECL_FUNCTION_CODE (op0)))
    6163                 :     562196 :         set_builtin_decl_implicit_p (DECL_FUNCTION_CODE (op0), true);
    6164                 :            : 
    6165                 :            :       /* We use fb_either here because the C frontend sometimes takes
    6166                 :            :          the address of a call that returns a struct; see
    6167                 :            :          gcc.dg/c99-array-lval-1.c.  The gimplifier will correctly make
    6168                 :            :          the implied temporary explicit.  */
    6169                 :            : 
    6170                 :            :       /* Make the operand addressable.  */
    6171                 :   20764000 :       ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
    6172                 :            :                            is_gimple_addressable, fb_either);
    6173                 :   20764000 :       if (ret == GS_ERROR)
    6174                 :            :         break;
    6175                 :            : 
    6176                 :            :       /* Then mark it.  Beware that it may not be possible to do so directly
    6177                 :            :          if a temporary has been created by the gimplification.  */
    6178                 :   20763600 :       prepare_gimple_addressable (&TREE_OPERAND (expr, 0), pre_p);
    6179                 :            : 
    6180                 :   20763600 :       op0 = TREE_OPERAND (expr, 0);
    6181                 :            : 
    6182                 :            :       /* For various reasons, the gimplification of the expression
    6183                 :            :          may have made a new INDIRECT_REF.  */
    6184                 :   20763600 :       if (TREE_CODE (op0) == INDIRECT_REF)
    6185                 :          0 :         goto do_indirect_ref;
    6186                 :            : 
    6187                 :   20763600 :       mark_addressable (TREE_OPERAND (expr, 0));
    6188                 :            : 
    6189                 :            :       /* The FEs may end up building ADDR_EXPRs early on a decl with
    6190                 :            :          an incomplete type.  Re-build ADDR_EXPRs in canonical form
    6191                 :            :          here.  */
    6192                 :   20763600 :       if (!types_compatible_p (TREE_TYPE (op0), TREE_TYPE (TREE_TYPE (expr))))
    6193                 :     101171 :         *expr_p = build_fold_addr_expr (op0);
    6194                 :            : 
    6195                 :            :       /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly.  */
    6196                 :   20763600 :       recompute_tree_invariant_for_addr_expr (*expr_p);
    6197                 :            : 
    6198                 :            :       /* If we re-built the ADDR_EXPR add a conversion to the original type
    6199                 :            :          if required.  */
    6200                 :   20763600 :       if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
    6201                 :          0 :         *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
    6202                 :            : 
    6203                 :            :       break;
    6204                 :            :     }
    6205                 :            : 
    6206                 :   20807000 :   return ret;
    6207                 :            : }
    6208                 :            : 
    6209                 :            : /* Gimplify the operands of an ASM_EXPR.  Input operands should be a gimple
    6210                 :            :    value; output operands should be a gimple lvalue.  */
    6211                 :            : 
    6212                 :            : static enum gimplify_status
    6213                 :      84553 : gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
    6214                 :            : {
    6215                 :      84553 :   tree expr;
    6216                 :      84553 :   int noutputs;
    6217                 :      84553 :   const char **oconstraints;
    6218                 :      84553 :   int i;
    6219                 :      84553 :   tree link;
    6220                 :      84553 :   const char *constraint;
    6221                 :      84553 :   bool allows_mem, allows_reg, is_inout;
    6222                 :      84553 :   enum gimplify_status ret, tret;
    6223                 :      84553 :   gasm *stmt;
    6224                 :      84553 :   vec<tree, va_gc> *inputs;
    6225                 :      84553 :   vec<tree, va_gc> *outputs;
    6226                 :      84553 :   vec<tree, va_gc> *clobbers;
    6227                 :      84553 :   vec<tree, va_gc> *labels;
    6228                 :      84553 :   tree link_next;
    6229                 :            : 
    6230                 :      84553 :   expr = *expr_p;
    6231                 :      84553 :   noutputs = list_length (ASM_OUTPUTS (expr));
    6232                 :      84553 :   oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
    6233                 :            : 
    6234                 :      84553 :   inputs = NULL;
    6235                 :      84553 :   outputs = NULL;
    6236                 :      84553 :   clobbers = NULL;
    6237                 :      84553 :   labels = NULL;
    6238                 :            : 
    6239                 :      84553 :   ret = GS_ALL_DONE;
    6240                 :      84553 :   link_next = NULL_TREE;
    6241                 :     148085 :   for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = link_next)
    6242                 :            :     {
    6243                 :      63547 :       bool ok;
    6244                 :      63547 :       size_t constraint_len;
    6245                 :            : 
    6246                 :      63547 :       link_next = TREE_CHAIN (link);
    6247                 :            : 
    6248                 :     127094 :       oconstraints[i]
    6249                 :      63547 :         = constraint
    6250                 :      63547 :         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
    6251                 :      63547 :       constraint_len = strlen (constraint);
    6252                 :      63547 :       if (constraint_len == 0)
    6253                 :          6 :         continue;
    6254                 :            : 
    6255                 :      63541 :       ok = parse_output_constraint (&constraint, i, 0, 0,
    6256                 :            :                                     &allows_mem, &allows_reg, &is_inout);
    6257                 :      63541 :       if (!ok)
    6258                 :            :         {
    6259                 :          4 :           ret = GS_ERROR;
    6260                 :          4 :           is_inout = false;
    6261                 :            :         }
    6262                 :            : 
    6263                 :            :       /* If we can't make copies, we can only accept memory.
    6264                 :            :          Similarly for VLAs.  */
    6265                 :      63541 :       tree outtype = TREE_TYPE (TREE_VALUE (link));
    6266                 :      63541 :       if (outtype != error_mark_node
    6267                 :      63541 :           && (TREE_ADDRESSABLE (outtype)
    6268                 :     127042 :               || !COMPLETE_TYPE_P (outtype)
    6269                 :      63493 :               || !tree_fits_poly_uint64_p (TYPE_SIZE_UNIT (outtype))))
    6270                 :            :         {
    6271                 :         55 :           if (allows_mem)
    6272                 :         40 :             allows_reg = 0;
    6273                 :            :           else
    6274                 :            :             {
    6275                 :         15 :               error ("impossible constraint in %<asm%>");
    6276                 :         15 :               error ("non-memory output %d must stay in memory", i);
    6277                 :         15 :               return GS_ERROR;
    6278                 :            :             }
    6279                 :            :         }
    6280                 :            : 
    6281                 :      63526 :       if (!allows_reg && allows_mem)
    6282                 :       1263 :         mark_addressable (TREE_VALUE (link));
    6283                 :            : 
    6284                 :     117449 :       tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
    6285                 :            :                             is_inout ? is_gimple_min_lval : is_gimple_lvalue,
    6286                 :            :                             fb_lvalue | fb_mayfail);
    6287                 :      63526 :       if (tret == GS_ERROR)
    6288                 :            :         {
    6289                 :         10 :           error ("invalid lvalue in %<asm%> output %d", i);
    6290                 :         10 :           ret = tret;
    6291                 :            :         }
    6292                 :            : 
    6293                 :            :       /* If the constraint does not allow memory make sure we gimplify
    6294                 :            :          it to a register if it is not already but its base is.  This
    6295                 :            :          happens for complex and vector components.  */
    6296                 :      63526 :       if (!allows_mem)
    6297                 :            :         {
    6298                 :      54724 :           tree op = TREE_VALUE (link);
    6299                 :      54724 :           if (! is_gimple_val (op)
    6300                 :      20695 :               && is_gimple_reg_type (TREE_TYPE (op))
    6301                 :      75418 :               && is_gimple_reg (get_base_address (op)))
    6302                 :            :             {
    6303                 :         14 :               tree tem = create_tmp_reg (TREE_TYPE (op));
    6304                 :         14 :               tree ass;
    6305                 :         14 :               if (is_inout)
    6306                 :            :                 {
    6307                 :          7 :                   ass = build2 (MODIFY_EXPR, TREE_TYPE (tem),
    6308                 :            :                                 tem, unshare_expr (op));
    6309                 :          7 :                   gimplify_and_add (ass, pre_p);
    6310                 :            :                 }
    6311                 :         14 :               ass = build2 (MODIFY_EXPR, TREE_TYPE (tem), op, tem);
    6312                 :         14 :               gimplify_and_add (ass, post_p);
    6313                 :            : 
    6314                 :         14 :               TREE_VALUE (link) = tem;
    6315                 :         14 :               tret = GS_OK;
    6316                 :            :             }
    6317                 :            :         }
    6318                 :            : 
    6319                 :      63526 :       vec_safe_push (outputs, link);
    6320                 :      63526 :       TREE_CHAIN (link) = NULL_TREE;
    6321                 :            : 
    6322                 :      63526 :       if (is_inout)
    6323                 :            :         {
    6324                 :            :           /* An input/output operand.  To give the optimizers more
    6325                 :            :              flexibility, split it into separate input and output
    6326                 :            :              operands.  */
    6327                 :       9603 :           tree input;
    6328                 :            :           /* Buffer big enough to format a 32-bit UINT_MAX into.  */
    6329                 :       9603 :           char buf[11];
    6330                 :            : 
    6331                 :            :           /* Turn the in/out constraint into an output constraint.  */
    6332                 :       9603 :           char *p = xstrdup (constraint);
    6333                 :       9603 :           p[0] = '=';
    6334                 :       9603 :           TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
    6335                 :            : 
    6336                 :            :           /* And add a matching input constraint.  */
    6337                 :       9603 :           if (allows_reg)
    6338                 :            :             {
    6339                 :       9360 :               sprintf (buf, "%u", i);
    6340                 :            : 
    6341                 :            :               /* If there are multiple alternatives in the constraint,
    6342                 :            :                  handle each of them individually.  Those that allow register
    6343                 :            :                  will be replaced with operand number, the others will stay
    6344                 :            :                  unchanged.  */
    6345                 :       9360 :               if (strchr (p, ',') != NULL)
    6346                 :            :                 {
    6347                 :        100 :                   size_t len = 0, buflen = strlen (buf);
    6348                 :        100 :                   char *beg, *end, *str, *dst;
    6349                 :            : 
    6350                 :        100 :                   for (beg = p + 1;;)
    6351                 :            :                     {
    6352                 :        200 :                       end = strchr (beg, ',');
    6353                 :        200 :                       if (end == NULL)
    6354                 :        100 :                         end = strchr (beg, '\0');
    6355                 :        200 :                       if ((size_t) (end - beg) < buflen)
    6356                 :         28 :                         len += buflen + 1;
    6357                 :            :                       else
    6358                 :        172 :                         len += end - beg + 1;
    6359                 :        200 :                       if (*end)
    6360                 :        100 :                         beg = end + 1;
    6361                 :            :                       else
    6362                 :            :                         break;
    6363                 :            :                     }
    6364                 :            : 
    6365                 :        100 :                   str = (char *) alloca (len);
    6366                 :        100 :                   for (beg = p + 1, dst = str;;)
    6367                 :            :                     {
    6368                 :        200 :                       const char *tem;
    6369                 :        200 :                       bool mem_p, reg_p, inout_p;
    6370                 :            : 
    6371                 :        200 :                       end = strchr (beg, ',');
    6372                 :        200 :                       if (end)
    6373                 :        100 :                         *end = '\0';
    6374                 :        200 :                       beg[-1] = '=';
    6375                 :        200 :                       tem = beg - 1;
    6376                 :        200 :                       parse_output_constraint (&tem, i, 0, 0,
    6377                 :            :                                                &mem_p, &reg_p, &inout_p);
    6378                 :        200 :                       if (dst != str)
    6379                 :        100 :                         *dst++ = ',';
    6380                 :        200 :                       if (reg_p)
    6381                 :            :                         {
    6382                 :        115 :                           memcpy (dst, buf, buflen);
    6383                 :        115 :                           dst += buflen;
    6384                 :            :                         }
    6385                 :            :                       else
    6386                 :            :                         {
    6387                 :         85 :                           if (end)
    6388                 :          0 :                             len = end - beg;
    6389                 :            :                           else
    6390                 :         85 :                             len = strlen (beg);
    6391                 :         85 :                           memcpy (dst, beg, len);
    6392                 :         85 :                           dst += len;
    6393                 :            :                         }
    6394                 :        200 :                       if (end)
    6395                 :        100 :                         beg = end + 1;
    6396                 :            :                       else
    6397                 :            :                         break;
    6398                 :        100 :                     }
    6399                 :        100 :                   *dst = '\0';
    6400                 :        100 :                   input = build_string (dst - str, str);
    6401                 :            :                 }
    6402                 :            :               else
    6403                 :       9260 :                 input = build_string (strlen (buf), buf);
    6404                 :            :             }
    6405                 :            :           else
    6406                 :        243 :             input = build_string (constraint_len - 1, constraint + 1);
    6407                 :            : 
    6408                 :       9603 :           free (p);
    6409                 :            : 
    6410                 :       9603 :           input = build_tree_list (build_tree_list (NULL_TREE, input),
    6411                 :       9603 :                                    unshare_expr (TREE_VALUE (link)));
    6412                 :       9603 :           ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
    6413                 :            :         }
    6414                 :            :     }
    6415                 :            : 
    6416                 :      84538 :   link_next = NULL_TREE;
    6417                 :     124835 :   for (link = ASM_INPUTS (expr); link; ++i, link = link_next)
    6418                 :            :     {
    6419                 :      40309 :       link_next = TREE_CHAIN (link);
    6420                 :      40309 :       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
    6421                 :      40309 :       parse_input_constraint (&constraint, 0, 0, noutputs, 0,
    6422                 :            :                               oconstraints, &allows_mem, &allows_reg);
    6423                 :            : 
    6424                 :            :       /* If we can't make copies, we can only accept memory.  */
    6425                 :      40309 :       tree intype = TREE_TYPE (TREE_VALUE (link));
    6426                 :      40309 :       if (intype != error_mark_node
    6427                 :      40309 :           && (TREE_ADDRESSABLE (intype)
    6428                 :      80560 :               || !COMPLETE_TYPE_P (intype)
    6429                 :      40251 :               || !tree_fits_poly_uint64_p (TYPE_SIZE_UNIT (intype))))
    6430                 :            :         {
    6431                 :         50 :           if (allows_mem)
    6432                 :         38 :             allows_reg = 0;
    6433                 :            :           else
    6434                 :            :             {
    6435                 :         12 :               error ("impossible constraint in %<asm%>");
    6436                 :         12 :               error ("non-memory input %d must stay in memory", i);
    6437                 :         12 :               return GS_ERROR;
    6438                 :            :             }
    6439                 :            :         }
    6440                 :            : 
    6441                 :            :       /* If the operand is a memory input, it should be an lvalue.  */
    6442                 :      40297 :       if (!allows_reg && allows_mem)
    6443                 :            :         {
    6444                 :       1693 :           tree inputv = TREE_VALUE (link);
    6445                 :       1693 :           STRIP_NOPS (inputv);
    6446                 :       1693 :           if (TREE_CODE (inputv) == PREDECREMENT_EXPR
    6447                 :            :               || TREE_CODE (inputv) == PREINCREMENT_EXPR
    6448                 :            :               || TREE_CODE (inputv) == POSTDECREMENT_EXPR
    6449                 :       1693 :               || TREE_CODE (inputv) == POSTINCREMENT_EXPR
    6450                 :       1679 :               || TREE_CODE (inputv) == MODIFY_EXPR)
    6451                 :         16 :             TREE_VALUE (link) = error_mark_node;
    6452                 :       1693 :           tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
    6453                 :            :                                 is_gimple_lvalue, fb_lvalue | fb_mayfail);
    6454                 :       1693 :           if (tret != GS_ERROR)
    6455                 :            :             {
    6456                 :            :               /* Unlike output operands, memory inputs are not guaranteed
    6457                 :            :                  to be lvalues by the FE, and while the expressions are
    6458                 :            :                  marked addressable there, if it is e.g. a statement
    6459                 :            :                  expression, temporaries in it might not end up being
    6460                 :            :                  addressable.  They might be already used in the IL and thus
    6461                 :            :                  it is too late to make them addressable now though.  */
    6462                 :       1663 :               tree x = TREE_VALUE (link);
    6463                 :       2071 :               while (handled_component_p (x))
    6464                 :        408 :                 x = TREE_OPERAND (x, 0);
    6465                 :       1663 :               if (TREE_CODE (x) == MEM_REF
    6466                 :       1663 :                   && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
    6467                 :          0 :                 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
    6468                 :       1663 :               if ((VAR_P (x)
    6469                 :       1663 :                    || TREE_CODE (x) == PARM_DECL
    6470                 :        462 :                    || TREE_CODE (x) == RESULT_DECL)
    6471                 :       1201 :                   && !TREE_ADDRESSABLE (x)
    6472                 :       1675 :                   && is_gimple_reg (x))
    6473                 :            :                 {
    6474                 :         12 :                   warning_at (EXPR_LOC_OR_LOC (TREE_VALUE (link),
    6475                 :            :                                                input_location), 0,
    6476                 :            :                               "memory input %d is not directly addressable",
    6477                 :            :                               i);
    6478                 :         12 :                   prepare_gimple_addressable (&TREE_VALUE (link), pre_p);
    6479                 :            :                 }
    6480                 :            :             }
    6481                 :       1693 :           mark_addressable (TREE_VALUE (link));
    6482                 :       1693 :           if (tret == GS_ERROR)
    6483                 :            :             {
    6484                 :         30 :               error_at (EXPR_LOC_OR_LOC (TREE_VALUE (link), input_location),
    6485                 :            :                         "memory input %d is not directly addressable", i);
    6486                 :         30 :               ret = tret;
    6487                 :            :             }
    6488                 :            :         }
    6489                 :            :       else
    6490                 :            :         {
    6491                 :      38604 :           tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
    6492                 :            :                                 is_gimple_asm_val, fb_rvalue);
    6493                 :      38604 :           if (tret == GS_ERROR)
    6494                 :         12 :             ret = tret;
    6495                 :            :         }
    6496                 :            : 
    6497                 :      40297 :       TREE_CHAIN (link) = NULL_TREE;
    6498                 :      40297 :       vec_safe_push (inputs, link);
    6499                 :            :     }
    6500                 :            : 
    6501                 :      84526 :   link_next = NULL_TREE;
    6502                 :     170157 :   for (link = ASM_CLOBBERS (expr); link; ++i, link = link_next)
    6503                 :            :     {
    6504                 :      85631 :       link_next = TREE_CHAIN (link);
    6505                 :      85631 :       TREE_CHAIN (link) = NULL_TREE;
    6506                 :      85631 :       vec_safe_push (clobbers, link);
    6507                 :            :     }
    6508                 :            : 
    6509                 :      84526 :   link_next = NULL_TREE;
    6510                 :      84892 :   for (link = ASM_LABELS (expr); link; ++i, link = link_next)
    6511                 :            :     {
    6512                 :        366 :       link_next = TREE_CHAIN (link);
    6513                 :        366 :       TREE_CHAIN (link) = NULL_TREE;
    6514                 :        366 :       vec_safe_push (labels, link);
    6515                 :            :     }
    6516                 :            : 
    6517                 :            :   /* Do not add ASMs with errors to the gimple IL stream.  */
    6518                 :      84526 :   if (ret != GS_ERROR)
    6519                 :            :     {
    6520                 :      84474 :       stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
    6521                 :            :                                    inputs, outputs, clobbers, labels);
    6522                 :            : 
    6523                 :      84474 :       gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr) || noutputs == 0);
    6524                 :      84474 :       gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
    6525                 :      84474 :       gimple_asm_set_inline (stmt, ASM_INLINE_P (expr));
    6526                 :            : 
    6527                 :      84474 :       gimplify_seq_add_stmt (pre_p, stmt);
    6528                 :            :     }
    6529                 :            : 
    6530                 :            :   return ret;
    6531                 :            : }
    6532                 :            : 
    6533                 :            : /* Gimplify a CLEANUP_POINT_EXPR.  Currently this works by adding
    6534                 :            :    GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
    6535                 :            :    gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
    6536                 :            :    return to this function.
    6537                 :            : 
    6538                 :            :    FIXME should we complexify the prequeue handling instead?  Or use flags
    6539                 :            :    for all the cleanups and let the optimizer tighten them up?  The current
    6540                 :            :    code seems pretty fragile; it will break on a cleanup within any
    6541                 :            :    non-conditional nesting.  But any such nesting would be broken, anyway;
    6542                 :            :    we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
    6543                 :            :    and continues out of it.  We can do that at the RTL level, though, so
    6544                 :            :    having an optimizer to tighten up try/finally regions would be a Good
    6545                 :            :    Thing.  */
    6546                 :            : 
    6547                 :            : static enum gimplify_status
    6548                 :    3291200 : gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
    6549                 :            : {
    6550                 :    3291200 :   gimple_stmt_iterator iter;
    6551                 :    3291200 :   gimple_seq body_sequence = NULL;
    6552                 :            : 
    6553                 :    3291200 :   tree temp = voidify_wrapper_expr (*expr_p, NULL);
    6554                 :            : 
    6555                 :            :   /* We only care about the number of conditions between the innermost
    6556                 :            :      CLEANUP_POINT_EXPR and the cleanup.  So save and reset the count and
    6557                 :            :      any cleanups collected outside the CLEANUP_POINT_EXPR.  */
    6558                 :    3291200 :   int old_conds = gimplify_ctxp->conditions;
    6559                 :    3291200 :   gimple_seq old_cleanups = gimplify_ctxp->conditional_cleanups;
    6560                 :    3291200 :   bool old_in_cleanup_point_expr = gimplify_ctxp->in_cleanup_point_expr;
    6561                 :    3291200 :   gimplify_ctxp->conditions = 0;
    6562                 :    3291200 :   gimplify_ctxp->conditional_cleanups = NULL;
    6563                 :    3291200 :   gimplify_ctxp->in_cleanup_point_expr = true;
    6564                 :            : 
    6565                 :    3291200 :   gimplify_stmt (&TREE_OPERAND (*expr_p, 0), &body_sequence);
    6566                 :            : 
    6567                 :    3291200 :   gimplify_ctxp->conditions = old_conds;
    6568                 :    3291200 :   gimplify_ctxp->conditional_cleanups = old_cleanups;
    6569                 :    3291200 :   gimplify_ctxp->in_cleanup_point_expr = old_in_cleanup_point_expr;
    6570                 :            : 
    6571                 :   16119100 :   for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
    6572                 :            :     {
    6573                 :    9557670 :       gimple *wce = gsi_stmt (iter);
    6574                 :            : 
    6575                 :    9557670 :       if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
    6576                 :            :         {
    6577                 :     288455 :           if (gsi_one_before_end_p (iter))
    6578                 :            :             {
    6579                 :            :               /* Note that gsi_insert_seq_before and gsi_remove do not
    6580                 :            :                  scan operands, unlike some other sequence mutators.  */
    6581                 :       5485 :               if (!gimple_wce_cleanup_eh_only (wce))
    6582                 :       5202 :                 gsi_insert_seq_before_without_update (&iter,
    6583                 :            :                                                       gimple_wce_cleanup (wce),
    6584                 :            :                                                       GSI_SAME_STMT);
    6585                 :       5485 :               gsi_remove (&iter, true);
    6586                 :       5485 :               break;
    6587                 :            :             }
    6588                 :            :           else
    6589                 :            :             {
    6590                 :     282970 :               gtry *gtry;
    6591                 :     282970 :               gimple_seq seq;
    6592                 :     282970 :               enum gimple_try_flags kind;
    6593                 :            : 
    6594                 :     282970 :               if (gimple_wce_cleanup_eh_only (wce))
    6595                 :            :                 kind = GIMPLE_TRY_CATCH;
    6596                 :            :               else
    6597                 :     272803 :                 kind = GIMPLE_TRY_FINALLY;
    6598                 :     282970 :               seq = gsi_split_seq_after (iter);
    6599                 :            : 
    6600                 :     282970 :               gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
    6601                 :            :               /* Do not use gsi_replace here, as it may scan operands.
    6602                 :            :                  We want to do a simple structural modification only.  */
    6603                 :     282970 :               gsi_set_stmt (&iter, gtry);
    6604                 :     565940 :               iter = gsi_start (gtry->eval);
    6605                 :            :             }
    6606                 :            :         }
    6607                 :            :       else
    6608                 :    9269220 :         gsi_next (&iter);
    6609                 :            :     }
    6610                 :            : 
    6611                 :    3291200 :   gimplify_seq_add_seq (pre_p, body_sequence);
    6612                 :    3291200 :   if (temp)
    6613                 :            :     {
    6614                 :     235486 :       *expr_p = temp;
    6615                 :     235486 :       return GS_OK;
    6616                 :            :     }
    6617                 :            :   else
    6618                 :            :     {
    6619                 :    3055710 :       *expr_p = NULL;
    6620                 :    3055710 :       return GS_ALL_DONE;
    6621                 :            :     }
    6622                 :            : }
    6623                 :            : 
    6624                 :            : /* Insert a cleanup marker for gimplify_cleanup_point_expr.  CLEANUP
    6625                 :            :    is the cleanup action required.  EH_ONLY is true if the cleanup should
    6626                 :            :    only be executed if an exception is thrown, not on normal exit.
    6627                 :            :    If FORCE_UNCOND is true perform the cleanup unconditionally;  this is
    6628                 :            :    only valid for clobbers.  */
    6629                 :            : 
    6630                 :            : static void
    6631                 :     291055 : gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p,
    6632                 :            :                      bool force_uncond = false)
    6633                 :            : {
    6634                 :     291055 :   gimple *wce;
    6635                 :     291055 :   gimple_seq cleanup_stmts = NULL;
    6636                 :            : 
    6637                 :            :   /* Errors can result in improperly nested cleanups.  Which results in
    6638                 :            :      confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR.  */
    6639                 :     291055 :   if (seen_error ())
    6640                 :       2600 :     return;
    6641                 :            : 
    6642                 :     288455 :   if (gimple_conditional_context ())
    6643                 :            :     {
    6644                 :            :       /* If we're in a conditional context, this is more complex.  We only
    6645                 :            :          want to run the cleanup if we actually ran the initialization that
    6646                 :            :          necessitates it, but we want to run it after the end of the
    6647                 :            :          conditional context.  So we wrap the try/finally around the
    6648                 :            :          condition and use a flag to determine whether or not to actually
    6649                 :            :          run the destructor.  Thus
    6650                 :            : 
    6651                 :            :            test ? f(A()) : 0
    6652                 :            : 
    6653                 :            :          becomes (approximately)
    6654                 :            : 
    6655                 :            :            flag = 0;
    6656                 :            :            try {
    6657                 :            :              if (test) { A::A(temp); flag = 1; val = f(temp); }
    6658                 :            :              else { val = 0; }
    6659                 :            :            } finally {
    6660                 :            :              if (flag) A::~A(temp);
    6661                 :            :            }
    6662                 :            :            val
    6663                 :            :       */
    6664                 :       8941 :       if (force_uncond)
    6665                 :            :         {
    6666                 :       8479 :           gimplify_stmt (&cleanup, &cleanup_stmts);
    6667                 :       8479 :           wce = gimple_build_wce (cleanup_stmts);
    6668                 :       8479 :           gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
    6669                 :            :         }
    6670                 :            :       else
    6671                 :            :         {
    6672                 :        462 :           tree flag = create_tmp_var (boolean_type_node, "cleanup");
    6673                 :        462 :           gassign *ffalse = gimple_build_assign (flag, boolean_false_node);
    6674                 :        462 :           gassign *ftrue = gimple_build_assign (flag, boolean_true_node);
    6675                 :            : 
    6676                 :        462 :           cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
    6677                 :        462 :           gimplify_stmt (&cleanup, &cleanup_stmts);
    6678                 :        462 :           wce = gimple_build_wce (cleanup_stmts);
    6679                 :            : 
    6680                 :        462 :           gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, ffalse);
    6681                 :        462 :           gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
    6682                 :        462 :           gimplify_seq_add_stmt (pre_p, ftrue);
    6683                 :            : 
    6684                 :            :           /* Because of this manipulation, and the EH edges that jump
    6685                 :            :              threading cannot redirect, the temporary (VAR) will appear
    6686                 :            :              to be used uninitialized.  Don't warn.  */
    6687                 :        462 :           TREE_NO_WARNING (var) = 1;
    6688                 :            :         }
    6689                 :            :     }
    6690                 :            :   else
    6691                 :            :     {
    6692                 :     279514 :       gimplify_stmt (&cleanup, &cleanup_stmts);
    6693                 :     279514 :       wce = gimple_build_wce (cleanup_stmts);
    6694                 :     279514 :       gimple_wce_set_cleanup_eh_only (wce, eh_only);
    6695                 :     567969 :       gimplify_seq_add_stmt (pre_p, wce);
    6696                 :            :     }
    6697                 :            : }
    6698                 :            : 
    6699                 :            : /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR.  */
    6700                 :            : 
    6701                 :            : static enum gimplify_status
    6702                 :     419657 : gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
    6703                 :            : {
    6704                 :     419657 :   tree targ = *expr_p;
    6705                 :     419657 :   tree temp = TARGET_EXPR_SLOT (targ);
    6706                 :     419657 :   tree init = TARGET_EXPR_INITIAL (targ);
    6707                 :     419657 :   enum gimplify_status ret;
    6708                 :            : 
    6709                 :     419657 :   bool unpoison_empty_seq = false;
    6710                 :     419657 :   gimple_stmt_iterator unpoison_it;
    6711                 :            : 
    6712                 :     419657 :   if (init)
    6713                 :            :     {
    6714                 :     398640 :       tree cleanup = NULL_TREE;
    6715                 :            : 
    6716                 :            :       /* TARGET_EXPR temps aren't part of the enclosing block, so add it
    6717                 :            :          to the temps list.  Handle also variable length TARGET_EXPRs.  */
    6718                 :     398640 :       if (!poly_int_tree_p (DECL_SIZE (temp)))
    6719                 :            :         {
    6720                 :         24 :           if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
    6721                 :          1 :             gimplify_type_sizes (TREE_TYPE (temp), pre_p);
    6722                 :         24 :           gimplify_vla_decl (temp, pre_p);
    6723                 :            :         }
    6724                 :            :       else
    6725                 :            :         {
    6726                 :            :           /* Save location where we need to place unpoisoning.  It's possible
    6727                 :            :              that a variable will be converted to needs_to_live_in_memory.  */
    6728                 :     398616 :           unpoison_it = gsi_last (*pre_p);
    6729                 :     398616 :           unpoison_empty_seq = gsi_end_p (unpoison_it);
    6730                 :            : 
    6731                 :     398616 :           gimple_add_tmp_var (temp);
    6732                 :            :         }
    6733                 :            : 
    6734                 :            :       /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
    6735                 :            :          expression is supposed to initialize the slot.  */
    6736                 :     398640 :       if (VOID_TYPE_P (TREE_TYPE (init)))
    6737                 :     194892 :         ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
    6738                 :            :       else
    6739                 :            :         {
    6740                 :     203748 :           tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
    6741                 :     203748 :           init = init_expr;
    6742                 :     203748 :           ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
    6743                 :     203748 :           init = NULL;
    6744                 :     203748 :           ggc_free (init_expr);
    6745                 :            :         }
    6746                 :     398640 :       if (ret == GS_ERROR)
    6747                 :            :         {
    6748                 :            :           /* PR c++/28266 Make sure this is expanded only once. */
    6749                 :          0 :           TARGET_EXPR_INITIAL (targ) = NULL_TREE;
    6750                 :          0 :           return GS_ERROR;
    6751                 :            :         }
    6752                 :     398640 :       if (init)
    6753                 :          0 :         gimplify_and_add (init, pre_p);
    6754                 :            : 
    6755                 :            :       /* If needed, push the cleanup for the temp.  */
    6756                 :     398640 :       if (TARGET_EXPR_CLEANUP (targ))
    6757                 :            :         {
    6758                 :      78451 :           if (CLEANUP_EH_ONLY (targ))
    6759                 :      10559 :             gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
    6760                 :            :                                  CLEANUP_EH_ONLY (targ), pre_p);
    6761                 :            :           else
    6762                 :      67892 :             cleanup = TARGET_EXPR_CLEANUP (targ);
    6763                 :            :         }
    6764                 :            : 
    6765                 :            :       /* Add a clobber for the temporary going out of scope, like
    6766                 :            :          gimplify_bind_expr.  */
    6767                 :     398640 :       if (gimplify_ctxp->in_cleanup_point_expr
    6768                 :     398640 :           && needs_to_live_in_memory (temp))
    6769                 :            :         {
    6770                 :     212619 :           if (flag_stack_reuse == SR_ALL)
    6771                 :            :             {
    6772                 :     212184 :               tree clobber = build_clobber (TREE_TYPE (temp));
    6773                 :     212184 :               clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber);
    6774                 :     212184 :               gimple_push_cleanup (temp, clobber, false, pre_p, true);
    6775                 :            :             }
    6776                 :     212619 :           if (asan_poisoned_variables
    6777                 :        435 :               && DECL_ALIGN (temp) <= MAX_SUPPORTED_STACK_ALIGNMENT
    6778                 :        435 :               && !TREE_STATIC (temp)
    6779                 :        428 :               && dbg_cnt (asan_use_after_scope)
    6780                 :     213047 :               && !gimplify_omp_ctxp)
    6781                 :            :             {
    6782                 :        420 :               tree asan_cleanup = build_asan_poison_call_expr (temp);
    6783                 :        420 :               if (asan_cleanup)
    6784                 :            :                 {
    6785                 :        420 :                   if (unpoison_empty_seq)
    6786                 :        255 :                     unpoison_it = gsi_start (*pre_p);
    6787                 :            : 
    6788                 :        420 :                   asan_poison_variable (temp, false, &unpoison_it,
    6789                 :            :                                         unpoison_empty_seq);
    6790                 :        420 :                   gimple_push_cleanup (temp, asan_cleanup, false, pre_p);
    6791                 :            :                 }
    6792                 :            :             }
    6793                 :            :         }
    6794                 :     398640 :       if (cleanup)
    6795                 :      67892 :         gimple_push_cleanup (temp, cleanup, false, pre_p);
    6796                 :            : 
    6797                 :            :       /* Only expand this once.  */
    6798                 :     398640 :       TREE_OPERAND (targ, 3) = init;
    6799                 :     398640 :       TARGET_EXPR_INITIAL (targ) = NULL_TREE;
    6800                 :            :     }
    6801                 :            :   else
    6802                 :            :     /* We should have expanded this before.  */
    6803                 :      21017 :     gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
    6804                 :            : 
    6805                 :     419657 :   *expr_p = temp;
    6806                 :     419657 :   return GS_OK;
    6807                 :            : }
    6808                 :            : 
    6809                 :            : /* Gimplification of expression trees.  */
    6810                 :            : 
    6811                 :            : /* Gimplify an expression which appears at statement context.  The
    6812                 :            :    corresponding GIMPLE statements are added to *SEQ_P.  If *SEQ_P is
    6813                 :            :    NULL, a new sequence is allocated.
    6814                 :            : 
    6815                 :            :    Return true if we actually added a statement to the queue.  */
    6816                 :            : 
    6817                 :            : bool
    6818                 :   67794800 : gimplify_stmt (tree *stmt_p, gimple_seq *seq_p)
    6819                 :            : {
    6820                 :   67794800 :   gimple_seq_node last;
    6821                 :            : 
    6822                 :   67794800 :   last = gimple_seq_last (*seq_p);
    6823                 :   67794800 :   gimplify_expr (stmt_p, seq_p, NULL, is_gimple_stmt, fb_none);
    6824                 :   67794800 :   return last != gimple_seq_last (*seq_p);
    6825                 :            : }
    6826                 :            : 
    6827                 :            : /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
    6828                 :            :    to CTX.  If entries already exist, force them to be some flavor of private.
    6829                 :            :    If there is no enclosing parallel, do nothing.  */
    6830                 :            : 
    6831                 :            : void
    6832                 :      97110 : omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
    6833                 :            : {
    6834                 :      97110 :   splay_tree_node n;
    6835                 :            : 
    6836                 :      97110 :   if (decl == NULL || !DECL_P (decl) || ctx->region_type == ORT_NONE)
    6837                 :            :     return;
    6838                 :            : 
    6839                 :      30783 :   do
    6840                 :            :     {
    6841                 :      30783 :       n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
    6842                 :      30783 :       if (n != NULL)
    6843                 :            :         {
    6844                 :       3750 :           if (n->value & GOVD_SHARED)
    6845                 :        185 :             n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
    6846                 :       3565 :           else if (n->value & GOVD_MAP)
    6847                 :          4 :             n->value |= GOVD_MAP_TO_ONLY;
    6848                 :            :           else
    6849                 :            :             return;
    6850                 :            :         }
    6851                 :      27033 :       else if ((ctx->region_type & ORT_TARGET) != 0)
    6852                 :            :         {
    6853                 :       5234 :           if (ctx->defaultmap[GDMK_SCALAR] & GOVD_FIRSTPRIVATE)
    6854                 :       3468 :             omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
    6855                 :            :           else
    6856                 :       1766 :             omp_add_variable (ctx, decl, GOVD_MAP | GOVD_MAP_TO_ONLY);
    6857                 :            :         }
    6858                 :      21799 :       else if (ctx->region_type != ORT_WORKSHARE
    6859                 :            :                && ctx->region_type != ORT_TASKGROUP
    6860                 :      21799 :                && ctx->region_type != ORT_SIMD
    6861                 :      19522 :                && ctx->region_type != ORT_ACC
    6862                 :      19502 :                && !(ctx->region_type & ORT_TARGET_DATA))
    6863                 :      12022 :         omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
    6864                 :            : 
    6865                 :      27222 :       ctx = ctx->outer_context;
    6866                 :            :     }
    6867                 :      27222 :   while (ctx);
    6868                 :            : }
    6869                 :            : 
    6870                 :            : /* Similarly for each of the type sizes of TYPE.  */
    6871                 :            : 
    6872                 :            : static void
    6873                 :      30970 : omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
    6874                 :            : {
    6875                 :      30970 :   if (type == NULL || type == error_mark_node)
    6876                 :            :     return;
    6877                 :      30970 :   type = TYPE_MAIN_VARIANT (type);
    6878                 :            : 
    6879                 :      30970 :   if (ctx->privatized_types->add (type))
    6880                 :            :     return;
    6881                 :            : 
    6882                 :      23634 :   switch (TREE_CODE (type))
    6883                 :            :     {
    6884                 :       9922 :     case INTEGER_TYPE:
    6885                 :       9922 :     case ENUMERAL_TYPE:
    6886                 :       9922 :     case BOOLEAN_TYPE:
    6887                 :       9922 :     case REAL_TYPE:
    6888                 :       9922 :     case FIXED_POINT_TYPE:
    6889                 :       9922 :       omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
    6890                 :       9922 :       omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
    6891                 :       9922 :       break;
    6892                 :            : 
    6893                 :       4187 :     case ARRAY_TYPE:
    6894                 :       4187 :       omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
    6895                 :       4187 :       omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
    6896                 :       4187 :       break;
    6897                 :            : 
    6898                 :       2248 :     case RECORD_TYPE:
    6899                 :       2248 :     case UNION_TYPE:
    6900                 :       2248 :     case QUAL_UNION_TYPE:
    6901                 :       2248 :       {
    6902                 :       2248 :         tree field;
    6903                 :      24413 :         for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
    6904                 :      22165 :           if (TREE_CODE (field) == FIELD_DECL)
    6905                 :            :             {
    6906                 :       7861 :               omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
    6907                 :       7861 :               omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
    6908                 :            :             }
    6909                 :            :       }
    6910                 :            :       break;
    6911                 :            : 
    6912                 :       6776 :     case POINTER_TYPE:
    6913                 :       6776 :     case REFERENCE_TYPE:
    6914                 :       6776 :       omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
    6915                 :       6776 :       break;
    6916                 :            : 
    6917                 :            :     default:
    6918                 :            :       break;
    6919                 :            :     }
    6920                 :            : 
    6921                 :      23634 :   omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
    6922                 :      23634 :   omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
    6923                 :      23634 :   lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
    6924                 :            : }
    6925                 :            : 
    6926                 :            : /* Add an entry for DECL in the OMP context CTX with FLAGS.  */
    6927                 :            : 
    6928                 :            : static void
    6929                 :     508300 : omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
    6930                 :            : {
    6931                 :     508300 :   splay_tree_node n;
    6932                 :     508300 :   unsigned int nflags;
    6933                 :     508300 :   tree t;
    6934                 :            : 
    6935                 :    1016600 :   if (error_operand_p (decl) || ctx->region_type == ORT_NONE)
    6936                 :            :     return;
    6937                 :            : 
    6938                 :            :   /* Never elide decls whose type has TREE_ADDRESSABLE set.  This means
    6939                 :            :      there are constructors involved somewhere.  Exception is a shared clause,
    6940                 :            :      there is nothing privatized in that case.  */
    6941                 :     508285 :   if ((flags & GOVD_SHARED) == 0
    6942                 :     508285 :       && (TREE_ADDRESSABLE (TREE_TYPE (decl))
    6943                 :     466828 :           || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl))))
    6944                 :       3359 :     flags |= GOVD_SEEN;
    6945                 :            : 
    6946                 :     508285 :   n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
    6947                 :     508285 :   if (n != NULL && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
    6948                 :            :     {
    6949                 :            :       /* We shouldn't be re-adding the decl with the same data
    6950                 :            :          sharing class.  */
    6951                 :        412 :       gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
    6952                 :        412 :       nflags = n->value | flags;
    6953                 :            :       /* The only combination of data sharing classes we should see is
    6954                 :            :          FIRSTPRIVATE and LASTPRIVATE.  However, OpenACC permits
    6955                 :            :          reduction variables to be used in data sharing clauses.  */
    6956                 :        412 :       gcc_assert ((ctx->region_type & ORT_ACC) != 0
    6957                 :            :                   || ((nflags & GOVD_DATA_SHARE_CLASS)
    6958                 :            :                       == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE))
    6959                 :            :                   || (flags & GOVD_DATA_SHARE_CLASS) == 0);
    6960                 :        412 :       n->value = nflags;
    6961                 :        412 :       return;
    6962                 :            :     }
    6963                 :            : 
    6964                 :            :   /* When adding a variable-sized variable, we have to handle all sorts
    6965                 :            :      of additional bits of data: the pointer replacement variable, and
    6966                 :            :      the parameters of the type.  */
    6967                 :     507873 :   if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
    6968                 :            :     {
    6969                 :            :       /* Add the pointer replacement variable as PRIVATE if the variable
    6970                 :            :          replacement is private, else FIRSTPRIVATE since we'll need the
    6971                 :            :          address of the original variable either for SHARED, or for the
    6972                 :            :          copy into or out of the context.  */
    6973                 :       1064 :       if (!(flags & GOVD_LOCAL) && ctx->region_type != ORT_TASKGROUP)
    6974                 :            :         {
    6975                 :       1003 :           if (flags & GOVD_MAP)
    6976                 :            :             nflags = GOVD_MAP | GOVD_MAP_TO_ONLY | GOVD_EXPLICIT;
    6977                 :        457 :           else if (flags & GOVD_PRIVATE)
    6978                 :            :             nflags = GOVD_PRIVATE;
    6979                 :        377 :           else if (((ctx->region_type & (ORT_TARGET | ORT_TARGET_DATA)) != 0
    6980                 :         10 :                     && (flags & GOVD_FIRSTPRIVATE))
    6981                 :        371 :                    || (ctx->region_type == ORT_TARGET_DATA
    6982                 :          4 :                        && (flags & GOVD_DATA_SHARE_CLASS) == 0))
    6983                 :            :             nflags = GOVD_PRIVATE | GOVD_EXPLICIT;
    6984                 :            :           else
    6985                 :        367 :             nflags = GOVD_FIRSTPRIVATE;
    6986                 :       1003 :           nflags |= flags & GOVD_SEEN;
    6987                 :       1003 :           t = DECL_VALUE_EXPR (decl);
    6988                 :       1003 :           gcc_assert (TREE_CODE (t) == INDIRECT_REF);
    6989                 :       1003 :           t = TREE_OPERAND (t, 0);
    6990                 :       1003 :           gcc_assert (DECL_P (t));
    6991                 :       1003 :           omp_add_variable (ctx, t, nflags);
    6992                 :            :         }
    6993                 :            : 
    6994                 :            :       /* Add all of the variable and type parameters (which should have
    6995                 :            :          been gimplified to a formal temporary) as FIRSTPRIVATE.  */
    6996                 :       1064 :       omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
    6997                 :       1064 :       omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
    6998                 :       1064 :       omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
    6999                 :            : 
    7000                 :            :       /* The variable-sized variable itself is never SHARED, only some form
    7001                 :            :          of PRIVATE.  The sharing would take place via the pointer variable
    7002                 :            :          which we remapped above.  */
    7003                 :       1064 :       if (flags & GOVD_SHARED)
    7004                 :        294 :         flags = GOVD_SHARED | GOVD_DEBUG_PRIVATE
    7005                 :        294 :                 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
    7006                 :            : 
    7007                 :            :       /* We're going to make use of the TYPE_SIZE_UNIT at least in the
    7008                 :            :          alloca statement we generate for the variable, so make sure it
    7009                 :            :          is available.  This isn't automatically needed for the SHARED
    7010                 :            :          case, since we won't be allocating local storage then.
    7011                 :            :          For local variables TYPE_SIZE_UNIT might not be gimplified yet,
    7012                 :            :          in this case omp_notice_variable will be called later
    7013                 :            :          on when it is gimplified.  */
    7014                 :        770 :       else if (! (flags & (GOVD_LOCAL | GOVD_MAP))
    7015                 :        945 :                && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl))))
    7016                 :        175 :         omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
    7017                 :            :     }
    7018                 :     506809 :   else if ((flags & (GOVD_MAP | GOVD_LOCAL)) == 0
    7019                 :     506809 :            && lang_hooks.decls.omp_privatize_by_reference (decl))
    7020                 :            :     {
    7021                 :       6895 :       omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
    7022                 :            : 
    7023                 :            :       /* Similar to the direct variable sized case above, we'll need the
    7024                 :            :          size of references being privatized.  */
    7025                 :       6895 :       if ((flags & GOVD_SHARED) == 0)
    7026                 :            :         {
    7027                 :       4577 :           t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
    7028                 :       4577 :           if (DECL_P (t))
    7029                 :       1183 :             omp_notice_variable (ctx, t, true);
    7030                 :            :         }
    7031                 :            :     }
    7032                 :            : 
    7033                 :     507873 :   if (n != NULL)
    7034                 :       1253 :     n->value |= flags;
    7035                 :            :   else
    7036                 :     506620 :     splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
    7037                 :            : 
    7038                 :            :   /* For reductions clauses in OpenACC loop directives, by default create a
    7039                 :            :      copy clause on the enclosing parallel construct for carrying back the
    7040                 :            :      results.  */
    7041                 :     507873 :   if (ctx->region_type == ORT_ACC && (flags & GOVD_REDUCTION))
    7042                 :            :     {
    7043                 :       3580 :       struct gimplify_omp_ctx *outer_ctx = ctx->outer_context;
    7044                 :       4442 :       while (outer_ctx)
    7045                 :            :         {
    7046                 :       4137 :           n = splay_tree_lookup (outer_ctx->variables, (splay_tree_key)decl);
    7047                 :       4137 :           if (n != NULL)
    7048                 :            :             {
    7049                 :            :               /* Ignore local variables and explicitly declared clauses.  */
    7050                 :       2969 :               if (n->value & (GOVD_LOCAL | GOVD_EXPLICIT))
    7051                 :            :                 break;
    7052                 :        222 :               else if (outer_ctx->region_type == ORT_ACC_KERNELS)
    7053                 :            :                 {
    7054                 :            :                   /* According to the OpenACC spec, such a reduction variable
    7055                 :            :                      should already have a copy map on a kernels construct,
    7056                 :            :                      verify that here.  */
    7057                 :         42 :                   gcc_assert (!(n->value & GOVD_FIRSTPRIVATE)
    7058                 :            :                               && (n->value & GOVD_MAP));
    7059                 :            :                 }
    7060                 :        180 :               else if (outer_ctx->region_type == ORT_ACC_PARALLEL)
    7061                 :            :                 {
    7062                 :            :                   /* Remove firstprivate and make it a copy map.  */
    7063                 :        180 :                   n->value &= ~GOVD_FIRSTPRIVATE;
    7064                 :        180 :                   n->value |= GOVD_MAP;
    7065                 :            :                 }
    7066                 :            :             }
    7067                 :       1168 :           else if (outer_ctx->region_type == ORT_ACC_PARALLEL)
    7068                 :            :             {
    7069                 :        528 :               splay_tree_insert (outer_ctx->variables, (splay_tree_key)decl,
    7070                 :            :                                  GOVD_MAP | GOVD_SEEN);
    7071                 :        528 :               break;
    7072                 :            :             }
    7073                 :        862 :           outer_ctx = outer_ctx->outer_context;
    7074                 :            :         }
    7075                 :            :     }
    7076                 :            : }
    7077                 :            : 
    7078                 :            : /* Notice a threadprivate variable DECL used in OMP context CTX.
    7079                 :            :    This just prints out diagnostics about threadprivate variable uses
    7080                 :            :    in untied tasks.  If DECL2 is non-NULL, prevent this warning
    7081                 :            :    on that variable.  */
    7082                 :            : 
    7083                 :            : static bool
    7084                 :      12522 : omp_notice_threadprivate_variable (struct gimplify_omp_ctx *ctx, tree decl,
    7085                 :            :                                    tree decl2)
    7086                 :            : {
    7087                 :      12522 :   splay_tree_node n;
    7088                 :      12522 :   struct gimplify_omp_ctx *octx;
    7089                 :            : 
    7090                 :      25145 :   for (octx = ctx; octx; octx = octx->outer_context)
    7091                 :      12623 :     if ((octx->region_type & ORT_TARGET) != 0
    7092                 :      12623 :         || octx->order_concurrent)
    7093                 :            :       {
    7094                 :        100 :         n = splay_tree_lookup (octx->variables, (splay_tree_key)decl);
    7095                 :        100 :         if (n == NULL)
    7096                 :            :           {
    7097                 :         20 :             if (octx->order_concurrent)
    7098                 :            :               {
    7099                 :         20 :                 error ("threadprivate variable %qE used in a region with"
    7100                 :         20 :                        " %<order(concurrent)%> clause", DECL_NAME (decl));
    7101                 :         20 :                 error_at (octx->location, "enclosing region");
    7102                 :            :               }
    7103                 :            :             else
    7104                 :            :               {
    7105                 :          0 :                 error ("threadprivate variable %qE used in target region",
    7106                 :          0 :                        DECL_NAME (decl));
    7107                 :          0 :                 error_at (octx->location, "enclosing target region");
    7108                 :            :               }
    7109                 :         20 :             splay_tree_insert (octx->variables, (splay_tree_key)decl, 0);
    7110                 :            :           }
    7111                 :        100 :         if (decl2)
    7112                 :          0 :           splay_tree_insert (octx->variables, (splay_tree_key)decl2, 0);
    7113                 :            :       }
    7114                 :            : 
    7115                 :      12522 :   if (ctx->region_type != ORT_UNTIED_TASK)
    7116                 :            :     return false;
    7117                 :         37 :   n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
    7118                 :         37 :   if (n == NULL)
    7119                 :            :     {
    7120                 :          6 :       error ("threadprivate variable %qE used in untied task",
    7121                 :          6 :              DECL_NAME (decl));
    7122                 :          6 :       error_at (ctx->location, "enclosing task");
    7123                 :          6 :       splay_tree_insert (ctx->variables, (splay_tree_key)decl, 0);
    7124                 :            :     }
    7125                 :         37 :   if (decl2)
    7126                 :          4 :     splay_tree_insert (ctx->variables, (splay_tree_key)decl2, 0);
    7127                 :            :   return false;
    7128                 :            : }
    7129                 :            : 
    7130                 :            : /* Return true if global var DECL is device resident.  */
    7131                 :            : 
    7132                 :            : static bool
    7133                 :        463 : device_resident_p (tree decl)
    7134                 :            : {
    7135                 :        463 :   tree attr = lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (decl));
    7136                 :            : 
    7137                 :        463 :   if (!attr)
    7138                 :            :     return false;
    7139                 :            : 
    7140                 :          0 :   for (tree t = TREE_VALUE (attr); t; t = TREE_PURPOSE (t))
    7141                 :            :     {
    7142                 :          0 :       tree c = TREE_VALUE (t);
    7143                 :          0 :       if (OMP_CLAUSE_MAP_KIND (c) == GOMP_MAP_DEVICE_RESIDENT)
    7144                 :            :         return true;
    7145                 :            :     }
    7146                 :            : 
    7147                 :            :   return false;
    7148                 :            : }
    7149                 :            : 
    7150                 :            : /* Return true if DECL has an ACC DECLARE attribute.  */
    7151                 :            : 
    7152                 :            : static bool
    7153                 :       7195 : is_oacc_declared (tree decl)
    7154                 :            : {
    7155                 :       7195 :   tree t = TREE_CODE (decl) == MEM_REF ? TREE_OPERAND (decl, 0) : decl;
    7156                 :       7195 :   tree declared = lookup_attribute ("oacc declare target", DECL_ATTRIBUTES (t));
    7157                 :       7195 :   return declared != NULL_TREE;
    7158                 :            : }
    7159                 :            : 
    7160                 :            : /* Determine outer default flags for DECL mentioned in an OMP region
    7161                 :            :    but not declared in an enclosing clause.
    7162                 :            : 
    7163                 :            :    ??? Some compiler-generated variables (like SAVE_EXPRs) could be
    7164                 :            :    remapped firstprivate instead of shared.  To some extent this is
    7165                 :            :    addressed in omp_firstprivatize_type_sizes, but not
    7166                 :            :    effectively.  */
    7167                 :            : 
    7168                 :            : static unsigned
    7169                 :      35610 : omp_default_clause (struct gimplify_omp_ctx *ctx, tree decl,
    7170                 :            :                     bool in_code, unsigned flags)
    7171                 :            : {
    7172                 :      35610 :   enum omp_clause_default_kind default_kind = ctx->default_kind;
    7173                 :      35610 :   enum omp_clause_default_kind kind;
    7174                 :            : 
    7175                 :      35610 :   kind = lang_hooks.decls.omp_predetermined_sharing (decl);
    7176                 :      35610 :   if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
    7177                 :            :     default_kind = kind;
    7178                 :      45628 :   else if (VAR_P (decl) && TREE_STATIC (decl) && DECL_IN_CONSTANT_POOL (decl))
    7179                 :            :     default_kind = OMP_CLAUSE_DEFAULT_SHARED;
    7180                 :            : 
    7181                 :      35609 :   switch (default_kind)
    7182                 :            :     {
    7183                 :        115 :     case OMP_CLAUSE_DEFAULT_NONE:
    7184                 :        115 :       {
    7185                 :        115 :         const char *rtype;
    7186                 :            : 
    7187                 :        115 :         if (ctx->region_type & ORT_PARALLEL)
    7188                 :            :           rtype = "parallel";
    7189                 :         15 :         else if ((ctx->region_type & ORT_TASKLOOP) == ORT_TASKLOOP)
    7190                 :            :           rtype = "taskloop";
    7191                 :         10 :         else if (ctx->region_type & ORT_TASK)
    7192                 :            :           rtype = "task";
    7193                 :          5 :         else if (ctx->region_type & ORT_TEAMS)
    7194                 :            :           rtype = "teams";
    7195                 :            :         else
    7196                 :          0 :           gcc_unreachable ();
    7197                 :            :         
    7198                 :        230 :         error ("%qE not specified in enclosing %qs",
    7199                 :        115 :                DECL_NAME (lang_hooks.decls.omp_report_decl (decl)), rtype);
    7200                 :        115 :         error_at (ctx->location, "enclosing %qs", rtype);
    7201                 :            :       }
    7202                 :            :       /* FALLTHRU */
    7203                 :      34011 :     case OMP_CLAUSE_DEFAULT_SHARED:
    7204                 :      34011 :       flags |= GOVD_SHARED;
    7205                 :      34011 :       break;
    7206                 :         96 :     case OMP_CLAUSE_DEFAULT_PRIVATE:
    7207                 :         96 :       flags |= GOVD_PRIVATE;
    7208                 :         96 :       break;
    7209                 :        154 :     case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
    7210                 :        154 :       flags |= GOVD_FIRSTPRIVATE;
    7211                 :        154 :       break;
    7212                 :       1349 :     case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
    7213                 :            :       /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED.  */
    7214                 :       1349 :       gcc_assert ((ctx->region_type & ORT_TASK) != 0);
    7215                 :       1349 :       if (struct gimplify_omp_ctx *octx = ctx->outer_context)
    7216                 :            :         {
    7217                 :        683 :           omp_notice_variable (octx, decl, in_code);
    7218                 :       1193 :           for (; octx; octx = octx->outer_context)
    7219                 :            :             {
    7220                 :       1174 :               splay_tree_node n2;
    7221                 :            : 
    7222                 :       1174 :               n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
    7223                 :       1174 :               if ((octx->region_type & (ORT_TARGET_DATA | ORT_TARGET)) != 0
    7224                 :          0 :                   && (n2 == NULL || (n2->value & GOVD_DATA_SHARE_CLASS) == 0))
    7225                 :          0 :                 continue;
    7226                 :       1174 :               if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
    7227                 :            :                 {
    7228                 :        226 :                   flags |= GOVD_FIRSTPRIVATE;
    7229                 :        226 :                   goto found_outer;
    7230                 :            :                 }
    7231                 :        948 :               if ((octx->region_type & (ORT_PARALLEL | ORT_TEAMS)) != 0)
    7232                 :            :                 {
    7233                 :        438 :                   flags |= GOVD_SHARED;
    7234                 :        438 :                   goto found_outer;
    7235                 :            :                 }
    7236                 :            :             }
    7237                 :            :         }
    7238                 :            :       
    7239                 :        685 :       if (TREE_CODE (decl) == PARM_DECL
    7240                 :        685 :           || (!is_global_var (decl)
    7241                 :        157 :               && DECL_CONTEXT (decl) == current_function_decl))
    7242                 :        391 :         flags |= GOVD_FIRSTPRIVATE;
    7243                 :            :       else
    7244                 :        294 :         flags |= GOVD_SHARED;
    7245                 :      35610 :     found_outer:
    7246                 :            :       break;
    7247                 :            : 
    7248                 :          0 :     default:
    7249                 :          0 :       gcc_unreachable ();
    7250                 :            :     }
    7251                 :            : 
    7252                 :      35610 :   return flags;
    7253                 :            : }
    7254                 :            : 
    7255                 :            : 
    7256                 :            : /* Determine outer default flags for DECL mentioned in an OACC region
    7257                 :            :    but not declared in an enclosing clause.  */
    7258                 :            : 
    7259                 :            : static unsigned
    7260                 :       6852 : oacc_default_clause (struct gimplify_omp_ctx *ctx, tree decl, unsigned flags)
    7261                 :            : {
    7262                 :       6852 :   const char *rkind;
    7263                 :       6852 :   bool on_device = false;
    7264                 :       6852 :   bool is_private = false;
    7265                 :       6852 :   bool declared = is_oacc_declared (decl);
    7266                 :       6852 :   tree type = TREE_TYPE (decl);
    7267                 :            : 
    7268                 :       6852 :   if (lang_hooks.decls.omp_privatize_by_reference (decl))
    7269                 :        297 :     type = TREE_TYPE (type);
    7270                 :            : 
    7271                 :            :   /* For Fortran COMMON blocks, only used variables in those blocks are
    7272                 :            :      transfered and remapped.  The block itself will have a private clause to
    7273                 :            :      avoid transfering the data twice.
    7274                 :            :      The hook evaluates to false by default.  For a variable in Fortran's COMMON
    7275                 :            :      or EQUIVALENCE block, returns 'true' (as we have shared=false) - as only
    7276                 :            :      the variables in such a COMMON/EQUIVALENCE block shall be privatized not
    7277                 :            :      the whole block.  For C++ and Fortran, it can also be true under certain
    7278                 :            :      other conditions, if DECL_HAS_VALUE_EXPR.  */
    7279                 :       6852 :   if (RECORD_OR_UNION_TYPE_P (type))
    7280                 :        791 :     is_private = lang_hooks.decls.omp_disregard_value_expr (decl, false);
    7281                 :            : 
    7282                 :       6852 :   if ((ctx->region_type & (ORT_ACC_PARALLEL | ORT_ACC_KERNELS)) != 0
    7283                 :       6852 :       && is_global_var (decl)
    7284                 :        463 :       && device_resident_p (decl)
    7285                 :       6852 :       && !is_private)
    7286                 :            :     {
    7287                 :          0 :       on_device = true;
    7288                 :          0 :       flags |= GOVD_MAP_TO_ONLY;
    7289                 :            :     }
    7290                 :            : 
    7291                 :       6852 :   switch (ctx->region_type)
    7292                 :            :     {
    7293                 :        965 :     case ORT_ACC_KERNELS:
    7294                 :        965 :       rkind = "kernels";
    7295                 :            : 
    7296                 :        965 :       if (is_private)
    7297                 :          0 :         flags |= GOVD_FIRSTPRIVATE;
    7298                 :        965 :       else if (AGGREGATE_TYPE_P (type))
    7299                 :            :         {
    7300                 :            :           /* Aggregates default to 'present_or_copy', or 'present'.  */
    7301                 :        229 :           if (ctx->default_kind != OMP_CLAUSE_DEFAULT_PRESENT)
    7302                 :        215 :             flags |= GOVD_MAP;
    7303                 :            :           else
    7304                 :         14 :             flags |= GOVD_MAP | GOVD_MAP_FORCE_PRESENT;
    7305                 :            :         }
    7306                 :            :       else
    7307                 :            :         /* Scalars default to 'copy'.  */
    7308                 :        736 :         flags |= GOVD_MAP | GOVD_MAP_FORCE;
    7309                 :            : 
    7310                 :            :       break;
    7311                 :            : 
    7312                 :       5887 :     case ORT_ACC_PARALLEL:
    7313                 :       5887 :     case ORT_ACC_SERIAL:
    7314                 :       5887 :       rkind = ctx->region_type == ORT_ACC_PARALLEL ? "parallel" : "serial";
    7315                 :            : 
    7316                 :       5887 :       if (is_private)
    7317                 :          0 :         flags |= GOVD_FIRSTPRIVATE;
    7318                 :       5887 :       else if (on_device || declared)
    7319                 :          6 :         flags |= GOVD_MAP;
    7320                 :       5881 :       else if (AGGREGATE_TYPE_P (type))
    7321                 :            :         {
    7322                 :            :           /* Aggregates default to 'present_or_copy', or 'present'.  */
    7323                 :       3001 :           if (ctx->default_kind != OMP_CLAUSE_DEFAULT_PRESENT)
    7324                 :       2752 :             flags |= GOVD_MAP;
    7325                 :            :           else
    7326                 :        249 :             flags |= GOVD_MAP | GOVD_MAP_FORCE_PRESENT;
    7327                 :            :         }
    7328                 :            :       else
    7329                 :            :         /* Scalars default to 'firstprivate'.  */
    7330                 :       2880 :         flags |= GOVD_FIRSTPRIVATE;
    7331                 :            : 
    7332                 :            :       break;
    7333                 :            : 
    7334                 :          0 :     default:
    7335                 :          0 :       gcc_unreachable ();
    7336                 :            :     }
    7337                 :            : 
    7338                 :       6852 :   if (DECL_ARTIFICIAL (decl))
    7339                 :            :     ; /* We can get compiler-generated decls, and should not complain
    7340                 :            :          about them.  */
    7341                 :       6702 :   else if (ctx->default_kind == OMP_CLAUSE_DEFAULT_NONE)
    7342                 :            :     {
    7343                 :         48 :       error ("%qE not specified in enclosing OpenACC %qs construct",
    7344                 :         24 :              DECL_NAME (lang_hooks.decls.omp_report_decl (decl)), rkind);
    7345                 :         24 :       inform (ctx->location, "enclosing OpenACC %qs construct", rkind);
    7346                 :            :     }
    7347                 :       6678 :   else if (ctx->default_kind == OMP_CLAUSE_DEFAULT_PRESENT)
    7348                 :            :     ; /* Handled above.  */
    7349                 :            :   else
    7350                 :       6181 :     gcc_checking_assert (ctx->default_kind == OMP_CLAUSE_DEFAULT_SHARED);
    7351                 :            : 
    7352                 :       6852 :   return flags;
    7353                 :            : }
    7354                 :            : 
    7355                 :            : /* Record the fact that DECL was used within the OMP context CTX.
    7356                 :            :    IN_CODE is true when real code uses DECL, and false when we should
    7357                 :            :    merely emit default(none) errors.  Return true if DECL is going to
    7358                 :            :    be remapped and thus DECL shouldn't be gimplified into its
    7359                 :            :    DECL_VALUE_EXPR (if any).  */
    7360                 :            : 
    7361                 :            : static bool
    7362                 :    2893500 : omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
    7363                 :            : {
    7364                 :    2893500 :   splay_tree_node n;
    7365                 :    2893500 :   unsigned flags = in_code ? GOVD_SEEN : 0;
    7366                 :    2893500 :   bool ret = false, shared;
    7367                 :            : 
    7368                 :    5787010 :   if (error_operand_p (decl))
    7369                 :            :     return false;
    7370                 :            : 
    7371                 :    2893500 :   if (ctx->region_type == ORT_NONE)
    7372                 :        149 :     return lang_hooks.decls.omp_disregard_value_expr (decl, false);
    7373                 :            : 
    7374                 :    2893350 :   if (is_global_var (decl))
    7375                 :            :     {
    7376                 :            :       /* Threadprivate variables are predetermined.  */
    7377                 :     389197 :       if (DECL_THREAD_LOCAL_P (decl))
    7378                 :      11910 :         return omp_notice_threadprivate_variable (ctx, decl, NULL_TREE);
    7379                 :            : 
    7380                 :     374677 :       if (DECL_HAS_VALUE_EXPR_P (decl))
    7381                 :            :         {
    7382                 :       4347 :           if (ctx->region_type & ORT_ACC)
    7383                 :            :             /* For OpenACC, defer expansion of value to avoid transfering
    7384                 :            :                privatized common block data instead of im-/explicitly transfered
    7385                 :            :                variables which are in common blocks.  */
    7386                 :            :             ;
    7387                 :            :           else
    7388                 :            :             {
    7389                 :       2095 :               tree value = get_base_address (DECL_VALUE_EXPR (decl));
    7390                 :            : 
    7391                 :       2095 :               if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
    7392                 :        612 :                 return omp_notice_threadprivate_variable (ctx, decl, value);
    7393                 :            :             }
    7394                 :            :         }
    7395                 :            : 
    7396                 :     374065 :       if (gimplify_omp_ctxp->outer_context == NULL
    7397                 :      44127 :           && VAR_P (decl)
    7398                 :     418192 :           && oacc_get_fn_attrib (current_function_decl))
    7399                 :            :         {
    7400                 :        296 :           location_t loc = DECL_SOURCE_LOCATION (decl);
    7401                 :            : 
    7402                 :        592 :           if (lookup_attribute ("omp declare target link",
    7403                 :        296 :                                 DECL_ATTRIBUTES (decl)))
    7404                 :            :             {
    7405                 :         30 :               error_at (loc,
    7406                 :            :                         "%qE with %<link%> clause used in %<routine%> function",
    7407                 :         30 :                         DECL_NAME (decl));
    7408                 :         30 :               return false;
    7409                 :            :             }
    7410                 :        532 :           else if (!lookup_attribute ("omp declare target",
    7411                 :        266 :                                       DECL_ATTRIBUTES (decl)))
    7412                 :            :             {
    7413                 :         80 :               error_at (loc,
    7414                 :            :                         "%qE requires a %<declare%> directive for use "
    7415                 :         80 :                         "in a %<routine%> function", DECL_NAME (decl));
    7416                 :         80 :               return false;
    7417                 :            :             }
    7418                 :            :         }
    7419                 :            :     }
    7420                 :            : 
    7421                 :    2880720 :   n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
    7422                 :    2880720 :   if ((ctx->region_type & ORT_TARGET) != 0)
    7423                 :            :     {
    7424                 :     422812 :       if (ctx->region_type & ORT_ACC)
    7425                 :            :         /* For OpenACC, as remarked above, defer expansion.  */
    7426                 :            :         shared = false;
    7427                 :            :       else
    7428                 :     173119 :         shared = true;
    7429                 :            : 
    7430                 :     422812 :       ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
    7431                 :     422812 :       if (n == NULL)
    7432                 :            :         {
    7433                 :      28043 :           unsigned nflags = flags;
    7434                 :      28043 :           if ((ctx->region_type & ORT_ACC) == 0)
    7435                 :            :             {
    7436                 :      19459 :               bool is_declare_target = false;
    7437                 :      19459 :               if (is_global_var (decl)
    7438                 :      19459 :                   && varpool_node::get_create (decl)->offloadable)
    7439                 :            :                 {
    7440                 :       6133 :                   struct gimplify_omp_ctx *octx;
    7441                 :       6133 :                   for (octx = ctx->outer_context;
    7442                 :       6133 :                        octx; octx = octx->outer_context)
    7443                 :            :                     {
    7444                 :          1 :                       n = splay_tree_lookup (octx->variables,
    7445                 :            :                                              (splay_tree_key)decl);
    7446                 :          1 :                       if (n
    7447                 :          1 :                           && (n->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED
    7448                 :          1 :                           && (n->value & GOVD_DATA_SHARE_CLASS) != 0)
    7449                 :            :                         break;
    7450                 :            :                     }
    7451                 :       6133 :                   is_declare_target = octx == NULL;
    7452                 :            :                 }
    7453                 :       6133 :               if (!is_declare_target)
    7454                 :            :                 {
    7455                 :      13327 :                   int gdmk;
    7456                 :      13327 :                   if (TREE_CODE (TREE_TYPE (decl)) == POINTER_TYPE
    7457                 :      13327 :                       || (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
    7458                 :        624 :                           && (TREE_CODE (TREE_TYPE (TREE_TYPE (decl)))
    7459                 :            :                               == POINTER_TYPE)))
    7460                 :            :                     gdmk = GDMK_POINTER;
    7461                 :      12487 :                   else if (lang_hooks.decls.omp_scalar_p (decl))
    7462                 :            :                     gdmk = GDMK_SCALAR;
    7463                 :            :                   else
    7464                 :        418 :                     gdmk = GDMK_AGGREGATE;
    7465                 :      13327 :                   if (ctx->defaultmap[gdmk] == 0)
    7466                 :            :                     {
    7467                 :         20 :                       tree d = lang_hooks.decls.omp_report_decl (decl);
    7468                 :         20 :                       error ("%qE not specified in enclosing %<target%>",
    7469                 :         20 :                              DECL_NAME (d));
    7470                 :         20 :                       error_at (ctx->location, "enclosing %<target%>");
    7471                 :            :                     }
    7472                 :      13307 :                   else if (ctx->defaultmap[gdmk]
    7473                 :      13307 :                            & (GOVD_MAP_0LEN_ARRAY | GOVD_FIRSTPRIVATE))
    7474                 :       9654 :                     nflags |= ctx->defaultmap[gdmk];
    7475                 :            :                   else
    7476                 :            :                     {
    7477                 :       3653 :                       gcc_assert (ctx->defaultmap[gdmk] & GOVD_MAP);
    7478                 :       3653 :                       nflags |= ctx->defaultmap[gdmk] & ~GOVD_MAP;
    7479                 :            :                     }
    7480                 :            :                 }
    7481                 :            :             }
    7482                 :            : 
    7483                 :      28043 :           struct gimplify_omp_ctx *octx = ctx->outer_context;
    7484                 :      28043 :           if ((ctx->region_type & ORT_ACC) && octx)
    7485                 :            :             {
    7486                 :            :               /* Look in outer OpenACC contexts, to see if there's a
    7487                 :            :                  data attribute for this variable.  */
    7488                 :       2532 :               omp_notice_variable (octx, decl, in_code);
    7489                 :            : 
    7490                 :       3382 :               for (; octx; octx = octx->outer_context)
    7491                 :            :                 {
    7492                 :       2582 :                   if (!(octx->region_type & (ORT_TARGET_DATA | ORT_TARGET)))
    7493                 :            :                     break;
    7494                 :       2582 :                   splay_tree_node n2
    7495                 :       2582 :                     = splay_tree_lookup (octx->variables,
    7496                 :            :                                          (splay_tree_key) decl);
    7497                 :       2582 :                   if (n2)
    7498                 :            :                     {
    7499                 :       1732 :                       if (octx->region_type == ORT_ACC_HOST_DATA)
    7500                 :          5 :                         error ("variable %qE declared in enclosing "
    7501                 :          5 :                                "%<host_data%> region", DECL_NAME (decl));
    7502                 :       1732 :                       nflags |= GOVD_MAP;
    7503                 :       1732 :                       if (octx->region_type == ORT_ACC_DATA
    7504                 :       1727 :                           && (n2->value & GOVD_MAP_0LEN_ARRAY))
    7505                 :        274 :                         nflags |= GOVD_MAP_0LEN_ARRAY;
    7506                 :       1732 :                       goto found_outer;
    7507                 :            :                     }
    7508                 :            :                 }
    7509                 :            :             }
    7510                 :            : 
    7511                 :      26311 :           if ((nflags & ~(GOVD_MAP_TO_ONLY | GOVD_MAP_FROM_ONLY
    7512                 :            :                           | GOVD_MAP_ALLOC_ONLY)) == flags)
    7513                 :            :             {
    7514                 :      16657 :               tree type = TREE_TYPE (decl);
    7515                 :            : 
    7516                 :      16657 :               if (gimplify_omp_ctxp->target_firstprivatize_array_bases
    7517                 :      16657 :                   && lang_hooks.decls.omp_privatize_by_reference (decl))
    7518                 :         20 :                 type = TREE_TYPE (type);
    7519                 :      16657 :               if (!lang_hooks.types.omp_mappable_type (type))
    7520                 :            :                 {
    7521                 :          5 :                   error ("%qD referenced in target region does not have "
    7522                 :            :                          "a mappable type", decl);
    7523                 :          5 :                   nflags |= GOVD_MAP | GOVD_EXPLICIT;
    7524                 :            :                 }
    7525                 :            :               else
    7526                 :            :                 {
    7527                 :      16652 :                   if ((ctx->region_type & ORT_ACC) != 0)
    7528                 :       6852 :                     nflags = oacc_default_clause (ctx, decl, flags);
    7529                 :            :                   else
    7530                 :       9800 :                     nflags |= GOVD_MAP;
    7531                 :            :                 }
    7532                 :            :             }
    7533                 :       9654 :         found_outer:
    7534                 :      28043 :           omp_add_variable (ctx, decl, nflags);
    7535                 :            :         }
    7536                 :            :       else
    7537                 :            :         {
    7538                 :            :           /* If nothing changed, there's nothing left to do.  */
    7539                 :     394769 :           if ((n->value & flags) == flags)
    7540                 :            :             return ret;
    7541                 :      10442 :           flags |= n->value;
    7542                 :      10442 :           n->value = flags;
    7543                 :            :         }
    7544                 :      38485 :       goto do_outer;
    7545                 :            :     }
    7546                 :            : 
    7547                 :    2457910 :   if (n == NULL)
    7548                 :            :     {
    7549                 :     913747 :       if (ctx->region_type == ORT_WORKSHARE
    7550                 :            :           || ctx->region_type == ORT_TASKGROUP
    7551                 :     422096 :           || ctx->region_type == ORT_SIMD
    7552                 :     250024 :           || ctx->region_type == ORT_ACC
    7553                 :      72815 :           || (ctx->region_type & ORT_TARGET_DATA) != 0)
    7554                 :     878137 :         goto do_outer;
    7555                 :            : 
    7556                 :      35610 :       flags = omp_default_clause (ctx, decl, in_code, flags);
    7557                 :            : 
    7558                 :      35610 :       if ((flags & GOVD_PRIVATE)
    7559                 :      35610 :           && lang_hooks.decls.omp_private_outer_ref (decl))
    7560                 :          6 :         flags |= GOVD_PRIVATE_OUTER_REF;
    7561                 :            : 
    7562                 :      35610 :       omp_add_variable (ctx, decl, flags);
    7563                 :            : 
    7564                 :      35610 :       shared = (flags & GOVD_SHARED) != 0;
    7565                 :      35610 :       ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
    7566                 :      35610 :       goto do_outer;
    7567                 :            :     }
    7568                 :            : 
    7569                 :    1544160 :   if ((n->value & (GOVD_SEEN | GOVD_LOCAL)) == 0
    7570                 :      25622 :       && (flags & (GOVD_SEEN | GOVD_LOCAL)) == GOVD_SEEN
    7571                 :    1569780 :       && DECL_SIZE (decl))
    7572                 :            :     {
    7573                 :      25621 :       if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
    7574                 :            :         {
    7575                 :        125 :           splay_tree_node n2;
    7576                 :        125 :           tree t = DECL_VALUE_EXPR (decl);
    7577                 :        125 :           gcc_assert (TREE_CODE (t) == INDIRECT_REF);
    7578                 :        125 :           t = TREE_OPERAND (t, 0);
    7579                 :        125 :           gcc_assert (DECL_P (t));
    7580                 :        125 :           n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
    7581                 :        125 :           n2->value |= GOVD_SEEN;
    7582                 :            :         }
    7583                 :      25496 :       else if (lang_hooks.decls.omp_privatize_by_reference (decl)
    7584                 :       3403 :                && TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)))
    7585                 :      28867 :                && (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl))))
    7586                 :            :                    != INTEGER_CST))
    7587                 :            :         {
    7588                 :       1207 :           splay_tree_node n2;
    7589                 :       1207 :           tree t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
    7590                 :       1207 :           gcc_assert (DECL_P (t));
    7591                 :       1207 :           n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
    7592                 :       1207 :           if (n2)
    7593                 :        570 :             omp_notice_variable (ctx, t, true);
    7594                 :            :         }
    7595                 :            :     }
    7596                 :            : 
    7597                 :    1544160 :   if (ctx->region_type & ORT_ACC)
    7598                 :            :     /* For OpenACC, as remarked above, defer expansion.  */
    7599                 :            :     shared = false;
    7600                 :            :   else
    7601                 :    1434730 :     shared = ((flags | n->value) & GOVD_SHARED) != 0;
    7602                 :    1544160 :   ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
    7603                 :            : 
    7604                 :            :   /* If nothing changed, there's nothing left to do.  */
    7605                 :    1544160 :   if ((n->value & flags) == flags)
    7606                 :            :     return ret;
    7607                 :      25622 :   flags |= n->value;
    7608                 :      25622 :   n->value = flags;
    7609                 :            : 
    7610                 :     977854 :  do_outer:
    7611                 :            :   /* If the variable is private in the current context, then we don't
    7612                 :            :      need to propagate anything to an outer context.  */
    7613                 :     977854 :   if ((flags & GOVD_PRIVATE) && !(flags & GOVD_PRIVATE_OUTER_REF))
    7614                 :            :     return ret;
    7615                 :     968308 :   if ((flags & (GOVD_LINEAR | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
    7616                 :            :       == (GOVD_LINEAR | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
    7617                 :            :     return ret;
    7618                 :     968181 :   if ((flags & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
    7619                 :            :                 | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
    7620                 :            :       == (GOVD_LASTPRIVATE | GOVD_LINEAR_LASTPRIVATE_NO_OUTER))
    7621                 :            :     return ret;
    7622                 :     968181 :   if (ctx->outer_context
    7623                 :     968181 :       && omp_notice_variable (ctx->outer_context, decl, in_code))
    7624                 :       2132 :     return true;
    7625                 :            :   return ret;
    7626                 :            : }
    7627                 :            : 
    7628                 :            : /* Verify that DECL is private within CTX.  If there's specific information
    7629                 :            :    to the contrary in the innermost scope, generate an error.  */
    7630                 :            : 
    7631                 :            : static bool
    7632                 :      39209 : omp_is_private (struct gimplify_omp_ctx *ctx, tree decl, int simd)
    7633                 :            : {
    7634                 :      74912 :   splay_tree_node n;
    7635                 :            : 
    7636                 :      74912 :   n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
    7637                 :      74912 :   if (n != NULL)
    7638                 :            :     {
    7639                 :      13918 :       if (n->value & GOVD_SHARED)
    7640                 :            :         {
    7641                 :        161 :           if (ctx == gimplify_omp_ctxp)
    7642                 :            :             {
    7643                 :          0 :               if (simd)
    7644                 :          0 :                 error ("iteration variable %qE is predetermined linear",
    7645                 :          0 :                        DECL_NAME (decl));
    7646                 :            :               else
    7647                 :          0 :                 error ("iteration variable %qE should be private",
    7648                 :          0 :                        DECL_NAME (decl));
    7649                 :          0 :               n->value = GOVD_PRIVATE;
    7650                 :          0 :               return true;
    7651                 :            :             }
    7652                 :            :           else
    7653                 :            :             return false;
    7654                 :            :         }
    7655                 :      13757 :       else if ((n->value & GOVD_EXPLICIT) != 0
    7656                 :       8079 :                && (ctx == gimplify_omp_ctxp
    7657                 :         98 :                    || (ctx->region_type == ORT_COMBINED_PARALLEL
    7658                 :         68 :                        && gimplify_omp_ctxp->outer_context == ctx)))
    7659                 :            :         {
    7660                 :       8049 :           if ((n->value & GOVD_FIRSTPRIVATE) != 0)
    7661                 :          5 :             error ("iteration variable %qE should not be firstprivate",
    7662                 :          5 :                    DECL_NAME (decl));
    7663                 :       8044 :           else if ((n->value & GOVD_REDUCTION) != 0)
    7664                 :         10 :             error ("iteration variable %qE should not be reduction",
    7665                 :         10 :                    DECL_NAME (decl));
    7666                 :       8034 :           else if (simd != 1 && (n->value & GOVD_LINEAR) != 0)
    7667                 :         74 :             error ("iteration variable %qE should not be linear",
    7668                 :         74 :                    DECL_NAME (decl));
    7669                 :            :         }
    7670                 :      13757 :       return (ctx == gimplify_omp_ctxp
    7671                 :      13757 :               || (ctx->region_type == ORT_COMBINED_PARALLEL
    7672                 :      14219 :                   && gimplify_omp_ctxp->outer_context == ctx));
    7673                 :            :     }
    7674                 :            : 
    7675                 :      60994 :   if (ctx->region_type != ORT_WORKSHARE
    7676                 :            :       && ctx->region_type != ORT_TASKGROUP
    7677                 :      60994 :       && ctx->region_type != ORT_SIMD
    7678                 :      28056 :       && ctx->region_type != ORT_ACC)
    7679                 :            :     return false;
    7680                 :      41626 :   else if (ctx->outer_context)
    7681                 :            :     return omp_is_private (ctx->outer_context, decl, simd);
    7682                 :            :   return false;
    7683                 :            : }
    7684                 :            : 
    7685                 :            : /* Return true if DECL is private within a parallel region
    7686                 :            :    that binds to the current construct's context or in parallel
    7687                 :            :    region's REDUCTION clause.  */
    7688                 :            : 
    7689                 :            : static bool
    7690                 :       9035 : omp_check_private (struct gimplify_omp_ctx *ctx, tree decl, bool copyprivate)
    7691                 :            : {
    7692                 :       9050 :   splay_tree_node n;
    7693                 :            : 
    7694                 :       9050 :   do
    7695                 :            :     {
    7696                 :       9050 :       ctx = ctx->outer_context;
    7697                 :       9050 :       if (ctx == NULL)
    7698                 :            :         {
    7699                 :       2045 :           if (is_global_var (decl))
    7700                 :            :             return false;
    7701                 :            : 
    7702                 :            :           /* References might be private, but might be shared too,
    7703                 :            :              when checking for copyprivate, assume they might be
    7704                 :            :              private, otherwise assume they might be shared.  */
    7705                 :       1098 :           if (copyprivate)
    7706                 :            :             return true;
    7707                 :            : 
    7708                 :       1046 :           if (lang_hooks.decls.omp_privatize_by_reference (decl))
    7709                 :            :             return false;
    7710                 :            : 
    7711                 :            :           /* Treat C++ privatized non-static data members outside
    7712                 :            :              of the privatization the same.  */
    7713                 :        996 :           if (omp_member_access_dummy_var (decl))
    7714                 :            :             return false;
    7715                 :            : 
    7716                 :        935 :           return true;
    7717                 :            :         }
    7718                 :            : 
    7719                 :       7005 :       n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
    7720                 :            : 
    7721                 :       7005 :       if ((ctx->region_type & (ORT_TARGET | ORT_TARGET_DATA)) != 0
    7722                 :       1226 :           && (n == NULL || (n->value & GOVD_DATA_SHARE_CLASS) == 0))
    7723                 :        181 :         continue;
    7724                 :            : 
    7725                 :       6824 :       if (n != NULL)
    7726                 :            :         {
    7727                 :       3567 :           if ((n->value & GOVD_LOCAL) != 0
    7728                 :       3567 :               && omp_member_access_dummy_var (decl))
    7729                 :            :             return false;
    7730                 :       3512 :           return (n->value & GOVD_SHARED) == 0;
    7731                 :            :         }
    7732                 :            :     }
    7733                 :            :   while (ctx->region_type == ORT_WORKSHARE
    7734                 :            :          || ctx->region_type == ORT_TASKGROUP
    7735                 :       3438 :          || ctx->region_type == ORT_SIMD
    7736                 :       3438 :          || ctx->region_type == ORT_ACC);
    7737                 :            :   return false;
    7738                 :            : }
    7739                 :            : 
    7740                 :            : /* Callback for walk_tree to find a DECL_EXPR for the given DECL.  */
    7741                 :            : 
    7742                 :            : static tree
    7743                 :       2740 : find_decl_expr (tree *tp, int *walk_subtrees, void *data)
    7744                 :            : {
    7745                 :       2740 :   tree t = *tp;
    7746                 :            : 
    7747                 :            :   /* If this node has been visited, unmark it and keep looking.  */
    7748                 :       2740 :   if (TREE_CODE (t) == DECL_EXPR && DECL_EXPR_DECL (t) == (tree) data)
    7749                 :            :     return t;
    7750                 :            : 
    7751                 :       2364 :   if (IS_TYPE_OR_DECL_P (t))
    7752                 :        428 :     *walk_subtrees = 0;
    7753                 :            :   return NULL_TREE;
    7754                 :            : }
    7755                 :            : 
    7756                 :            : /* If *LIST_P contains any OpenMP depend clauses with iterators,
    7757                 :            :    lower all the depend clauses by populating corresponding depend
    7758                 :            :    array.  Returns 0 if there are no such depend clauses, or
    7759                 :            :    2 if all depend clauses should be removed, 1 otherwise.  */
    7760                 :            : 
    7761                 :            : static int
    7762                 :       1234 : gimplify_omp_depend (tree *list_p, gimple_seq *pre_p)
    7763