LCOV - code coverage report
Current view: top level - gcc - tree-nested.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1631 1836 88.8 %
Date: 2020-04-04 11:58:09 Functions: 53 56 94.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Nested function decomposition for GIMPLE.
       2                 :            :    Copyright (C) 2004-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            :    This file is part of GCC.
       5                 :            : 
       6                 :            :    GCC is free software; you can redistribute it and/or modify
       7                 :            :    it under the terms of the GNU General Public License as published by
       8                 :            :    the Free Software Foundation; either version 3, or (at your option)
       9                 :            :    any later version.
      10                 :            : 
      11                 :            :    GCC is distributed in the hope that it will be useful,
      12                 :            :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            :    GNU General Public License for more details.
      15                 :            : 
      16                 :            :    You should have received a copy of the GNU General Public License
      17                 :            :    along with GCC; see the file COPYING3.  If not see
      18                 :            :    <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "target.h"
      25                 :            : #include "rtl.h"
      26                 :            : #include "tree.h"
      27                 :            : #include "gimple.h"
      28                 :            : #include "memmodel.h"
      29                 :            : #include "tm_p.h"
      30                 :            : #include "stringpool.h"
      31                 :            : #include "cgraph.h"
      32                 :            : #include "fold-const.h"
      33                 :            : #include "stor-layout.h"
      34                 :            : #include "dumpfile.h"
      35                 :            : #include "tree-inline.h"
      36                 :            : #include "gimplify.h"
      37                 :            : #include "gimple-iterator.h"
      38                 :            : #include "gimple-walk.h"
      39                 :            : #include "tree-cfg.h"
      40                 :            : #include "explow.h"
      41                 :            : #include "langhooks.h"
      42                 :            : #include "gimple-low.h"
      43                 :            : #include "gomp-constants.h"
      44                 :            : #include "diagnostic.h"
      45                 :            : 
      46                 :            : 
      47                 :            : /* The object of this pass is to lower the representation of a set of nested
      48                 :            :    functions in order to expose all of the gory details of the various
      49                 :            :    nonlocal references.  We want to do this sooner rather than later, in
      50                 :            :    order to give us more freedom in emitting all of the functions in question.
      51                 :            : 
      52                 :            :    Back in olden times, when gcc was young, we developed an insanely
      53                 :            :    complicated scheme whereby variables which were referenced nonlocally
      54                 :            :    were forced to live in the stack of the declaring function, and then
      55                 :            :    the nested functions magically discovered where these variables were
      56                 :            :    placed.  In order for this scheme to function properly, it required
      57                 :            :    that the outer function be partially expanded, then we switch to
      58                 :            :    compiling the inner function, and once done with those we switch back
      59                 :            :    to compiling the outer function.  Such delicate ordering requirements
      60                 :            :    makes it difficult to do whole translation unit optimizations
      61                 :            :    involving such functions.
      62                 :            : 
      63                 :            :    The implementation here is much more direct.  Everything that can be
      64                 :            :    referenced by an inner function is a member of an explicitly created
      65                 :            :    structure herein called the "nonlocal frame struct".  The incoming
      66                 :            :    static chain for a nested function is a pointer to this struct in
      67                 :            :    the parent.  In this way, we settle on known offsets from a known
      68                 :            :    base, and so are decoupled from the logic that places objects in the
      69                 :            :    function's stack frame.  More importantly, we don't have to wait for
      70                 :            :    that to happen -- since the compilation of the inner function is no
      71                 :            :    longer tied to a real stack frame, the nonlocal frame struct can be
      72                 :            :    allocated anywhere.  Which means that the outer function is now
      73                 :            :    inlinable.
      74                 :            : 
      75                 :            :    Theory of operation here is very simple.  Iterate over all the
      76                 :            :    statements in all the functions (depth first) several times,
      77                 :            :    allocating structures and fields on demand.  In general we want to
      78                 :            :    examine inner functions first, so that we can avoid making changes
      79                 :            :    to outer functions which are unnecessary.
      80                 :            : 
      81                 :            :    The order of the passes matters a bit, in that later passes will be
      82                 :            :    skipped if it is discovered that the functions don't actually interact
      83                 :            :    at all.  That is, they're nested in the lexical sense but could have
      84                 :            :    been written as independent functions without change.  */
      85                 :            : 
      86                 :            : 
      87                 :            : struct nesting_info
      88                 :            : {
      89                 :            :   struct nesting_info *outer;
      90                 :            :   struct nesting_info *inner;
      91                 :            :   struct nesting_info *next;
      92                 :            : 
      93                 :            :   hash_map<tree, tree> *field_map;
      94                 :            :   hash_map<tree, tree> *var_map;
      95                 :            :   hash_set<tree *> *mem_refs;
      96                 :            :   bitmap suppress_expansion;
      97                 :            : 
      98                 :            :   tree context;
      99                 :            :   tree new_local_var_chain;
     100                 :            :   tree debug_var_chain;
     101                 :            :   tree frame_type;
     102                 :            :   tree frame_decl;
     103                 :            :   tree chain_field;
     104                 :            :   tree chain_decl;
     105                 :            :   tree nl_goto_field;
     106                 :            : 
     107                 :            :   bool thunk_p;
     108                 :            :   bool any_parm_remapped;
     109                 :            :   bool any_tramp_created;
     110                 :            :   bool any_descr_created;
     111                 :            :   char static_chain_added;
     112                 :            : };
     113                 :            : 
     114                 :            : 
     115                 :            : /* Iterate over the nesting tree, starting with ROOT, depth first.  */
     116                 :            : 
     117                 :            : static inline struct nesting_info *
     118                 :      62231 : iter_nestinfo_start (struct nesting_info *root)
     119                 :            : {
     120                 :     227912 :   while (root->inner)
     121                 :            :     root = root->inner;
     122                 :            :   return root;
     123                 :            : }
     124                 :            : 
     125                 :            : static inline struct nesting_info *
     126                 :     227912 : iter_nestinfo_next (struct nesting_info *node)
     127                 :            : {
     128                 :     227912 :   if (node->next)
     129                 :            :     return iter_nestinfo_start (node->next);
     130                 :            :   return node->outer;
     131                 :            : }
     132                 :            : 
     133                 :            : #define FOR_EACH_NEST_INFO(I, ROOT) \
     134                 :            :   for ((I) = iter_nestinfo_start (ROOT); (I); (I) = iter_nestinfo_next (I))
     135                 :            : 
     136                 :            : /* Obstack used for the bitmaps in the struct above.  */
     137                 :            : static struct bitmap_obstack nesting_info_bitmap_obstack;
     138                 :            : 
     139                 :            : 
     140                 :            : /* We're working in so many different function contexts simultaneously,
     141                 :            :    that create_tmp_var is dangerous.  Prevent mishap.  */
     142                 :            : #define create_tmp_var cant_use_create_tmp_var_here_dummy
     143                 :            : 
     144                 :            : /* Like create_tmp_var, except record the variable for registration at
     145                 :            :    the given nesting level.  */
     146                 :            : 
     147                 :            : static tree
     148                 :      16335 : create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix)
     149                 :            : {
     150                 :      16335 :   tree tmp_var;
     151                 :            : 
     152                 :            :   /* If the type is of variable size or a type which must be created by the
     153                 :            :      frontend, something is wrong.  Note that we explicitly allow
     154                 :            :      incomplete types here, since we create them ourselves here.  */
     155                 :      16335 :   gcc_assert (!TREE_ADDRESSABLE (type));
     156                 :      16335 :   gcc_assert (!TYPE_SIZE_UNIT (type)
     157                 :            :               || TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
     158                 :            : 
     159                 :      16335 :   tmp_var = create_tmp_var_raw (type, prefix);
     160                 :      16335 :   DECL_CONTEXT (tmp_var) = info->context;
     161                 :      16335 :   DECL_CHAIN (tmp_var) = info->new_local_var_chain;
     162                 :      16335 :   DECL_SEEN_IN_BIND_EXPR_P (tmp_var) = 1;
     163                 :      16335 :   if (TREE_CODE (type) == COMPLEX_TYPE
     164                 :      16335 :       || TREE_CODE (type) == VECTOR_TYPE)
     165                 :         21 :     DECL_GIMPLE_REG_P (tmp_var) = 1;
     166                 :            : 
     167                 :      16335 :   info->new_local_var_chain = tmp_var;
     168                 :            : 
     169                 :      16335 :   return tmp_var;
     170                 :            : }
     171                 :            : 
     172                 :            : /* Like build_simple_mem_ref, but set TREE_THIS_NOTRAP on the result.  */
     173                 :            : 
     174                 :            : static tree
     175                 :      14758 : build_simple_mem_ref_notrap (tree ptr)
     176                 :            : {
     177                 :      14758 :   tree t = build_simple_mem_ref (ptr);
     178                 :      14758 :   TREE_THIS_NOTRAP (t) = 1;
     179                 :      14758 :   return t;
     180                 :            : }
     181                 :            : 
     182                 :            : /* Take the address of EXP to be used within function CONTEXT.
     183                 :            :    Mark it for addressability as necessary.  */
     184                 :            : 
     185                 :            : tree
     186                 :      27612 : build_addr (tree exp)
     187                 :            : {
     188                 :      27612 :   mark_addressable (exp);
     189                 :      27612 :   return build_fold_addr_expr (exp);
     190                 :            : }
     191                 :            : 
     192                 :            : /* Insert FIELD into TYPE, sorted by alignment requirements.  */
     193                 :            : 
     194                 :            : void
     195                 :     120074 : insert_field_into_struct (tree type, tree field)
     196                 :            : {
     197                 :     120074 :   tree *p;
     198                 :            : 
     199                 :     120074 :   DECL_CONTEXT (field) = type;
     200                 :            : 
     201                 :     155593 :   for (p = &TYPE_FIELDS (type); *p ; p = &DECL_CHAIN (*p))
     202                 :     114189 :     if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
     203                 :            :       break;
     204                 :            : 
     205                 :     120074 :   DECL_CHAIN (field) = *p;
     206                 :     120074 :   *p = field;
     207                 :            : 
     208                 :            :   /* Set correct alignment for frame struct type.  */
     209                 :     240148 :   if (TYPE_ALIGN (type) < DECL_ALIGN (field))
     210                 :      39421 :     SET_TYPE_ALIGN (type, DECL_ALIGN (field));
     211                 :     120074 : }
     212                 :            : 
     213                 :            : /* Build or return the RECORD_TYPE that describes the frame state that is
     214                 :            :    shared between INFO->CONTEXT and its nested functions.  This record will
     215                 :            :    not be complete until finalize_nesting_tree; up until that point we'll
     216                 :            :    be adding fields as necessary.
     217                 :            : 
     218                 :            :    We also build the DECL that represents this frame in the function.  */
     219                 :            : 
     220                 :            : static tree
     221                 :      24008 : get_frame_type (struct nesting_info *info)
     222                 :            : {
     223                 :      24008 :   tree type = info->frame_type;
     224                 :      24008 :   if (!type)
     225                 :            :     {
     226                 :       2631 :       char *name;
     227                 :            : 
     228                 :       2631 :       type = make_node (RECORD_TYPE);
     229                 :            : 
     230                 :       7893 :       name = concat ("FRAME.",
     231                 :       2631 :                      IDENTIFIER_POINTER (DECL_NAME (info->context)),
     232                 :            :                      NULL);
     233                 :       2631 :       TYPE_NAME (type) = get_identifier (name);
     234                 :       2631 :       free (name);
     235                 :            : 
     236                 :       2631 :       info->frame_type = type;
     237                 :            : 
     238                 :            :       /* Do not put info->frame_decl on info->new_local_var_chain,
     239                 :            :          so that we can declare it in the lexical blocks, which
     240                 :            :          makes sure virtual regs that end up appearing in its RTL
     241                 :            :          expression get substituted in instantiate_virtual_regs.  */
     242                 :       2631 :       info->frame_decl = create_tmp_var_raw (type, "FRAME");
     243                 :       2631 :       DECL_CONTEXT (info->frame_decl) = info->context;
     244                 :       2631 :       DECL_NONLOCAL_FRAME (info->frame_decl) = 1;
     245                 :       2631 :       DECL_SEEN_IN_BIND_EXPR_P (info->frame_decl) = 1;
     246                 :            : 
     247                 :            :       /* ??? Always make it addressable for now, since it is meant to
     248                 :            :          be pointed to by the static chain pointer.  This pessimizes
     249                 :            :          when it turns out that no static chains are needed because
     250                 :            :          the nested functions referencing non-local variables are not
     251                 :            :          reachable, but the true pessimization is to create the non-
     252                 :            :          local frame structure in the first place.  */
     253                 :       2631 :       TREE_ADDRESSABLE (info->frame_decl) = 1;
     254                 :            :     }
     255                 :            : 
     256                 :      24008 :   return type;
     257                 :            : }
     258                 :            : 
     259                 :            : /* Return true if DECL should be referenced by pointer in the non-local frame
     260                 :            :    structure.  */
     261                 :            : 
     262                 :            : static bool
     263                 :    1949460 : use_pointer_in_frame (tree decl)
     264                 :            : {
     265                 :    1949460 :   if (TREE_CODE (decl) == PARM_DECL)
     266                 :            :     {
     267                 :            :       /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable-
     268                 :            :          sized DECLs, and inefficient to copy large aggregates.  Don't bother
     269                 :            :          moving anything but scalar parameters.  */
     270                 :     109219 :       return AGGREGATE_TYPE_P (TREE_TYPE (decl));
     271                 :            :     }
     272                 :            :   else
     273                 :            :     {
     274                 :            :       /* Variable-sized DECLs can only come from OMP clauses at this point
     275                 :            :          since the gimplifier has already turned the regular variables into
     276                 :            :          pointers.  Do the same as the gimplifier.  */
     277                 :    1840240 :       return !DECL_SIZE (decl) || TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST;
     278                 :            :     }
     279                 :            : }
     280                 :            : 
     281                 :            : /* Given DECL, a non-locally accessed variable, find or create a field
     282                 :            :    in the non-local frame structure for the given nesting context.  */
     283                 :            : 
     284                 :            : static tree
     285                 :    1946640 : lookup_field_for_decl (struct nesting_info *info, tree decl,
     286                 :            :                        enum insert_option insert)
     287                 :            : {
     288                 :    1946640 :   gcc_checking_assert (decl_function_context (decl) == info->context);
     289                 :            : 
     290                 :    1946640 :   if (insert == NO_INSERT)
     291                 :            :     {
     292                 :    1932510 :       tree *slot = info->field_map->get (decl);
     293                 :    1932510 :       return slot ? *slot : NULL_TREE;
     294                 :            :     }
     295                 :            : 
     296                 :      14130 :   tree *slot = &info->field_map->get_or_insert (decl);
     297                 :      14130 :   if (!*slot)
     298                 :            :     {
     299                 :       2706 :       tree type = get_frame_type (info);
     300                 :       2706 :       tree field = make_node (FIELD_DECL);
     301                 :       2706 :       DECL_NAME (field) = DECL_NAME (decl);
     302                 :            : 
     303                 :       2706 :       if (use_pointer_in_frame (decl))
     304                 :            :         {
     305                 :         15 :           TREE_TYPE (field) = build_pointer_type (TREE_TYPE (decl));
     306                 :         15 :           SET_DECL_ALIGN (field, TYPE_ALIGN (TREE_TYPE (field)));
     307                 :         15 :           DECL_NONADDRESSABLE_P (field) = 1;
     308                 :            :         }
     309                 :            :       else
     310                 :            :         {
     311                 :       2691 :           TREE_TYPE (field) = TREE_TYPE (decl);
     312                 :       2691 :           DECL_SOURCE_LOCATION (field) = DECL_SOURCE_LOCATION (decl);
     313                 :       2691 :           SET_DECL_ALIGN (field, DECL_ALIGN (decl));
     314                 :       2691 :           DECL_USER_ALIGN (field) = DECL_USER_ALIGN (decl);
     315                 :       2691 :           TREE_ADDRESSABLE (field) = TREE_ADDRESSABLE (decl);
     316                 :       2691 :           DECL_NONADDRESSABLE_P (field) = !TREE_ADDRESSABLE (decl);
     317                 :       2691 :           TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (decl);
     318                 :            : 
     319                 :            :           /* Declare the transformation and adjust the original DECL.  For a
     320                 :            :              variable or for a parameter when not optimizing, we make it point
     321                 :            :              to the field in the frame directly.  For a parameter, we don't do
     322                 :            :              it when optimizing because the variable tracking pass will already
     323                 :            :              do the job,  */
     324                 :       2691 :           if (VAR_P (decl) || !optimize)
     325                 :            :             {
     326                 :       2521 :               tree x
     327                 :       2521 :                 = build3 (COMPONENT_REF, TREE_TYPE (field), info->frame_decl,
     328                 :            :                           field, NULL_TREE);
     329                 :            : 
     330                 :            :               /* If the next declaration is a PARM_DECL pointing to the DECL,
     331                 :            :                  we need to adjust its VALUE_EXPR directly, since chains of
     332                 :            :                  VALUE_EXPRs run afoul of garbage collection.  This occurs
     333                 :            :                  in Ada for Out parameters that aren't copied in.  */
     334                 :       2521 :               tree next = DECL_CHAIN (decl);
     335                 :       2521 :               if (next
     336                 :       2082 :                   && TREE_CODE (next) == PARM_DECL
     337                 :          9 :                   && DECL_HAS_VALUE_EXPR_P (next)
     338                 :       2525 :                   && DECL_VALUE_EXPR (next) == decl)
     339                 :          0 :                 SET_DECL_VALUE_EXPR (next, x);
     340                 :            : 
     341                 :       2521 :               SET_DECL_VALUE_EXPR (decl, x);
     342                 :       2561 :               DECL_HAS_VALUE_EXPR_P (decl) = 1;
     343                 :            :             }
     344                 :            :         }
     345                 :            : 
     346                 :       2706 :       insert_field_into_struct (type, field);
     347                 :       2706 :       *slot = field;
     348                 :            : 
     349                 :       2706 :       if (TREE_CODE (decl) == PARM_DECL)
     350                 :        219 :         info->any_parm_remapped = true;
     351                 :            :     }
     352                 :            : 
     353                 :      14130 :   return *slot;
     354                 :            : }
     355                 :            : 
     356                 :            : /* Build or return the variable that holds the static chain within
     357                 :            :    INFO->CONTEXT.  This variable may only be used within INFO->CONTEXT.  */
     358                 :            : 
     359                 :            : static tree
     360                 :      18261 : get_chain_decl (struct nesting_info *info)
     361                 :            : {
     362                 :      18261 :   tree decl = info->chain_decl;
     363                 :            : 
     364                 :      18261 :   if (!decl)
     365                 :            :     {
     366                 :       4241 :       tree type;
     367                 :            : 
     368                 :       4241 :       type = get_frame_type (info->outer);
     369                 :       4241 :       type = build_pointer_type (type);
     370                 :            : 
     371                 :            :       /* Note that this variable is *not* entered into any BIND_EXPR;
     372                 :            :          the construction of this variable is handled specially in
     373                 :            :          expand_function_start and initialize_inlined_parameters.
     374                 :            :          Note also that it's represented as a parameter.  This is more
     375                 :            :          close to the truth, since the initial value does come from
     376                 :            :          the caller.  */
     377                 :       4241 :       decl = build_decl (DECL_SOURCE_LOCATION (info->context),
     378                 :            :                          PARM_DECL, create_tmp_var_name ("CHAIN"), type);
     379                 :       4241 :       DECL_ARTIFICIAL (decl) = 1;
     380                 :       4241 :       DECL_IGNORED_P (decl) = 1;
     381                 :       4241 :       TREE_USED (decl) = 1;
     382                 :       4241 :       DECL_CONTEXT (decl) = info->context;
     383                 :       4241 :       DECL_ARG_TYPE (decl) = type;
     384                 :            : 
     385                 :            :       /* Tell tree-inline.c that we never write to this variable, so
     386                 :            :          it can copy-prop the replacement value immediately.  */
     387                 :       4241 :       TREE_READONLY (decl) = 1;
     388                 :            : 
     389                 :       4241 :       info->chain_decl = decl;
     390                 :            : 
     391                 :       4241 :       if (dump_file
     392                 :          0 :           && (dump_flags & TDF_DETAILS)
     393                 :       4241 :           && !DECL_STATIC_CHAIN (info->context))
     394                 :          0 :         fprintf (dump_file, "Setting static-chain for %s\n",
     395                 :          0 :                  lang_hooks.decl_printable_name (info->context, 2));
     396                 :            : 
     397                 :       4241 :       DECL_STATIC_CHAIN (info->context) = 1;
     398                 :            :     }
     399                 :      18261 :   return decl;
     400                 :            : }
     401                 :            : 
     402                 :            : /* Build or return the field within the non-local frame state that holds
     403                 :            :    the static chain for INFO->CONTEXT.  This is the way to walk back up
     404                 :            :    multiple nesting levels.  */
     405                 :            : 
     406                 :            : static tree
     407                 :         68 : get_chain_field (struct nesting_info *info)
     408                 :            : {
     409                 :         68 :   tree field = info->chain_field;
     410                 :            : 
     411                 :         68 :   if (!field)
     412                 :            :     {
     413                 :         11 :       tree type = build_pointer_type (get_frame_type (info->outer));
     414                 :            : 
     415                 :         11 :       field = make_node (FIELD_DECL);
     416                 :         11 :       DECL_NAME (field) = get_identifier ("__chain");
     417                 :         11 :       TREE_TYPE (field) = type;
     418                 :         11 :       SET_DECL_ALIGN (field, TYPE_ALIGN (type));
     419                 :         11 :       DECL_NONADDRESSABLE_P (field) = 1;
     420                 :            : 
     421                 :         11 :       insert_field_into_struct (get_frame_type (info), field);
     422                 :            : 
     423                 :         11 :       info->chain_field = field;
     424                 :            : 
     425                 :         11 :       if (dump_file
     426                 :          0 :           && (dump_flags & TDF_DETAILS)
     427                 :         11 :           && !DECL_STATIC_CHAIN (info->context))
     428                 :          0 :         fprintf (dump_file, "Setting static-chain for %s\n",
     429                 :          0 :                  lang_hooks.decl_printable_name (info->context, 2));
     430                 :            : 
     431                 :         11 :       DECL_STATIC_CHAIN (info->context) = 1;
     432                 :            :     }
     433                 :         68 :   return field;
     434                 :            : }
     435                 :            : 
     436                 :            : /* Initialize a new temporary with the GIMPLE_CALL STMT.  */
     437                 :            : 
     438                 :            : static tree
     439                 :       1333 : init_tmp_var_with_call (struct nesting_info *info, gimple_stmt_iterator *gsi,
     440                 :            :                         gcall *call)
     441                 :            : {
     442                 :       1333 :   tree t;
     443                 :            : 
     444                 :       1333 :   t = create_tmp_var_for (info, gimple_call_return_type (call), NULL);
     445                 :       1333 :   gimple_call_set_lhs (call, t);
     446                 :       1333 :   if (! gsi_end_p (*gsi))
     447                 :        308 :     gimple_set_location (call, gimple_location (gsi_stmt (*gsi)));
     448                 :       1333 :   gsi_insert_before (gsi, call, GSI_SAME_STMT);
     449                 :            : 
     450                 :       1333 :   return t;
     451                 :            : }
     452                 :            : 
     453                 :            : 
     454                 :            : /* Copy EXP into a temporary.  Allocate the temporary in the context of
     455                 :            :    INFO and insert the initialization statement before GSI.  */
     456                 :            : 
     457                 :            : static tree
     458                 :      11093 : init_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
     459                 :            : {
     460                 :      11093 :   tree t;
     461                 :      11093 :   gimple *stmt;
     462                 :            : 
     463                 :      11093 :   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
     464                 :      11093 :   stmt = gimple_build_assign (t, exp);
     465                 :      11093 :   if (! gsi_end_p (*gsi))
     466                 :      11075 :     gimple_set_location (stmt, gimple_location (gsi_stmt (*gsi)));
     467                 :      11093 :   gsi_insert_before_without_update (gsi, stmt, GSI_SAME_STMT);
     468                 :            : 
     469                 :      11093 :   return t;
     470                 :            : }
     471                 :            : 
     472                 :            : 
     473                 :            : /* Similarly, but only do so to force EXP to satisfy is_gimple_val.  */
     474                 :            : 
     475                 :            : static tree
     476                 :       2236 : gsi_gimplify_val (struct nesting_info *info, tree exp,
     477                 :            :                   gimple_stmt_iterator *gsi)
     478                 :            : {
     479                 :       2236 :   if (is_gimple_val (exp))
     480                 :            :     return exp;
     481                 :            :   else
     482                 :        546 :     return init_tmp_var (info, exp, gsi);
     483                 :            : }
     484                 :            : 
     485                 :            : /* Similarly, but copy from the temporary and insert the statement
     486                 :            :    after the iterator.  */
     487                 :            : 
     488                 :            : static tree
     489                 :       3909 : save_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
     490                 :            : {
     491                 :       3909 :   tree t;
     492                 :       3909 :   gimple *stmt;
     493                 :            : 
     494                 :       3909 :   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
     495                 :       3909 :   stmt = gimple_build_assign (exp, t);
     496                 :       3909 :   if (! gsi_end_p (*gsi))
     497                 :       3909 :     gimple_set_location (stmt, gimple_location (gsi_stmt (*gsi)));
     498                 :       3909 :   gsi_insert_after_without_update (gsi, stmt, GSI_SAME_STMT);
     499                 :            : 
     500                 :       3909 :   return t;
     501                 :            : }
     502                 :            : 
     503                 :            : /* Build or return the type used to represent a nested function trampoline.  */
     504                 :            : 
     505                 :            : static GTY(()) tree trampoline_type;
     506                 :            : 
     507                 :            : static tree
     508                 :        290 : get_trampoline_type (struct nesting_info *info)
     509                 :            : {
     510                 :        290 :   unsigned align, size;
     511                 :        290 :   tree t;
     512                 :            : 
     513                 :        290 :   if (trampoline_type)
     514                 :            :     return trampoline_type;
     515                 :            : 
     516                 :        258 :   align = TRAMPOLINE_ALIGNMENT;
     517                 :        258 :   size = TRAMPOLINE_SIZE;
     518                 :            : 
     519                 :            :   /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
     520                 :            :      then allocate extra space so that we can do dynamic alignment.  */
     521                 :        258 :   if (align > STACK_BOUNDARY)
     522                 :            :     {
     523                 :          0 :       size += ((align/BITS_PER_UNIT) - 1) & -(STACK_BOUNDARY/BITS_PER_UNIT);
     524                 :          0 :       align = STACK_BOUNDARY;
     525                 :            :     }
     526                 :            : 
     527                 :        258 :   t = build_index_type (size_int (size - 1));
     528                 :        258 :   t = build_array_type (char_type_node, t);
     529                 :        258 :   t = build_decl (DECL_SOURCE_LOCATION (info->context),
     530                 :            :                   FIELD_DECL, get_identifier ("__data"), t);
     531                 :        258 :   SET_DECL_ALIGN (t, align);
     532                 :        258 :   DECL_USER_ALIGN (t) = 1;
     533                 :            : 
     534                 :        258 :   trampoline_type = make_node (RECORD_TYPE);
     535                 :        258 :   TYPE_NAME (trampoline_type) = get_identifier ("__builtin_trampoline");
     536                 :        258 :   TYPE_FIELDS (trampoline_type) = t;
     537                 :        258 :   layout_type (trampoline_type);
     538                 :        258 :   DECL_CONTEXT (t) = trampoline_type;
     539                 :            : 
     540                 :        258 :   return trampoline_type;
     541                 :            : }
     542                 :            : 
     543                 :            : /* Build or return the type used to represent a nested function descriptor.  */
     544                 :            : 
     545                 :            : static GTY(()) tree descriptor_type;
     546                 :            : 
     547                 :            : static tree
     548                 :          0 : get_descriptor_type (struct nesting_info *info)
     549                 :            : {
     550                 :            :   /* The base alignment is that of a function.  */
     551                 :          0 :   const unsigned align = FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY);
     552                 :          0 :   tree t;
     553                 :            : 
     554                 :          0 :   if (descriptor_type)
     555                 :            :     return descriptor_type;
     556                 :            : 
     557                 :          0 :   t = build_index_type (integer_one_node);
     558                 :          0 :   t = build_array_type (ptr_type_node, t);
     559                 :          0 :   t = build_decl (DECL_SOURCE_LOCATION (info->context),
     560                 :            :                   FIELD_DECL, get_identifier ("__data"), t);
     561                 :          0 :   SET_DECL_ALIGN (t, MAX (TYPE_ALIGN (ptr_type_node), align));
     562                 :          0 :   DECL_USER_ALIGN (t) = 1;
     563                 :            : 
     564                 :          0 :   descriptor_type = make_node (RECORD_TYPE);
     565                 :          0 :   TYPE_NAME (descriptor_type) = get_identifier ("__builtin_descriptor");
     566                 :          0 :   TYPE_FIELDS (descriptor_type) = t;
     567                 :          0 :   layout_type (descriptor_type);
     568                 :          0 :   DECL_CONTEXT (t) = descriptor_type;
     569                 :            : 
     570                 :          0 :   return descriptor_type;
     571                 :            : }
     572                 :            : 
     573                 :            : /* Given DECL, a nested function, find or create an element in the
     574                 :            :    var map for this function.  */
     575                 :            : 
     576                 :            : static tree
     577                 :        668 : lookup_element_for_decl (struct nesting_info *info, tree decl,
     578                 :            :                          enum insert_option insert)
     579                 :            : {
     580                 :        668 :   if (insert == NO_INSERT)
     581                 :            :     {
     582                 :        360 :       tree *slot = info->var_map->get (decl);
     583                 :        360 :       return slot ? *slot : NULL_TREE;
     584                 :            :     }
     585                 :            : 
     586                 :        308 :   tree *slot = &info->var_map->get_or_insert (decl);
     587                 :        308 :   if (!*slot)
     588                 :        290 :     *slot = build_tree_list (NULL_TREE, NULL_TREE);
     589                 :            : 
     590                 :        308 :   return (tree) *slot;
     591                 :            : } 
     592                 :            : 
     593                 :            : /* Given DECL, a nested function, create a field in the non-local
     594                 :            :    frame structure for this function.  */
     595                 :            : 
     596                 :            : static tree
     597                 :        290 : create_field_for_decl (struct nesting_info *info, tree decl, tree type)
     598                 :            : {
     599                 :        290 :   tree field = make_node (FIELD_DECL);
     600                 :        290 :   DECL_NAME (field) = DECL_NAME (decl);
     601                 :        290 :   TREE_TYPE (field) = type;
     602                 :        290 :   TREE_ADDRESSABLE (field) = 1;
     603                 :        290 :   insert_field_into_struct (get_frame_type (info), field);
     604                 :        290 :   return field;
     605                 :            : }
     606                 :            : 
     607                 :            : /* Given DECL, a nested function, find or create a field in the non-local
     608                 :            :    frame structure for a trampoline for this function.  */
     609                 :            : 
     610                 :            : static tree
     611                 :        668 : lookup_tramp_for_decl (struct nesting_info *info, tree decl,
     612                 :            :                        enum insert_option insert)
     613                 :            : {
     614                 :        668 :   tree elt, field;
     615                 :            : 
     616                 :        668 :   elt = lookup_element_for_decl (info, decl, insert);
     617                 :        668 :   if (!elt)
     618                 :            :     return NULL_TREE;
     619                 :            : 
     620                 :        598 :   field = TREE_PURPOSE (elt);
     621                 :            : 
     622                 :        598 :   if (!field && insert == INSERT)
     623                 :            :     {
     624                 :        290 :       field = create_field_for_decl (info, decl, get_trampoline_type (info));
     625                 :        290 :       TREE_PURPOSE (elt) = field;
     626                 :        290 :       info->any_tramp_created = true;
     627                 :            :     }
     628                 :            : 
     629                 :            :   return field;
     630                 :            : }
     631                 :            : 
     632                 :            : /* Given DECL, a nested function, find or create a field in the non-local
     633                 :            :    frame structure for a descriptor for this function.  */
     634                 :            : 
     635                 :            : static tree
     636                 :          0 : lookup_descr_for_decl (struct nesting_info *info, tree decl,
     637                 :            :                        enum insert_option insert)
     638                 :            : {
     639                 :          0 :   tree elt, field;
     640                 :            : 
     641                 :          0 :   elt = lookup_element_for_decl (info, decl, insert);
     642                 :          0 :   if (!elt)
     643                 :            :     return NULL_TREE;
     644                 :            : 
     645                 :          0 :   field = TREE_VALUE (elt);
     646                 :            : 
     647                 :          0 :   if (!field && insert == INSERT)
     648                 :            :     {
     649                 :          0 :       field = create_field_for_decl (info, decl, get_descriptor_type (info));
     650                 :          0 :       TREE_VALUE (elt) = field;
     651                 :          0 :       info->any_descr_created = true;
     652                 :            :     }
     653                 :            : 
     654                 :            :   return field;
     655                 :            : }
     656                 :            : 
     657                 :            : /* Build or return the field within the non-local frame state that holds
     658                 :            :    the non-local goto "jmp_buf".  The buffer itself is maintained by the
     659                 :            :    rtl middle-end as dynamic stack space is allocated.  */
     660                 :            : 
     661                 :            : static tree
     662                 :        519 : get_nl_goto_field (struct nesting_info *info)
     663                 :            : {
     664                 :        519 :   tree field = info->nl_goto_field;
     665                 :        519 :   if (!field)
     666                 :            :     {
     667                 :        373 :       unsigned size;
     668                 :        373 :       tree type;
     669                 :            : 
     670                 :            :       /* For __builtin_nonlocal_goto, we need N words.  The first is the
     671                 :            :          frame pointer, the rest is for the target's stack pointer save
     672                 :            :          area.  The number of words is controlled by STACK_SAVEAREA_MODE;
     673                 :            :          not the best interface, but it'll do for now.  */
     674                 :        373 :       if (Pmode == ptr_mode)
     675                 :        373 :         type = ptr_type_node;
     676                 :            :       else
     677                 :          0 :         type = lang_hooks.types.type_for_mode (Pmode, 1);
     678                 :            : 
     679                 :        373 :       scalar_int_mode mode
     680                 :        373 :         = as_a <scalar_int_mode> (STACK_SAVEAREA_MODE (SAVE_NONLOCAL));
     681                 :        373 :       size = GET_MODE_SIZE (mode);
     682                 :        373 :       size = size / GET_MODE_SIZE (Pmode);
     683                 :        373 :       size = size + 1;
     684                 :            : 
     685                 :        373 :       type = build_array_type
     686                 :        373 :         (type, build_index_type (size_int (size)));
     687                 :            : 
     688                 :        373 :       field = make_node (FIELD_DECL);
     689                 :        373 :       DECL_NAME (field) = get_identifier ("__nl_goto_buf");
     690                 :        373 :       TREE_TYPE (field) = type;
     691                 :        373 :       SET_DECL_ALIGN (field, TYPE_ALIGN (type));
     692                 :        373 :       TREE_ADDRESSABLE (field) = 1;
     693                 :            : 
     694                 :        373 :       insert_field_into_struct (get_frame_type (info), field);
     695                 :            : 
     696                 :        373 :       info->nl_goto_field = field;
     697                 :            :     }
     698                 :            : 
     699                 :        519 :   return field;
     700                 :            : }
     701                 :            : 
     702                 :            : /* Invoke CALLBACK on all statements of GIMPLE sequence *PSEQ.  */
     703                 :            : 
     704                 :            : static void
     705                 :     142058 : walk_body (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
     706                 :            :            struct nesting_info *info, gimple_seq *pseq)
     707                 :            : {
     708                 :     142058 :   struct walk_stmt_info wi;
     709                 :            : 
     710                 :     142058 :   memset (&wi, 0, sizeof (wi));
     711                 :     142058 :   wi.info = info;
     712                 :     142058 :   wi.val_only = true;
     713                 :     142058 :   walk_gimple_seq_mod (pseq, callback_stmt, callback_op, &wi);
     714                 :     142058 : }
     715                 :            : 
     716                 :            : 
     717                 :            : /* Invoke CALLBACK_STMT/CALLBACK_OP on all statements of INFO->CONTEXT.  */
     718                 :            : 
     719                 :            : static inline void
     720                 :     124492 : walk_function (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
     721                 :            :                struct nesting_info *info)
     722                 :            : {
     723                 :     124492 :   gimple_seq body = gimple_body (info->context);
     724                 :     124492 :   walk_body (callback_stmt, callback_op, info, &body);
     725                 :     124492 :   gimple_set_body (info->context, body);
     726                 :     124492 : }
     727                 :            : 
     728                 :            : /* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body.  */
     729                 :            : 
     730                 :            : static void
     731                 :       2388 : walk_gimple_omp_for (gomp_for *for_stmt,
     732                 :            :                      walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
     733                 :            :                      struct nesting_info *info)
     734                 :            : {
     735                 :       2388 :   struct walk_stmt_info wi;
     736                 :       2388 :   gimple_seq seq;
     737                 :       2388 :   tree t;
     738                 :       2388 :   size_t i;
     739                 :            : 
     740                 :       2388 :   walk_body (callback_stmt, callback_op, info, gimple_omp_for_pre_body_ptr (for_stmt));
     741                 :            : 
     742                 :       2388 :   seq = NULL;
     743                 :       2388 :   memset (&wi, 0, sizeof (wi));
     744                 :       2388 :   wi.info = info;
     745                 :       2388 :   wi.gsi = gsi_last (seq);
     746                 :            : 
     747                 :       5400 :   for (i = 0; i < gimple_omp_for_collapse (for_stmt); i++)
     748                 :            :     {
     749                 :       3012 :       wi.val_only = false;
     750                 :       3012 :       walk_tree (gimple_omp_for_index_ptr (for_stmt, i), callback_op,
     751                 :            :                  &wi, NULL);
     752                 :       3012 :       wi.val_only = true;
     753                 :       3012 :       wi.is_lhs = false;
     754                 :       3012 :       walk_tree (gimple_omp_for_initial_ptr (for_stmt, i), callback_op,
     755                 :            :                  &wi, NULL);
     756                 :            : 
     757                 :       3012 :       wi.val_only = true;
     758                 :       3012 :       wi.is_lhs = false;
     759                 :       3012 :       walk_tree (gimple_omp_for_final_ptr (for_stmt, i), callback_op,
     760                 :            :                  &wi, NULL);
     761                 :            : 
     762                 :       3012 :       t = gimple_omp_for_incr (for_stmt, i);
     763                 :       3012 :       gcc_assert (BINARY_CLASS_P (t));
     764                 :       3012 :       wi.val_only = false;
     765                 :       3012 :       walk_tree (&TREE_OPERAND (t, 0), callback_op, &wi, NULL);
     766                 :       3012 :       wi.val_only = true;
     767                 :       3012 :       wi.is_lhs = false;
     768                 :       3012 :       walk_tree (&TREE_OPERAND (t, 1), callback_op, &wi, NULL);
     769                 :            :     }
     770                 :            : 
     771                 :       2388 :   seq = gsi_seq (wi.gsi);
     772                 :       2388 :   if (!gimple_seq_empty_p (seq))
     773                 :            :     {
     774                 :          9 :       gimple_seq pre_body = gimple_omp_for_pre_body (for_stmt);
     775                 :          9 :       annotate_all_with_location (seq, gimple_location (for_stmt));
     776                 :          9 :       gimple_seq_add_seq (&pre_body, seq);
     777                 :          9 :       gimple_omp_for_set_pre_body (for_stmt, pre_body);
     778                 :            :     }
     779                 :       2388 : }
     780                 :            : 
     781                 :            : /* Similarly for ROOT and all functions nested underneath, depth first.  */
     782                 :            : 
     783                 :            : static void
     784                 :      27640 : walk_all_functions (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
     785                 :            :                     struct nesting_info *root)
     786                 :            : {
     787                 :      27640 :   struct nesting_info *n;
     788                 :     220752 :   FOR_EACH_NEST_INFO (n, root)
     789                 :      82736 :     walk_function (callback_stmt, callback_op, n);
     790                 :      27640 : }
     791                 :            : 
     792                 :            : 
     793                 :            : /* We have to check for a fairly pathological case.  The operands of function
     794                 :            :    nested function are to be interpreted in the context of the enclosing
     795                 :            :    function.  So if any are variably-sized, they will get remapped when the
     796                 :            :    enclosing function is inlined.  But that remapping would also have to be
     797                 :            :    done in the types of the PARM_DECLs of the nested function, meaning the
     798                 :            :    argument types of that function will disagree with the arguments in the
     799                 :            :    calls to that function.  So we'd either have to make a copy of the nested
     800                 :            :    function corresponding to each time the enclosing function was inlined or
     801                 :            :    add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
     802                 :            :    function.  The former is not practical.  The latter would still require
     803                 :            :    detecting this case to know when to add the conversions.  So, for now at
     804                 :            :    least, we don't inline such an enclosing function.
     805                 :            : 
     806                 :            :    We have to do that check recursively, so here return indicating whether
     807                 :            :    FNDECL has such a nested function.  ORIG_FN is the function we were
     808                 :            :    trying to inline to use for checking whether any argument is variably
     809                 :            :    modified by anything in it.
     810                 :            : 
     811                 :            :    It would be better to do this in tree-inline.c so that we could give
     812                 :            :    the appropriate warning for why a function can't be inlined, but that's
     813                 :            :    too late since the nesting structure has already been flattened and
     814                 :            :    adding a flag just to record this fact seems a waste of a flag.  */
     815                 :            : 
     816                 :            : static bool
     817                 :      34043 : check_for_nested_with_variably_modified (tree fndecl, tree orig_fndecl)
     818                 :            : {
     819                 :      34043 :   struct cgraph_node *cgn = cgraph_node::get (fndecl);
     820                 :      34043 :   tree arg;
     821                 :            : 
     822                 :      47402 :   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
     823                 :            :     {
     824                 :      35402 :       for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = DECL_CHAIN (arg))
     825                 :      22043 :         if (variably_modified_type_p (TREE_TYPE (arg), orig_fndecl))
     826                 :            :           return true;
     827                 :            : 
     828                 :      13359 :       if (check_for_nested_with_variably_modified (cgn->decl,
     829                 :            :                                                    orig_fndecl))
     830                 :            :         return true;
     831                 :            :     }
     832                 :            : 
     833                 :            :   return false;
     834                 :            : }
     835                 :            : 
     836                 :            : /* Construct our local datastructure describing the function nesting
     837                 :            :    tree rooted by CGN.  */
     838                 :            : 
     839                 :            : static struct nesting_info *
     840                 :      20684 : create_nesting_tree (struct cgraph_node *cgn)
     841                 :            : {
     842                 :      20684 :   struct nesting_info *info = XCNEW (struct nesting_info);
     843                 :      20684 :   info->field_map = new hash_map<tree, tree>;
     844                 :      20684 :   info->var_map = new hash_map<tree, tree>;
     845                 :      20684 :   info->mem_refs = new hash_set<tree *>;
     846                 :      20684 :   info->suppress_expansion = BITMAP_ALLOC (&nesting_info_bitmap_obstack);
     847                 :      20684 :   info->context = cgn->decl;
     848                 :      20684 :   info->thunk_p = cgn->thunk.thunk_p;
     849                 :            : 
     850                 :      34458 :   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
     851                 :            :     {
     852                 :      13774 :       struct nesting_info *sub = create_nesting_tree (cgn);
     853                 :      13774 :       sub->outer = info;
     854                 :      13774 :       sub->next = info->inner;
     855                 :      13774 :       info->inner = sub;
     856                 :            :     }
     857                 :            : 
     858                 :            :   /* See discussion at check_for_nested_with_variably_modified for a
     859                 :            :      discussion of why this has to be here.  */
     860                 :      20684 :   if (check_for_nested_with_variably_modified (info->context, info->context))
     861                 :        244 :     DECL_UNINLINABLE (info->context) = true;
     862                 :            : 
     863                 :      20684 :   return info;
     864                 :            : }
     865                 :            : 
     866                 :            : /* Return an expression computing the static chain for TARGET_CONTEXT
     867                 :            :    from INFO->CONTEXT.  Insert any necessary computations before TSI.  */
     868                 :            : 
     869                 :            : static tree
     870                 :       9505 : get_static_chain (struct nesting_info *info, tree target_context,
     871                 :            :                   gimple_stmt_iterator *gsi)
     872                 :            : {
     873                 :       9505 :   struct nesting_info *i;
     874                 :       9505 :   tree x;
     875                 :            : 
     876                 :       9505 :   if (info->context == target_context)
     877                 :            :     {
     878                 :       8362 :       x = build_addr (info->frame_decl);
     879                 :       8362 :       info->static_chain_added |= 1;
     880                 :            :     }
     881                 :            :   else
     882                 :            :     {
     883                 :       1143 :       x = get_chain_decl (info);
     884                 :       1143 :       info->static_chain_added |= 2;
     885                 :            : 
     886                 :       1145 :       for (i = info->outer; i->context != target_context; i = i->outer)
     887                 :            :         {
     888                 :          2 :           tree field = get_chain_field (i);
     889                 :            : 
     890                 :          2 :           x = build_simple_mem_ref_notrap (x);
     891                 :          2 :           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
     892                 :          2 :           x = init_tmp_var (info, x, gsi);
     893                 :            :         }
     894                 :            :     }
     895                 :            : 
     896                 :       9505 :   return x;
     897                 :            : }
     898                 :            : 
     899                 :            : 
     900                 :            : /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
     901                 :            :    frame as seen from INFO->CONTEXT.  Insert any necessary computations
     902                 :            :    before GSI.  */
     903                 :            : 
     904                 :            : static tree
     905                 :      29217 : get_frame_field (struct nesting_info *info, tree target_context,
     906                 :            :                  tree field, gimple_stmt_iterator *gsi)
     907                 :            : {
     908                 :      29217 :   struct nesting_info *i;
     909                 :      29217 :   tree x;
     910                 :            : 
     911                 :      29217 :   if (info->context == target_context)
     912                 :            :     {
     913                 :            :       /* Make sure frame_decl gets created.  */
     914                 :      15166 :       (void) get_frame_type (info);
     915                 :      15166 :       x = info->frame_decl;
     916                 :      15166 :       info->static_chain_added |= 1;
     917                 :            :     }
     918                 :            :   else
     919                 :            :     {
     920                 :      14051 :       x = get_chain_decl (info);
     921                 :      14051 :       info->static_chain_added |= 2;
     922                 :            : 
     923                 :      14117 :       for (i = info->outer; i->context != target_context; i = i->outer)
     924                 :            :         {
     925                 :         66 :           tree field = get_chain_field (i);
     926                 :            : 
     927                 :         66 :           x = build_simple_mem_ref_notrap (x);
     928                 :         66 :           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
     929                 :         66 :           x = init_tmp_var (info, x, gsi);
     930                 :            :         }
     931                 :            : 
     932                 :      14051 :       x = build_simple_mem_ref_notrap (x);
     933                 :            :     }
     934                 :            : 
     935                 :      29217 :   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
     936                 :      29217 :   return x;
     937                 :            : }
     938                 :            : 
     939                 :            : static void note_nonlocal_vla_type (struct nesting_info *info, tree type);
     940                 :            : 
     941                 :            : /* A subroutine of convert_nonlocal_reference_op.  Create a local variable
     942                 :            :    in the nested function with DECL_VALUE_EXPR set to reference the true
     943                 :            :    variable in the parent function.  This is used both for debug info
     944                 :            :    and in OMP lowering.  */
     945                 :            : 
     946                 :            : static tree
     947                 :       3542 : get_nonlocal_debug_decl (struct nesting_info *info, tree decl)
     948                 :            : {
     949                 :       3542 :   tree target_context;
     950                 :       3542 :   struct nesting_info *i;
     951                 :       3542 :   tree x, field, new_decl;
     952                 :            : 
     953                 :       3542 :   tree *slot = &info->var_map->get_or_insert (decl);
     954                 :            : 
     955                 :       3542 :   if (*slot)
     956                 :            :     return *slot;
     957                 :            : 
     958                 :        624 :   target_context = decl_function_context (decl);
     959                 :            : 
     960                 :            :   /* A copy of the code in get_frame_field, but without the temporaries.  */
     961                 :        624 :   if (info->context == target_context)
     962                 :            :     {
     963                 :            :       /* Make sure frame_decl gets created.  */
     964                 :          0 :       (void) get_frame_type (info);
     965                 :          0 :       x = info->frame_decl;
     966                 :          0 :       i = info;
     967                 :          0 :       info->static_chain_added |= 1;
     968                 :            :     }
     969                 :            :   else
     970                 :            :     {
     971                 :        624 :       x = get_chain_decl (info);
     972                 :        624 :       info->static_chain_added |= 2;
     973                 :        624 :       for (i = info->outer; i->context != target_context; i = i->outer)
     974                 :            :         {
     975                 :          0 :           field = get_chain_field (i);
     976                 :          0 :           x = build_simple_mem_ref_notrap (x);
     977                 :          0 :           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
     978                 :            :         }
     979                 :        624 :       x = build_simple_mem_ref_notrap (x);
     980                 :            :     }
     981                 :            : 
     982                 :        624 :   field = lookup_field_for_decl (i, decl, INSERT);
     983                 :        624 :   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
     984                 :        624 :   if (use_pointer_in_frame (decl))
     985                 :          6 :     x = build_simple_mem_ref_notrap (x);
     986                 :            : 
     987                 :            :   /* ??? We should be remapping types as well, surely.  */
     988                 :       2496 :   new_decl = build_decl (DECL_SOURCE_LOCATION (decl),
     989                 :        624 :                          VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
     990                 :        624 :   DECL_CONTEXT (new_decl) = info->context;
     991                 :        624 :   DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
     992                 :        624 :   DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
     993                 :        624 :   TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
     994                 :        624 :   TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
     995                 :        624 :   TREE_READONLY (new_decl) = TREE_READONLY (decl);
     996                 :        624 :   TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
     997                 :        624 :   DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
     998                 :        624 :   if ((TREE_CODE (decl) == PARM_DECL
     999                 :        624 :        || TREE_CODE (decl) == RESULT_DECL
    1000                 :        590 :        || VAR_P (decl))
    1001                 :       1242 :       && DECL_BY_REFERENCE (decl))
    1002                 :          6 :     DECL_BY_REFERENCE (new_decl) = 1;
    1003                 :            : 
    1004                 :        624 :   SET_DECL_VALUE_EXPR (new_decl, x);
    1005                 :        624 :   DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
    1006                 :            : 
    1007                 :        624 :   *slot = new_decl;
    1008                 :        624 :   DECL_CHAIN (new_decl) = info->debug_var_chain;
    1009                 :        624 :   info->debug_var_chain = new_decl;
    1010                 :            : 
    1011                 :        624 :   if (!optimize
    1012                 :        115 :       && info->context != target_context
    1013                 :        739 :       && variably_modified_type_p (TREE_TYPE (decl), NULL))
    1014                 :          1 :     note_nonlocal_vla_type (info, TREE_TYPE (decl));
    1015                 :            : 
    1016                 :            :   return new_decl;
    1017                 :            : }
    1018                 :            : 
    1019                 :            : 
    1020                 :            : /* Callback for walk_gimple_stmt, rewrite all references to VAR
    1021                 :            :    and PARM_DECLs that belong to outer functions.
    1022                 :            : 
    1023                 :            :    The rewrite will involve some number of structure accesses back up
    1024                 :            :    the static chain.  E.g. for a variable FOO up one nesting level it'll
    1025                 :            :    be CHAIN->FOO.  For two levels it'll be CHAIN->__chain->FOO.  Further
    1026                 :            :    indirections apply to decls for which use_pointer_in_frame is true.  */
    1027                 :            : 
    1028                 :            : static tree
    1029                 :    7075800 : convert_nonlocal_reference_op (tree *tp, int *walk_subtrees, void *data)
    1030                 :            : {
    1031                 :    7075800 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
    1032                 :    7075800 :   struct nesting_info *const info = (struct nesting_info *) wi->info;
    1033                 :    7075800 :   tree t = *tp;
    1034                 :            : 
    1035                 :    7075800 :   *walk_subtrees = 0;
    1036                 :    7075800 :   switch (TREE_CODE (t))
    1037                 :            :     {
    1038                 :    1831700 :     case VAR_DECL:
    1039                 :            :       /* Non-automatic variables are never processed.  */
    1040                 :    3577940 :       if (TREE_STATIC (t) || DECL_EXTERNAL (t))
    1041                 :            :         break;
    1042                 :            :       /* FALLTHRU */
    1043                 :            : 
    1044                 :    1839980 :     case PARM_DECL:
    1045                 :    1839980 :       {
    1046                 :    1839980 :         tree x, target_context = decl_function_context (t);
    1047                 :            : 
    1048                 :    1839980 :         if (info->context == target_context)
    1049                 :            :           break;
    1050                 :            : 
    1051                 :      15890 :         wi->changed = true;
    1052                 :            : 
    1053                 :      15890 :         if (bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
    1054                 :       2384 :           x = get_nonlocal_debug_decl (info, t);
    1055                 :            :         else
    1056                 :            :           {
    1057                 :            :             struct nesting_info *i = info;
    1058                 :      27078 :             while (i && i->context != target_context)
    1059                 :      13572 :               i = i->outer;
    1060                 :            :             /* If none of the outer contexts is the target context, this means
    1061                 :            :                that the VAR or PARM_DECL is referenced in a wrong context.  */
    1062                 :      13506 :             if (!i)
    1063                 :          0 :               internal_error ("%s from %s referenced in %s",
    1064                 :          0 :                               IDENTIFIER_POINTER (DECL_NAME (t)),
    1065                 :          0 :                               IDENTIFIER_POINTER (DECL_NAME (target_context)),
    1066                 :          0 :                               IDENTIFIER_POINTER (DECL_NAME (info->context)));
    1067                 :            : 
    1068                 :      13506 :             x = lookup_field_for_decl (i, t, INSERT);
    1069                 :      13506 :             x = get_frame_field (info, target_context, x, &wi->gsi);
    1070                 :      13506 :             if (use_pointer_in_frame (t))
    1071                 :            :               {
    1072                 :          9 :                 x = init_tmp_var (info, x, &wi->gsi);
    1073                 :          9 :                 x = build_simple_mem_ref_notrap (x);
    1074                 :            :               }
    1075                 :            :           }
    1076                 :            : 
    1077                 :      15890 :         if (wi->val_only)
    1078                 :            :           {
    1079                 :       6725 :             if (wi->is_lhs)
    1080                 :       1629 :               x = save_tmp_var (info, x, &wi->gsi);
    1081                 :            :             else
    1082                 :       5096 :               x = init_tmp_var (info, x, &wi->gsi);
    1083                 :            :           }
    1084                 :            : 
    1085                 :      15890 :         *tp = x;
    1086                 :            :       }
    1087                 :      15890 :       break;
    1088                 :            : 
    1089                 :     795351 :     case LABEL_DECL:
    1090                 :            :       /* We're taking the address of a label from a parent function, but
    1091                 :            :          this is not itself a non-local goto.  Mark the label such that it
    1092                 :            :          will not be deleted, much as we would with a label address in
    1093                 :            :          static storage.  */
    1094                 :     795351 :       if (decl_function_context (t) != info->context)
    1095                 :         77 :         FORCED_LABEL (t) = 1;
    1096                 :            :       break;
    1097                 :            : 
    1098                 :     402540 :     case ADDR_EXPR:
    1099                 :     402540 :       {
    1100                 :     402540 :         bool save_val_only = wi->val_only;
    1101                 :            : 
    1102                 :     402540 :         wi->val_only = false;
    1103                 :     402540 :         wi->is_lhs = false;
    1104                 :     402540 :         wi->changed = false;
    1105                 :     402540 :         walk_tree (&TREE_OPERAND (t, 0), convert_nonlocal_reference_op, wi, 0);
    1106                 :     402540 :         wi->val_only = true;
    1107                 :            : 
    1108                 :     402540 :         if (wi->changed)
    1109                 :            :           {
    1110                 :       1786 :             tree save_context;
    1111                 :            : 
    1112                 :            :             /* If we changed anything, we might no longer be directly
    1113                 :            :                referencing a decl.  */
    1114                 :       1786 :             save_context = current_function_decl;
    1115                 :       1786 :             current_function_decl = info->context;
    1116                 :       1786 :             recompute_tree_invariant_for_addr_expr (t);
    1117                 :       1786 :             current_function_decl = save_context;
    1118                 :            : 
    1119                 :            :             /* If the callback converted the address argument in a context
    1120                 :            :                where we only accept variables (and min_invariant, presumably),
    1121                 :            :                then compute the address into a temporary.  */
    1122                 :       1786 :             if (save_val_only)
    1123                 :          0 :               *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
    1124                 :            :                                       t, &wi->gsi);
    1125                 :            :           }
    1126                 :            :       }
    1127                 :            :       break;
    1128                 :            : 
    1129                 :     752154 :     case REALPART_EXPR:
    1130                 :     752154 :     case IMAGPART_EXPR:
    1131                 :     752154 :     case COMPONENT_REF:
    1132                 :     752154 :     case ARRAY_REF:
    1133                 :     752154 :     case ARRAY_RANGE_REF:
    1134                 :     752154 :     case BIT_FIELD_REF:
    1135                 :            :       /* Go down this entire nest and just look at the final prefix and
    1136                 :            :          anything that describes the references.  Otherwise, we lose track
    1137                 :            :          of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
    1138                 :     752154 :       wi->val_only = true;
    1139                 :     752154 :       wi->is_lhs = false;
    1140                 :    2111820 :       for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
    1141                 :            :         {
    1142                 :    1359660 :           if (TREE_CODE (t) == COMPONENT_REF)
    1143                 :    1000680 :             walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op, wi,
    1144                 :            :                        NULL);
    1145                 :     358983 :           else if (TREE_CODE (t) == ARRAY_REF
    1146                 :     358983 :                    || TREE_CODE (t) == ARRAY_RANGE_REF)
    1147                 :            :             {
    1148                 :     358519 :               walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference_op,
    1149                 :            :                          wi, NULL);
    1150                 :     358519 :               walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op,
    1151                 :            :                          wi, NULL);
    1152                 :     358519 :               walk_tree (&TREE_OPERAND (t, 3), convert_nonlocal_reference_op,
    1153                 :            :                          wi, NULL);
    1154                 :            :             }
    1155                 :            :         }
    1156                 :     752154 :       wi->val_only = false;
    1157                 :     752154 :       walk_tree (tp, convert_nonlocal_reference_op, wi, NULL);
    1158                 :     752154 :       break;
    1159                 :            : 
    1160                 :        710 :     case VIEW_CONVERT_EXPR:
    1161                 :            :       /* Just request to look at the subtrees, leaving val_only and lhs
    1162                 :            :          untouched.  This might actually be for !val_only + lhs, in which
    1163                 :            :          case we don't want to force a replacement by a temporary.  */
    1164                 :        710 :       *walk_subtrees = 1;
    1165                 :        710 :       break;
    1166                 :            : 
    1167                 :    3199470 :     default:
    1168                 :    3199470 :       if (!IS_TYPE_OR_DECL_P (t))
    1169                 :            :         {
    1170                 :    2983840 :           *walk_subtrees = 1;
    1171                 :    2983840 :           wi->val_only = true;
    1172                 :    2983840 :           wi->is_lhs = false;
    1173                 :            :         }
    1174                 :            :       break;
    1175                 :            :     }
    1176                 :            : 
    1177                 :    7075800 :   return NULL_TREE;
    1178                 :            : }
    1179                 :            : 
    1180                 :            : static tree convert_nonlocal_reference_stmt (gimple_stmt_iterator *, bool *,
    1181                 :            :                                              struct walk_stmt_info *);
    1182                 :            : 
    1183                 :            : /* Helper for convert_nonlocal_references, rewrite all references to VAR
    1184                 :            :    and PARM_DECLs that belong to outer functions.  */
    1185                 :            : 
    1186                 :            : static bool
    1187                 :       3463 : convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
    1188                 :            : {
    1189                 :       3463 :   struct nesting_info *const info = (struct nesting_info *) wi->info;
    1190                 :       3463 :   bool need_chain = false, need_stmts = false;
    1191                 :       3463 :   tree clause, decl, *pdecl;
    1192                 :       3463 :   int dummy;
    1193                 :       3463 :   bitmap new_suppress;
    1194                 :            : 
    1195                 :       3463 :   new_suppress = BITMAP_GGC_ALLOC ();
    1196                 :       3463 :   bitmap_copy (new_suppress, info->suppress_expansion);
    1197                 :            : 
    1198                 :      21498 :   for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
    1199                 :            :     {
    1200                 :      18035 :       pdecl = NULL;
    1201                 :      18035 :       switch (OMP_CLAUSE_CODE (clause))
    1202                 :            :         {
    1203                 :        633 :         case OMP_CLAUSE_REDUCTION:
    1204                 :        633 :         case OMP_CLAUSE_IN_REDUCTION:
    1205                 :        633 :         case OMP_CLAUSE_TASK_REDUCTION:
    1206                 :        633 :           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
    1207                 :         36 :             need_stmts = true;
    1208                 :        633 :           if (TREE_CODE (OMP_CLAUSE_DECL (clause)) == MEM_REF)
    1209                 :            :             {
    1210                 :          6 :               pdecl = &TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0);
    1211                 :          6 :               if (TREE_CODE (*pdecl) == POINTER_PLUS_EXPR)
    1212                 :          0 :                 pdecl = &TREE_OPERAND (*pdecl, 0);
    1213                 :          6 :               if (TREE_CODE (*pdecl) == INDIRECT_REF
    1214                 :          6 :                   || TREE_CODE (*pdecl) == ADDR_EXPR)
    1215                 :          4 :                 pdecl = &TREE_OPERAND (*pdecl, 0);
    1216                 :            :             }
    1217                 :        633 :           goto do_decl_clause;
    1218                 :            : 
    1219                 :       1139 :         case OMP_CLAUSE_LASTPRIVATE:
    1220                 :       1139 :           if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
    1221                 :        260 :             need_stmts = true;
    1222                 :       1139 :           goto do_decl_clause;
    1223                 :            : 
    1224                 :        328 :         case OMP_CLAUSE_LINEAR:
    1225                 :        328 :           if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause))
    1226                 :         74 :             need_stmts = true;
    1227                 :        328 :           wi->val_only = true;
    1228                 :        328 :           wi->is_lhs = false;
    1229                 :        328 :           convert_nonlocal_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause),
    1230                 :            :                                          &dummy, wi);
    1231                 :        328 :           goto do_decl_clause;
    1232                 :            : 
    1233                 :       4102 :         case OMP_CLAUSE_PRIVATE:
    1234                 :       4102 :         case OMP_CLAUSE_FIRSTPRIVATE:
    1235                 :       4102 :         case OMP_CLAUSE_COPYPRIVATE:
    1236                 :       4102 :         case OMP_CLAUSE_SHARED:
    1237                 :       4102 :         case OMP_CLAUSE_TO_DECLARE:
    1238                 :       4102 :         case OMP_CLAUSE_LINK:
    1239                 :       4102 :         case OMP_CLAUSE_USE_DEVICE_PTR:
    1240                 :       4102 :         case OMP_CLAUSE_USE_DEVICE_ADDR:
    1241                 :       4102 :         case OMP_CLAUSE_IS_DEVICE_PTR:
    1242                 :       4102 :         do_decl_clause:
    1243                 :       2100 :           if (pdecl == NULL)
    1244                 :      13567 :             pdecl = &OMP_CLAUSE_DECL (clause);
    1245                 :      13573 :           decl = *pdecl;
    1246                 :      13573 :           if (VAR_P (decl)
    1247                 :      24497 :               && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
    1248                 :            :             break;
    1249                 :      13254 :           if (decl_function_context (decl) != info->context)
    1250                 :            :             {
    1251                 :       1144 :               if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_SHARED)
    1252                 :        353 :                 OMP_CLAUSE_SHARED_READONLY (clause) = 0;
    1253                 :       1144 :               bitmap_set_bit (new_suppress, DECL_UID (decl));
    1254                 :       1144 :               *pdecl = get_nonlocal_debug_decl (info, decl);
    1255                 :       1144 :               if (OMP_CLAUSE_CODE (clause) != OMP_CLAUSE_PRIVATE)
    1256                 :        950 :                 need_chain = true;
    1257                 :            :             }
    1258                 :            :           break;
    1259                 :            : 
    1260                 :        165 :         case OMP_CLAUSE_SCHEDULE:
    1261                 :        165 :           if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
    1262                 :            :             break;
    1263                 :            :           /* FALLTHRU */
    1264                 :       1341 :         case OMP_CLAUSE_FINAL:
    1265                 :       1341 :         case OMP_CLAUSE_IF:
    1266                 :       1341 :         case OMP_CLAUSE_NUM_THREADS:
    1267                 :       1341 :         case OMP_CLAUSE_DEPEND:
    1268                 :       1341 :         case OMP_CLAUSE_DEVICE:
    1269                 :       1341 :         case OMP_CLAUSE_NUM_TEAMS:
    1270                 :       1341 :         case OMP_CLAUSE_THREAD_LIMIT:
    1271                 :       1341 :         case OMP_CLAUSE_SAFELEN:
    1272                 :       1341 :         case OMP_CLAUSE_SIMDLEN:
    1273                 :       1341 :         case OMP_CLAUSE_PRIORITY:
    1274                 :       1341 :         case OMP_CLAUSE_GRAINSIZE:
    1275                 :       1341 :         case OMP_CLAUSE_NUM_TASKS:
    1276                 :       1341 :         case OMP_CLAUSE_HINT:
    1277                 :       1341 :         case OMP_CLAUSE_NUM_GANGS:
    1278                 :       1341 :         case OMP_CLAUSE_NUM_WORKERS:
    1279                 :       1341 :         case OMP_CLAUSE_VECTOR_LENGTH:
    1280                 :       1341 :         case OMP_CLAUSE_GANG:
    1281                 :       1341 :         case OMP_CLAUSE_WORKER:
    1282                 :       1341 :         case OMP_CLAUSE_VECTOR:
    1283                 :       1341 :         case OMP_CLAUSE_ASYNC:
    1284                 :       1341 :         case OMP_CLAUSE_WAIT:
    1285                 :            :           /* Several OpenACC clauses have optional arguments.  Check if they
    1286                 :            :              are present.  */
    1287                 :       1341 :           if (OMP_CLAUSE_OPERAND (clause, 0))
    1288                 :            :             {
    1289                 :       1169 :               wi->val_only = true;
    1290                 :       1169 :               wi->is_lhs = false;
    1291                 :       1169 :               convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
    1292                 :            :                                              &dummy, wi);
    1293                 :            :             }
    1294                 :            : 
    1295                 :            :           /* The gang clause accepts two arguments.  */
    1296                 :       1341 :           if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_GANG
    1297                 :       1341 :               && OMP_CLAUSE_GANG_STATIC_EXPR (clause))
    1298                 :            :             {
    1299                 :         28 :                 wi->val_only = true;
    1300                 :         28 :                 wi->is_lhs = false;
    1301                 :         28 :                 convert_nonlocal_reference_op
    1302                 :         28 :                   (&OMP_CLAUSE_GANG_STATIC_EXPR (clause), &dummy, wi);
    1303                 :            :             }
    1304                 :            :           break;
    1305                 :            : 
    1306                 :          7 :         case OMP_CLAUSE_DIST_SCHEDULE:
    1307                 :          7 :           if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause) != NULL)
    1308                 :            :             {
    1309                 :          7 :               wi->val_only = true;
    1310                 :          7 :               wi->is_lhs = false;
    1311                 :          7 :               convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
    1312                 :            :                                              &dummy, wi);
    1313                 :            :             }
    1314                 :            :           break;
    1315                 :            : 
    1316                 :       4219 :         case OMP_CLAUSE_MAP:
    1317                 :       4219 :         case OMP_CLAUSE_TO:
    1318                 :       4219 :         case OMP_CLAUSE_FROM:
    1319                 :       4219 :           if (OMP_CLAUSE_SIZE (clause))
    1320                 :            :             {
    1321                 :       4219 :               wi->val_only = true;
    1322                 :       4219 :               wi->is_lhs = false;
    1323                 :       4219 :               convert_nonlocal_reference_op (&OMP_CLAUSE_SIZE (clause),
    1324                 :            :                                              &dummy, wi);
    1325                 :            :             }
    1326                 :       4219 :           if (DECL_P (OMP_CLAUSE_DECL (clause)))
    1327                 :       2002 :             goto do_decl_clause;
    1328                 :       2217 :           wi->val_only = true;
    1329                 :       2217 :           wi->is_lhs = false;
    1330                 :       2217 :           walk_tree (&OMP_CLAUSE_DECL (clause), convert_nonlocal_reference_op,
    1331                 :            :                      wi, NULL);
    1332                 :       2217 :           break;
    1333                 :            : 
    1334                 :          6 :         case OMP_CLAUSE_ALIGNED:
    1335                 :          6 :           if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
    1336                 :            :             {
    1337                 :          6 :               wi->val_only = true;
    1338                 :          6 :               wi->is_lhs = false;
    1339                 :          6 :               convert_nonlocal_reference_op
    1340                 :          6 :                 (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause), &dummy, wi);
    1341                 :            :             }
    1342                 :            :           /* FALLTHRU */
    1343                 :          6 :         case OMP_CLAUSE_NONTEMPORAL:
    1344                 :            :           /* Like do_decl_clause, but don't add any suppression.  */
    1345                 :          6 :           decl = OMP_CLAUSE_DECL (clause);
    1346                 :          6 :           if (VAR_P (decl)
    1347                 :         12 :               && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
    1348                 :            :             break;
    1349                 :          6 :           if (decl_function_context (decl) != info->context)
    1350                 :            :             {
    1351                 :          6 :               OMP_CLAUSE_DECL (clause) = get_nonlocal_debug_decl (info, decl);
    1352                 :          6 :               need_chain = true;
    1353                 :            :             }
    1354                 :            :           break;
    1355                 :            : 
    1356                 :            :         case OMP_CLAUSE_NOWAIT:
    1357                 :            :         case OMP_CLAUSE_ORDERED:
    1358                 :            :         case OMP_CLAUSE_DEFAULT:
    1359                 :            :         case OMP_CLAUSE_COPYIN:
    1360                 :            :         case OMP_CLAUSE_COLLAPSE:
    1361                 :            :         case OMP_CLAUSE_TILE:
    1362                 :            :         case OMP_CLAUSE_UNTIED:
    1363                 :            :         case OMP_CLAUSE_MERGEABLE:
    1364                 :            :         case OMP_CLAUSE_PROC_BIND:
    1365                 :            :         case OMP_CLAUSE_NOGROUP:
    1366                 :            :         case OMP_CLAUSE_THREADS:
    1367                 :            :         case OMP_CLAUSE_SIMD:
    1368                 :            :         case OMP_CLAUSE_DEFAULTMAP:
    1369                 :            :         case OMP_CLAUSE_ORDER:
    1370                 :            :         case OMP_CLAUSE_SEQ:
    1371                 :            :         case OMP_CLAUSE_INDEPENDENT:
    1372                 :            :         case OMP_CLAUSE_AUTO:
    1373                 :            :         case OMP_CLAUSE_IF_PRESENT:
    1374                 :            :         case OMP_CLAUSE_FINALIZE:
    1375                 :            :         case OMP_CLAUSE__CONDTEMP_:
    1376                 :            :         case OMP_CLAUSE__SCANTEMP_:
    1377                 :            :           break;
    1378                 :            : 
    1379                 :            :           /* The following clause belongs to the OpenACC cache directive, which
    1380                 :            :              is discarded during gimplification.  */
    1381                 :          0 :         case OMP_CLAUSE__CACHE_:
    1382                 :            :           /* The following clauses are only allowed in the OpenMP declare simd
    1383                 :            :              directive, so not seen here.  */
    1384                 :          0 :         case OMP_CLAUSE_UNIFORM:
    1385                 :          0 :         case OMP_CLAUSE_INBRANCH:
    1386                 :          0 :         case OMP_CLAUSE_NOTINBRANCH:
    1387                 :            :           /* The following clauses are only allowed on OpenMP cancel and
    1388                 :            :              cancellation point directives, which at this point have already
    1389                 :            :              been lowered into a function call.  */
    1390                 :          0 :         case OMP_CLAUSE_FOR:
    1391                 :          0 :         case OMP_CLAUSE_PARALLEL:
    1392                 :          0 :         case OMP_CLAUSE_SECTIONS:
    1393                 :          0 :         case OMP_CLAUSE_TASKGROUP:
    1394                 :            :           /* The following clauses are only added during OMP lowering; nested
    1395                 :            :              function decomposition happens before that.  */
    1396                 :          0 :         case OMP_CLAUSE__LOOPTEMP_:
    1397                 :          0 :         case OMP_CLAUSE__REDUCTEMP_:
    1398                 :          0 :         case OMP_CLAUSE__SIMDUID_:
    1399                 :          0 :         case OMP_CLAUSE__GRIDDIM_:
    1400                 :          0 :         case OMP_CLAUSE__SIMT_:
    1401                 :            :           /* Anything else.  */
    1402                 :          0 :         default:
    1403                 :          0 :           gcc_unreachable ();
    1404                 :            :         }
    1405                 :            :     }
    1406                 :            : 
    1407                 :       3463 :   info->suppress_expansion = new_suppress;
    1408                 :            : 
    1409                 :       3463 :   if (need_stmts)
    1410                 :       1580 :     for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
    1411                 :       1285 :       switch (OMP_CLAUSE_CODE (clause))
    1412                 :            :         {
    1413                 :        102 :         case OMP_CLAUSE_REDUCTION:
    1414                 :        102 :         case OMP_CLAUSE_IN_REDUCTION:
    1415                 :        102 :         case OMP_CLAUSE_TASK_REDUCTION:
    1416                 :        102 :           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
    1417                 :            :             {
    1418                 :         36 :               tree old_context
    1419                 :         36 :                 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
    1420                 :         36 :               DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
    1421                 :         36 :                 = info->context;
    1422                 :         36 :               if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
    1423                 :          0 :                 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
    1424                 :          0 :                   = info->context;
    1425                 :         36 :               walk_body (convert_nonlocal_reference_stmt,
    1426                 :            :                          convert_nonlocal_reference_op, info,
    1427                 :         36 :                          &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
    1428                 :         36 :               walk_body (convert_nonlocal_reference_stmt,
    1429                 :            :                          convert_nonlocal_reference_op, info,
    1430                 :         36 :                          &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
    1431                 :         36 :               DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
    1432                 :         36 :                 = old_context;
    1433                 :         36 :               if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
    1434                 :          0 :                 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
    1435                 :          0 :                   = old_context;
    1436                 :            :             }
    1437                 :            :           break;
    1438                 :            : 
    1439                 :        420 :         case OMP_CLAUSE_LASTPRIVATE:
    1440                 :        420 :           walk_body (convert_nonlocal_reference_stmt,
    1441                 :            :                      convert_nonlocal_reference_op, info,
    1442                 :        420 :                      &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
    1443                 :        420 :           break;
    1444                 :            : 
    1445                 :        215 :         case OMP_CLAUSE_LINEAR:
    1446                 :        215 :           walk_body (convert_nonlocal_reference_stmt,
    1447                 :            :                      convert_nonlocal_reference_op, info,
    1448                 :        215 :                      &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause));
    1449                 :        215 :           break;
    1450                 :            : 
    1451                 :            :         default:
    1452                 :            :           break;
    1453                 :            :         }
    1454                 :            : 
    1455                 :       3463 :   return need_chain;
    1456                 :            : }
    1457                 :            : 
    1458                 :            : /* Create nonlocal debug decls for nonlocal VLA array bounds.  */
    1459                 :            : 
    1460                 :            : static void
    1461                 :          2 : note_nonlocal_vla_type (struct nesting_info *info, tree type)
    1462                 :            : {
    1463                 :          4 :   while (POINTER_TYPE_P (type) && !TYPE_NAME (type))
    1464                 :          1 :     type = TREE_TYPE (type);
    1465                 :            : 
    1466                 :          2 :   if (TYPE_NAME (type)
    1467                 :          2 :       && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
    1468                 :          4 :       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
    1469                 :          2 :     type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
    1470                 :            : 
    1471                 :          2 :   while (POINTER_TYPE_P (type)
    1472                 :          2 :          || TREE_CODE (type) == VECTOR_TYPE
    1473                 :          2 :          || TREE_CODE (type) == FUNCTION_TYPE
    1474                 :          4 :          || TREE_CODE (type) == METHOD_TYPE)
    1475                 :          0 :     type = TREE_TYPE (type);
    1476                 :            : 
    1477                 :          2 :   if (TREE_CODE (type) == ARRAY_TYPE)
    1478                 :            :     {
    1479                 :          1 :       tree domain, t;
    1480                 :            : 
    1481                 :          1 :       note_nonlocal_vla_type (info, TREE_TYPE (type));
    1482                 :          1 :       domain = TYPE_DOMAIN (type);
    1483                 :          1 :       if (domain)
    1484                 :            :         {
    1485                 :          1 :           t = TYPE_MIN_VALUE (domain);
    1486                 :          1 :           if (t && (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
    1487                 :          1 :               && decl_function_context (t) != info->context)
    1488                 :          0 :             get_nonlocal_debug_decl (info, t);
    1489                 :          1 :           t = TYPE_MAX_VALUE (domain);
    1490                 :          1 :           if (t && (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
    1491                 :          2 :               && decl_function_context (t) != info->context)
    1492                 :          1 :             get_nonlocal_debug_decl (info, t);
    1493                 :            :         }
    1494                 :            :     }
    1495                 :          2 : }
    1496                 :            : 
    1497                 :            : /* Callback for walk_gimple_stmt.  Rewrite all references to VAR and
    1498                 :            :    PARM_DECLs that belong to outer functions.  This handles statements
    1499                 :            :    that are not handled via the standard recursion done in
    1500                 :            :    walk_gimple_stmt.  STMT is the statement to examine, DATA is as in
    1501                 :            :    convert_nonlocal_reference_op.  Set *HANDLED_OPS_P to true if all the
    1502                 :            :    operands of STMT have been handled by this function.  */
    1503                 :            : 
    1504                 :            : static tree
    1505                 :    2618860 : convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
    1506                 :            :                                  struct walk_stmt_info *wi)
    1507                 :            : {
    1508                 :    2618860 :   struct nesting_info *info = (struct nesting_info *) wi->info;
    1509                 :    2618860 :   tree save_local_var_chain;
    1510                 :    2618860 :   bitmap save_suppress;
    1511                 :    2618860 :   gimple *stmt = gsi_stmt (*gsi);
    1512                 :            : 
    1513                 :    2618860 :   switch (gimple_code (stmt))
    1514                 :            :     {
    1515                 :      99201 :     case GIMPLE_GOTO:
    1516                 :            :       /* Don't walk non-local gotos for now.  */
    1517                 :      99201 :       if (TREE_CODE (gimple_goto_dest (stmt)) != LABEL_DECL)
    1518                 :            :         {
    1519                 :         74 :           wi->val_only = true;
    1520                 :         74 :           wi->is_lhs = false;
    1521                 :         74 :           *handled_ops_p = false;
    1522                 :         74 :           return NULL_TREE;
    1523                 :            :         }
    1524                 :            :       break;
    1525                 :            : 
    1526                 :         15 :     case GIMPLE_OMP_TEAMS:
    1527                 :         15 :       if (!gimple_omp_teams_host (as_a <gomp_teams *> (stmt)))
    1528                 :            :         {
    1529                 :          9 :           save_suppress = info->suppress_expansion;
    1530                 :          9 :           convert_nonlocal_omp_clauses (gimple_omp_teams_clauses_ptr (stmt),
    1531                 :            :                                         wi);
    1532                 :          9 :           walk_body (convert_nonlocal_reference_stmt,
    1533                 :            :                      convert_nonlocal_reference_op, info,
    1534                 :            :                      gimple_omp_body_ptr (stmt));
    1535                 :          9 :           info->suppress_expansion = save_suppress;
    1536                 :          9 :           break;
    1537                 :            :         }
    1538                 :            :       /* FALLTHRU */
    1539                 :            : 
    1540                 :       1134 :     case GIMPLE_OMP_PARALLEL:
    1541                 :       1134 :     case GIMPLE_OMP_TASK:
    1542                 :       1134 :       save_suppress = info->suppress_expansion;
    1543                 :       1134 :       if (convert_nonlocal_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
    1544                 :            :                                         wi))
    1545                 :            :         {
    1546                 :        147 :           tree c, decl;
    1547                 :        147 :           decl = get_chain_decl (info);
    1548                 :        147 :           c = build_omp_clause (gimple_location (stmt),
    1549                 :            :                                 OMP_CLAUSE_FIRSTPRIVATE);
    1550                 :        147 :           OMP_CLAUSE_DECL (c) = decl;
    1551                 :        147 :           OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
    1552                 :        147 :           gimple_omp_taskreg_set_clauses (stmt, c);
    1553                 :            :         }
    1554                 :            : 
    1555                 :       1134 :       save_local_var_chain = info->new_local_var_chain;
    1556                 :       1134 :       info->new_local_var_chain = NULL;
    1557                 :            : 
    1558                 :       1134 :       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
    1559                 :            :                  info, gimple_omp_body_ptr (stmt));
    1560                 :            : 
    1561                 :       1134 :       if (info->new_local_var_chain)
    1562                 :        111 :         declare_vars (info->new_local_var_chain,
    1563                 :            :                       gimple_seq_first_stmt (gimple_omp_body (stmt)),
    1564                 :            :                       false);
    1565                 :       1134 :       info->new_local_var_chain = save_local_var_chain;
    1566                 :       1134 :       info->suppress_expansion = save_suppress;
    1567                 :       1134 :       break;
    1568                 :            : 
    1569                 :       1194 :     case GIMPLE_OMP_FOR:
    1570                 :       1194 :       save_suppress = info->suppress_expansion;
    1571                 :       1194 :       convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
    1572                 :       1194 :       walk_gimple_omp_for (as_a <gomp_for *> (stmt),
    1573                 :            :                            convert_nonlocal_reference_stmt,
    1574                 :            :                            convert_nonlocal_reference_op, info);
    1575                 :       1194 :       walk_body (convert_nonlocal_reference_stmt,
    1576                 :            :                  convert_nonlocal_reference_op, info, gimple_omp_body_ptr (stmt));
    1577                 :       1194 :       info->suppress_expansion = save_suppress;
    1578                 :       1194 :       break;
    1579                 :            : 
    1580                 :         42 :     case GIMPLE_OMP_SECTIONS:
    1581                 :         42 :       save_suppress = info->suppress_expansion;
    1582                 :         42 :       convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
    1583                 :         42 :       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
    1584                 :            :                  info, gimple_omp_body_ptr (stmt));
    1585                 :         42 :       info->suppress_expansion = save_suppress;
    1586                 :         42 :       break;
    1587                 :            : 
    1588                 :        178 :     case GIMPLE_OMP_SINGLE:
    1589                 :        178 :       save_suppress = info->suppress_expansion;
    1590                 :        178 :       convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
    1591                 :        178 :       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
    1592                 :            :                  info, gimple_omp_body_ptr (stmt));
    1593                 :        178 :       info->suppress_expansion = save_suppress;
    1594                 :        178 :       break;
    1595                 :            : 
    1596                 :         32 :     case GIMPLE_OMP_TASKGROUP:
    1597                 :         32 :       save_suppress = info->suppress_expansion;
    1598                 :         32 :       convert_nonlocal_omp_clauses (gimple_omp_taskgroup_clauses_ptr (stmt), wi);
    1599                 :         32 :       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
    1600                 :            :                  info, gimple_omp_body_ptr (stmt));
    1601                 :         32 :       info->suppress_expansion = save_suppress;
    1602                 :         32 :       break;
    1603                 :            : 
    1604                 :        874 :     case GIMPLE_OMP_TARGET:
    1605                 :        874 :       if (!is_gimple_omp_offloaded (stmt))
    1606                 :            :         {
    1607                 :        338 :           save_suppress = info->suppress_expansion;
    1608                 :        338 :           convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt),
    1609                 :            :                                         wi);
    1610                 :        338 :           info->suppress_expansion = save_suppress;
    1611                 :        338 :           walk_body (convert_nonlocal_reference_stmt,
    1612                 :            :                      convert_nonlocal_reference_op, info,
    1613                 :            :                      gimple_omp_body_ptr (stmt));
    1614                 :        338 :           break;
    1615                 :            :         }
    1616                 :        536 :       save_suppress = info->suppress_expansion;
    1617                 :        536 :       if (convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt),
    1618                 :            :                                         wi))
    1619                 :            :         {
    1620                 :         55 :           tree c, decl;
    1621                 :         55 :           decl = get_chain_decl (info);
    1622                 :         55 :           c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP);
    1623                 :         55 :           OMP_CLAUSE_DECL (c) = decl;
    1624                 :         55 :           OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TO);
    1625                 :         55 :           OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
    1626                 :         55 :           OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
    1627                 :         55 :           gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt), c);
    1628                 :            :         }
    1629                 :            : 
    1630                 :        536 :       save_local_var_chain = info->new_local_var_chain;
    1631                 :        536 :       info->new_local_var_chain = NULL;
    1632                 :            : 
    1633                 :        536 :       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
    1634                 :            :                  info, gimple_omp_body_ptr (stmt));
    1635                 :            : 
    1636                 :        536 :       if (info->new_local_var_chain)
    1637                 :        216 :         declare_vars (info->new_local_var_chain,
    1638                 :            :                       gimple_seq_first_stmt (gimple_omp_body (stmt)),
    1639                 :            :                       false);
    1640                 :        536 :       info->new_local_var_chain = save_local_var_chain;
    1641                 :        536 :       info->suppress_expansion = save_suppress;
    1642                 :        536 :       break;
    1643                 :            : 
    1644                 :        146 :     case GIMPLE_OMP_SECTION:
    1645                 :        146 :     case GIMPLE_OMP_MASTER:
    1646                 :        146 :     case GIMPLE_OMP_ORDERED:
    1647                 :        146 :     case GIMPLE_OMP_SCAN:
    1648                 :        146 :       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
    1649                 :            :                  info, gimple_omp_body_ptr (stmt));
    1650                 :        146 :       break;
    1651                 :            : 
    1652                 :     135361 :     case GIMPLE_BIND:
    1653                 :     135361 :       {
    1654                 :     135361 :       gbind *bind_stmt = as_a <gbind *> (stmt);
    1655                 :            : 
    1656                 :     595580 :       for (tree var = gimple_bind_vars (bind_stmt); var; var = DECL_CHAIN (var))
    1657                 :     460219 :         if (TREE_CODE (var) == NAMELIST_DECL)
    1658                 :            :           {
    1659                 :            :             /* Adjust decls mentioned in NAMELIST_DECL.  */
    1660                 :        119 :             tree decls = NAMELIST_DECL_ASSOCIATED_DECL (var);
    1661                 :        119 :             tree decl;
    1662                 :        119 :             unsigned int i;
    1663                 :            : 
    1664                 :       1568 :             FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls), i, decl)
    1665                 :            :               {
    1666                 :        753 :                 if (VAR_P (decl)
    1667                 :        935 :                     && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
    1668                 :         88 :                   continue;
    1669                 :        577 :                 if (decl_function_context (decl) != info->context)
    1670                 :          7 :                   CONSTRUCTOR_ELT (decls, i)->value
    1671                 :          7 :                     = get_nonlocal_debug_decl (info, decl);
    1672                 :            :               }
    1673                 :            :           }
    1674                 :            : 
    1675                 :     135361 :       *handled_ops_p = false;
    1676                 :     135361 :       return NULL_TREE;
    1677                 :            :       }
    1678                 :     161869 :     case GIMPLE_COND:
    1679                 :     161869 :       wi->val_only = true;
    1680                 :     161869 :       wi->is_lhs = false;
    1681                 :     161869 :       *handled_ops_p = false;
    1682                 :     161869 :       return NULL_TREE;
    1683                 :            : 
    1684                 :    1500080 :     case GIMPLE_ASSIGN:
    1685                 :    1500080 :       if (gimple_clobber_p (stmt))
    1686                 :            :         {
    1687                 :      67056 :           tree lhs = gimple_assign_lhs (stmt);
    1688                 :      67056 :           if (DECL_P (lhs)
    1689                 :     134092 :               && !(TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
    1690                 :     134102 :               && decl_function_context (lhs) != info->context)
    1691                 :            :             {
    1692                 :         11 :               gsi_replace (gsi, gimple_build_nop (), true);
    1693                 :         11 :               break;
    1694                 :            :             }
    1695                 :            :         }
    1696                 :    1500070 :       *handled_ops_p = false;
    1697                 :    1500070 :       return NULL_TREE;
    1698                 :            : 
    1699                 :     718740 :     default:
    1700                 :            :       /* For every other statement that we are not interested in
    1701                 :            :          handling here, let the walker traverse the operands.  */
    1702                 :     718740 :       *handled_ops_p = false;
    1703                 :     718740 :       return NULL_TREE;
    1704                 :            :     }
    1705                 :            : 
    1706                 :            :   /* We have handled all of STMT operands, no need to traverse the operands.  */
    1707                 :     102747 :   *handled_ops_p = true;
    1708                 :     102747 :   return NULL_TREE;
    1709                 :            : }
    1710                 :            : 
    1711                 :            : 
    1712                 :            : /* A subroutine of convert_local_reference.  Create a local variable
    1713                 :            :    in the parent function with DECL_VALUE_EXPR set to reference the
    1714                 :            :    field in FRAME.  This is used both for debug info and in OMP
    1715                 :            :    lowering.  */
    1716                 :            : 
    1717                 :            : static tree
    1718                 :        190 : get_local_debug_decl (struct nesting_info *info, tree decl, tree field)
    1719                 :            : {
    1720                 :        190 :   tree x, new_decl;
    1721                 :            : 
    1722                 :        190 :   tree *slot = &info->var_map->get_or_insert (decl);
    1723                 :        190 :   if (*slot)
    1724                 :            :     return *slot;
    1725                 :            : 
    1726                 :            :   /* Make sure frame_decl gets created.  */
    1727                 :         57 :   (void) get_frame_type (info);
    1728                 :         57 :   x = info->frame_decl;
    1729                 :         57 :   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
    1730                 :            : 
    1731                 :        228 :   new_decl = build_decl (DECL_SOURCE_LOCATION (decl),
    1732                 :         57 :                          VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
    1733                 :         57 :   DECL_CONTEXT (new_decl) = info->context;
    1734                 :         57 :   DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
    1735                 :         57 :   DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
    1736                 :         57 :   TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
    1737                 :         57 :   TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
    1738                 :         57 :   TREE_READONLY (new_decl) = TREE_READONLY (decl);
    1739                 :         57 :   TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
    1740                 :         57 :   DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
    1741                 :         57 :   if ((TREE_CODE (decl) == PARM_DECL
    1742                 :         57 :        || TREE_CODE (decl) == RESULT_DECL
    1743                 :         55 :        || VAR_P (decl))
    1744                 :        114 :       && DECL_BY_REFERENCE (decl))
    1745                 :          0 :     DECL_BY_REFERENCE (new_decl) = 1;
    1746                 :            : 
    1747                 :         57 :   SET_DECL_VALUE_EXPR (new_decl, x);
    1748                 :         57 :   DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
    1749                 :         57 :   *slot = new_decl;
    1750                 :            : 
    1751                 :         57 :   DECL_CHAIN (new_decl) = info->debug_var_chain;
    1752                 :         57 :   info->debug_var_chain = new_decl;
    1753                 :            : 
    1754                 :            :   /* Do not emit debug info twice.  */
    1755                 :         57 :   DECL_IGNORED_P (decl) = 1;
    1756                 :            : 
    1757                 :         57 :   return new_decl;
    1758                 :            : }
    1759                 :            : 
    1760                 :            : 
    1761                 :            : /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
    1762                 :            :    and PARM_DECLs that were referenced by inner nested functions.
    1763                 :            :    The rewrite will be a structure reference to the local frame variable.  */
    1764                 :            : 
    1765                 :            : static bool convert_local_omp_clauses (tree *, struct walk_stmt_info *);
    1766                 :            : 
    1767                 :            : static tree
    1768                 :    7041780 : convert_local_reference_op (tree *tp, int *walk_subtrees, void *data)
    1769                 :            : {
    1770                 :    7041780 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
    1771                 :    7041780 :   struct nesting_info *const info = (struct nesting_info *) wi->info;
    1772                 :    7041780 :   tree t = *tp, field, x;
    1773                 :    7041780 :   bool save_val_only;
    1774                 :            : 
    1775                 :    7041780 :   *walk_subtrees = 0;
    1776                 :    7041780 :   switch (TREE_CODE (t))
    1777                 :            :     {
    1778                 :    1833540 :     case VAR_DECL:
    1779                 :            :       /* Non-automatic variables are never processed.  */
    1780                 :    3581640 :       if (TREE_STATIC (t) || DECL_EXTERNAL (t))
    1781                 :            :         break;
    1782                 :            :       /* FALLTHRU */
    1783                 :            : 
    1784                 :    1853600 :     case PARM_DECL:
    1785                 :    1853600 :       if (t != info->frame_decl && decl_function_context (t) == info->context)
    1786                 :            :         {
    1787                 :            :           /* If we copied a pointer to the frame, then the original decl
    1788                 :            :              is used unchanged in the parent function.  */
    1789                 :    1851340 :           if (use_pointer_in_frame (t))
    1790                 :            :             break;
    1791                 :            : 
    1792                 :            :           /* No need to transform anything if no child references the
    1793                 :            :              variable.  */
    1794                 :    1851220 :           field = lookup_field_for_decl (info, t, NO_INSERT);
    1795                 :    1851220 :           if (!field)
    1796                 :            :             break;
    1797                 :      14625 :           wi->changed = true;
    1798                 :            : 
    1799                 :      14625 :           if (bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
    1800                 :        114 :             x = get_local_debug_decl (info, t, field);
    1801                 :            :           else
    1802                 :      14511 :             x = get_frame_field (info, info->context, field, &wi->gsi);
    1803                 :            : 
    1804                 :      14625 :           if (wi->val_only)
    1805                 :            :             {
    1806                 :       7322 :               if (wi->is_lhs)
    1807                 :       2280 :                 x = save_tmp_var (info, x, &wi->gsi);
    1808                 :            :               else
    1809                 :       5042 :                 x = init_tmp_var (info, x, &wi->gsi);
    1810                 :            :             }
    1811                 :            : 
    1812                 :      14625 :           *tp = x;
    1813                 :            :         }
    1814                 :            :       break;
    1815                 :            : 
    1816                 :     402540 :     case ADDR_EXPR:
    1817                 :     402540 :       save_val_only = wi->val_only;
    1818                 :     402540 :       wi->val_only = false;
    1819                 :     402540 :       wi->is_lhs = false;
    1820                 :     402540 :       wi->changed = false;
    1821                 :     402540 :       walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op, wi, NULL);
    1822                 :     402540 :       wi->val_only = save_val_only;
    1823                 :            : 
    1824                 :            :       /* If we converted anything ... */
    1825                 :     402540 :       if (wi->changed)
    1826                 :            :         {
    1827                 :       1841 :           tree save_context;
    1828                 :            : 
    1829                 :            :           /* Then the frame decl is now addressable.  */
    1830                 :       1841 :           TREE_ADDRESSABLE (info->frame_decl) = 1;
    1831                 :            : 
    1832                 :       1841 :           save_context = current_function_decl;
    1833                 :       1841 :           current_function_decl = info->context;
    1834                 :       1841 :           recompute_tree_invariant_for_addr_expr (t);
    1835                 :       1841 :           current_function_decl = save_context;
    1836                 :            : 
    1837                 :            :           /* If we are in a context where we only accept values, then
    1838                 :            :              compute the address into a temporary.  */
    1839                 :       1841 :           if (save_val_only)
    1840                 :       1409 :             *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
    1841                 :            :                                     t, &wi->gsi);
    1842                 :            :         }
    1843                 :            :       break;
    1844                 :            : 
    1845                 :     761098 :     case REALPART_EXPR:
    1846                 :     761098 :     case IMAGPART_EXPR:
    1847                 :     761098 :     case COMPONENT_REF:
    1848                 :     761098 :     case ARRAY_REF:
    1849                 :     761098 :     case ARRAY_RANGE_REF:
    1850                 :     761098 :     case BIT_FIELD_REF:
    1851                 :            :       /* Go down this entire nest and just look at the final prefix and
    1852                 :            :          anything that describes the references.  Otherwise, we lose track
    1853                 :            :          of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
    1854                 :     761098 :       save_val_only = wi->val_only;
    1855                 :     761098 :       wi->val_only = true;
    1856                 :     761098 :       wi->is_lhs = false;
    1857                 :    2135190 :       for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
    1858                 :            :         {
    1859                 :    1374090 :           if (TREE_CODE (t) == COMPONENT_REF)
    1860                 :    1015110 :             walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
    1861                 :            :                        NULL);
    1862                 :     358983 :           else if (TREE_CODE (t) == ARRAY_REF
    1863                 :     358983 :                    || TREE_CODE (t) == ARRAY_RANGE_REF)
    1864                 :            :             {
    1865                 :     358519 :               walk_tree (&TREE_OPERAND (t, 1), convert_local_reference_op, wi,
    1866                 :            :                          NULL);
    1867                 :     358519 :               walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
    1868                 :            :                          NULL);
    1869                 :     358519 :               walk_tree (&TREE_OPERAND (t, 3), convert_local_reference_op, wi,
    1870                 :            :                          NULL);
    1871                 :            :             }
    1872                 :            :         }
    1873                 :     761098 :       wi->val_only = false;
    1874                 :     761098 :       walk_tree (tp, convert_local_reference_op, wi, NULL);
    1875                 :     761098 :       wi->val_only = save_val_only;
    1876                 :     761098 :       break;
    1877                 :            : 
    1878                 :     178805 :     case MEM_REF:
    1879                 :     178805 :       save_val_only = wi->val_only;
    1880                 :     178805 :       wi->val_only = true;
    1881                 :     178805 :       wi->is_lhs = false;
    1882                 :     178805 :       walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op,
    1883                 :            :                  wi, NULL);
    1884                 :            :       /* We need to re-fold the MEM_REF as component references as
    1885                 :            :          part of a ADDR_EXPR address are not allowed.  But we cannot
    1886                 :            :          fold here, as the chain record type is not yet finalized.  */
    1887                 :     178805 :       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
    1888                 :     178805 :           && !DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
    1889                 :          0 :         info->mem_refs->add (tp);
    1890                 :     178805 :       wi->val_only = save_val_only;
    1891                 :     178805 :       break;
    1892                 :            : 
    1893                 :        710 :     case VIEW_CONVERT_EXPR:
    1894                 :            :       /* Just request to look at the subtrees, leaving val_only and lhs
    1895                 :            :          untouched.  This might actually be for !val_only + lhs, in which
    1896                 :            :          case we don't want to force a replacement by a temporary.  */
    1897                 :        710 :       *walk_subtrees = 1;
    1898                 :        710 :       break;
    1899                 :            : 
    1900                 :    3759430 :     default:
    1901                 :    3759430 :       if (!IS_TYPE_OR_DECL_P (t))
    1902                 :            :         {
    1903                 :    2649320 :           *walk_subtrees = 1;
    1904                 :    2649320 :           wi->val_only = true;
    1905                 :    2649320 :           wi->is_lhs = false;
    1906                 :            :         }
    1907                 :            :       break;
    1908                 :            :     }
    1909                 :            : 
    1910                 :    7041780 :   return NULL_TREE;
    1911                 :            : }
    1912                 :            : 
    1913                 :            : static tree convert_local_reference_stmt (gimple_stmt_iterator *, bool *,
    1914                 :            :                                           struct walk_stmt_info *);
    1915                 :            : 
    1916                 :            : /* Helper for convert_local_reference.  Convert all the references in
    1917                 :            :    the chain of clauses at *PCLAUSES.  WI is as in convert_local_reference.  */
    1918                 :            : 
    1919                 :            : static bool
    1920                 :       3463 : convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
    1921                 :            : {
    1922                 :       3463 :   struct nesting_info *const info = (struct nesting_info *) wi->info;
    1923                 :       3463 :   bool need_frame = false, need_stmts = false;
    1924                 :       3463 :   tree clause, decl, *pdecl;
    1925                 :       3463 :   int dummy;
    1926                 :       3463 :   bitmap new_suppress;
    1927                 :            : 
    1928                 :       3463 :   new_suppress = BITMAP_GGC_ALLOC ();
    1929                 :       3463 :   bitmap_copy (new_suppress, info->suppress_expansion);
    1930                 :            : 
    1931                 :      21700 :   for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
    1932                 :            :     {
    1933                 :      18237 :       pdecl = NULL;
    1934                 :      18237 :       switch (OMP_CLAUSE_CODE (clause))
    1935                 :            :         {
    1936                 :        633 :         case OMP_CLAUSE_REDUCTION:
    1937                 :        633 :         case OMP_CLAUSE_IN_REDUCTION:
    1938                 :        633 :         case OMP_CLAUSE_TASK_REDUCTION:
    1939                 :        633 :           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
    1940                 :         36 :             need_stmts = true;
    1941                 :        633 :           if (TREE_CODE (OMP_CLAUSE_DECL (clause)) == MEM_REF)
    1942                 :            :             {
    1943                 :          6 :               pdecl = &TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0);
    1944                 :          6 :               if (TREE_CODE (*pdecl) == POINTER_PLUS_EXPR)
    1945                 :          0 :                 pdecl = &TREE_OPERAND (*pdecl, 0);
    1946                 :          6 :               if (TREE_CODE (*pdecl) == INDIRECT_REF
    1947                 :          6 :                   || TREE_CODE (*pdecl) == ADDR_EXPR)
    1948                 :          4 :                 pdecl = &TREE_OPERAND (*pdecl, 0);
    1949                 :            :             }
    1950                 :        633 :           goto do_decl_clause;
    1951                 :            : 
    1952                 :       1139 :         case OMP_CLAUSE_LASTPRIVATE:
    1953                 :       1139 :           if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
    1954                 :        260 :             need_stmts = true;
    1955                 :       1139 :           goto do_decl_clause;
    1956                 :            : 
    1957                 :        328 :         case OMP_CLAUSE_LINEAR:
    1958                 :        328 :           if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause))
    1959                 :         74 :             need_stmts = true;
    1960                 :        328 :           wi->val_only = true;
    1961                 :        328 :           wi->is_lhs = false;
    1962                 :        328 :           convert_local_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause), &dummy,
    1963                 :            :                                       wi);
    1964                 :        328 :           goto do_decl_clause;
    1965                 :            : 
    1966                 :       4157 :         case OMP_CLAUSE_PRIVATE:
    1967                 :       4157 :         case OMP_CLAUSE_FIRSTPRIVATE:
    1968                 :       4157 :         case OMP_CLAUSE_COPYPRIVATE:
    1969                 :       4157 :         case OMP_CLAUSE_SHARED:
    1970                 :       4157 :         case OMP_CLAUSE_TO_DECLARE:
    1971                 :       4157 :         case OMP_CLAUSE_LINK:
    1972                 :       4157 :         case OMP_CLAUSE_USE_DEVICE_PTR:
    1973                 :       4157 :         case OMP_CLAUSE_USE_DEVICE_ADDR:
    1974                 :       4157 :         case OMP_CLAUSE_IS_DEVICE_PTR:
    1975                 :       4157 :         do_decl_clause:
    1976                 :       2100 :           if (pdecl == NULL)
    1977                 :      13769 :             pdecl = &OMP_CLAUSE_DECL (clause);
    1978                 :      13775 :           decl = *pdecl;
    1979                 :      13775 :           if (VAR_P (decl)
    1980                 :      24736 :               && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
    1981                 :            :             break;
    1982                 :      13456 :           if (decl_function_context (decl) == info->context
    1983                 :      13456 :               && !use_pointer_in_frame (decl))
    1984                 :            :             {
    1985                 :      13330 :               tree field = lookup_field_for_decl (info, decl, NO_INSERT);
    1986                 :      13330 :               if (field)
    1987                 :            :                 {
    1988                 :         74 :                   if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_SHARED)
    1989                 :         34 :                     OMP_CLAUSE_SHARED_READONLY (clause) = 0;
    1990                 :         74 :                   bitmap_set_bit (new_suppress, DECL_UID (decl));
    1991                 :         74 :                   *pdecl = get_local_debug_decl (info, decl, field);
    1992                 :         74 :                   need_frame = true;
    1993                 :            :                 }
    1994                 :            :             }
    1995                 :            :           break;
    1996                 :            : 
    1997                 :        165 :         case OMP_CLAUSE_SCHEDULE:
    1998                 :        165 :           if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
    1999                 :            :             break;
    2000                 :            :           /* FALLTHRU */
    2001                 :       1341 :         case OMP_CLAUSE_FINAL:
    2002                 :       1341 :         case OMP_CLAUSE_IF:
    2003                 :       1341 :         case OMP_CLAUSE_NUM_THREADS:
    2004                 :       1341 :         case OMP_CLAUSE_DEPEND:
    2005                 :       1341 :         case OMP_CLAUSE_DEVICE:
    2006                 :       1341 :         case OMP_CLAUSE_NUM_TEAMS:
    2007                 :       1341 :         case OMP_CLAUSE_THREAD_LIMIT:
    2008                 :       1341 :         case OMP_CLAUSE_SAFELEN:
    2009                 :       1341 :         case OMP_CLAUSE_SIMDLEN:
    2010                 :       1341 :         case OMP_CLAUSE_PRIORITY:
    2011                 :       1341 :         case OMP_CLAUSE_GRAINSIZE:
    2012                 :       1341 :         case OMP_CLAUSE_NUM_TASKS:
    2013                 :       1341 :         case OMP_CLAUSE_HINT:
    2014                 :       1341 :         case OMP_CLAUSE_NUM_GANGS:
    2015                 :       1341 :         case OMP_CLAUSE_NUM_WORKERS:
    2016                 :       1341 :         case OMP_CLAUSE_VECTOR_LENGTH:
    2017                 :       1341 :         case OMP_CLAUSE_GANG:
    2018                 :       1341 :         case OMP_CLAUSE_WORKER:
    2019                 :       1341 :         case OMP_CLAUSE_VECTOR:
    2020                 :       1341 :         case OMP_CLAUSE_ASYNC:
    2021                 :       1341 :         case OMP_CLAUSE_WAIT:
    2022                 :            :           /* Several OpenACC clauses have optional arguments.  Check if they
    2023                 :            :              are present.  */
    2024                 :       1341 :           if (OMP_CLAUSE_OPERAND (clause, 0))
    2025                 :            :             {
    2026                 :       1169 :               wi->val_only = true;
    2027                 :       1169 :               wi->is_lhs = false;
    2028                 :       1169 :               convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
    2029                 :            :                                           &dummy, wi);
    2030                 :            :             }
    2031                 :            : 
    2032                 :            :           /* The gang clause accepts two arguments.  */
    2033                 :       1341 :           if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_GANG
    2034                 :       1341 :               && OMP_CLAUSE_GANG_STATIC_EXPR (clause))
    2035                 :            :             {
    2036                 :         28 :                 wi->val_only = true;
    2037                 :         28 :                 wi->is_lhs = false;
    2038                 :         28 :                 convert_nonlocal_reference_op
    2039                 :         28 :                   (&OMP_CLAUSE_GANG_STATIC_EXPR (clause), &dummy, wi);
    2040                 :            :             }
    2041                 :            :           break;
    2042                 :            : 
    2043                 :          7 :         case OMP_CLAUSE_DIST_SCHEDULE:
    2044                 :          7 :           if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause) != NULL)
    2045                 :            :             {
    2046                 :          7 :               wi->val_only = true;
    2047                 :          7 :               wi->is_lhs = false;
    2048                 :          7 :               convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
    2049                 :            :                                           &dummy, wi);
    2050                 :            :             }
    2051                 :            :           break;
    2052                 :            : 
    2053                 :       4274 :         case OMP_CLAUSE_MAP:
    2054                 :       4274 :         case OMP_CLAUSE_TO:
    2055                 :       4274 :         case OMP_CLAUSE_FROM:
    2056                 :       4274 :           if (OMP_CLAUSE_SIZE (clause))
    2057                 :            :             {
    2058                 :       4274 :               wi->val_only = true;
    2059                 :       4274 :               wi->is_lhs = false;
    2060                 :       4274 :               convert_local_reference_op (&OMP_CLAUSE_SIZE (clause),
    2061                 :            :                                           &dummy, wi);
    2062                 :            :             }
    2063                 :       4274 :           if (DECL_P (OMP_CLAUSE_DECL (clause)))
    2064                 :       2057 :             goto do_decl_clause;
    2065                 :       2217 :           wi->val_only = true;
    2066                 :       2217 :           wi->is_lhs = false;
    2067                 :       2217 :           walk_tree (&OMP_CLAUSE_DECL (clause), convert_local_reference_op,
    2068                 :            :                      wi, NULL);
    2069                 :       2217 :           break;
    2070                 :            : 
    2071                 :          6 :         case OMP_CLAUSE_ALIGNED:
    2072                 :          6 :           if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
    2073                 :            :             {
    2074                 :          6 :               wi->val_only = true;
    2075                 :          6 :               wi->is_lhs = false;
    2076                 :          6 :               convert_local_reference_op
    2077                 :          6 :                 (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause), &dummy, wi);
    2078                 :            :             }
    2079                 :            :           /* FALLTHRU */
    2080                 :          6 :         case OMP_CLAUSE_NONTEMPORAL:
    2081                 :            :           /* Like do_decl_clause, but don't add any suppression.  */
    2082                 :          6 :           decl = OMP_CLAUSE_DECL (clause);
    2083                 :          6 :           if (VAR_P (decl)
    2084                 :         12 :               && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
    2085                 :            :             break;
    2086                 :          6 :           if (decl_function_context (decl) == info->context
    2087                 :          6 :               && !use_pointer_in_frame (decl))
    2088                 :            :             {
    2089                 :          6 :               tree field = lookup_field_for_decl (info, decl, NO_INSERT);
    2090                 :          6 :               if (field)
    2091                 :            :                 {
    2092                 :          0 :                   OMP_CLAUSE_DECL (clause)
    2093                 :          0 :                     = get_local_debug_decl (info, decl, field);
    2094                 :          0 :                   need_frame = true;
    2095                 :            :                 }
    2096                 :            :             }
    2097                 :            :           break;
    2098                 :            : 
    2099                 :            :         case OMP_CLAUSE_NOWAIT:
    2100                 :            :         case OMP_CLAUSE_ORDERED:
    2101                 :            :         case OMP_CLAUSE_DEFAULT:
    2102                 :            :         case OMP_CLAUSE_COPYIN:
    2103                 :            :         case OMP_CLAUSE_COLLAPSE:
    2104                 :            :         case OMP_CLAUSE_TILE:
    2105                 :            :         case OMP_CLAUSE_UNTIED:
    2106                 :            :         case OMP_CLAUSE_MERGEABLE:
    2107                 :            :         case OMP_CLAUSE_PROC_BIND:
    2108                 :            :         case OMP_CLAUSE_NOGROUP:
    2109                 :            :         case OMP_CLAUSE_THREADS:
    2110                 :            :         case OMP_CLAUSE_SIMD:
    2111                 :            :         case OMP_CLAUSE_DEFAULTMAP:
    2112                 :            :         case OMP_CLAUSE_ORDER:
    2113                 :            :         case OMP_CLAUSE_SEQ:
    2114                 :            :         case OMP_CLAUSE_INDEPENDENT:
    2115                 :            :         case OMP_CLAUSE_AUTO:
    2116                 :            :         case OMP_CLAUSE_IF_PRESENT:
    2117                 :            :         case OMP_CLAUSE_FINALIZE:
    2118                 :            :         case OMP_CLAUSE__CONDTEMP_:
    2119                 :            :         case OMP_CLAUSE__SCANTEMP_:
    2120                 :            :           break;
    2121                 :            : 
    2122                 :            :           /* The following clause belongs to the OpenACC cache directive, which
    2123                 :            :              is discarded during gimplification.  */
    2124                 :          0 :         case OMP_CLAUSE__CACHE_:
    2125                 :            :           /* The following clauses are only allowed in the OpenMP declare simd
    2126                 :            :              directive, so not seen here.  */
    2127                 :          0 :         case OMP_CLAUSE_UNIFORM:
    2128                 :          0 :         case OMP_CLAUSE_INBRANCH:
    2129                 :          0 :         case OMP_CLAUSE_NOTINBRANCH:
    2130                 :            :           /* The following clauses are only allowed on OpenMP cancel and
    2131                 :            :              cancellation point directives, which at this point have already
    2132                 :            :              been lowered into a function call.  */
    2133                 :          0 :         case OMP_CLAUSE_FOR:
    2134                 :          0 :         case OMP_CLAUSE_PARALLEL:
    2135                 :          0 :         case OMP_CLAUSE_SECTIONS:
    2136                 :          0 :         case OMP_CLAUSE_TASKGROUP:
    2137                 :            :           /* The following clauses are only added during OMP lowering; nested
    2138                 :            :              function decomposition happens before that.  */
    2139                 :          0 :         case OMP_CLAUSE__LOOPTEMP_:
    2140                 :          0 :         case OMP_CLAUSE__REDUCTEMP_:
    2141                 :          0 :         case OMP_CLAUSE__SIMDUID_:
    2142                 :          0 :         case OMP_CLAUSE__GRIDDIM_:
    2143                 :          0 :         case OMP_CLAUSE__SIMT_:
    2144                 :            :           /* Anything else.  */
    2145                 :          0 :         default:
    2146                 :          0 :           gcc_unreachable ();
    2147                 :            :         }
    2148                 :            :     }
    2149                 :            : 
    2150                 :       3463 :   info->suppress_expansion = new_suppress;
    2151                 :            : 
    2152                 :       3463 :   if (need_stmts)
    2153                 :       1586 :     for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
    2154                 :       1291 :       switch (OMP_CLAUSE_CODE (clause))
    2155                 :            :         {
    2156                 :        102 :         case OMP_CLAUSE_REDUCTION:
    2157                 :        102 :         case OMP_CLAUSE_IN_REDUCTION:
    2158                 :        102 :         case OMP_CLAUSE_TASK_REDUCTION:
    2159                 :        102 :           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
    2160                 :            :             {
    2161                 :         36 :               tree old_context
    2162                 :         36 :                 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
    2163                 :         36 :               DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
    2164                 :         36 :                 = info->context;
    2165                 :         36 :               if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
    2166                 :          0 :                 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
    2167                 :          0 :                   = info->context;
    2168                 :         36 :               walk_body (convert_local_reference_stmt,
    2169                 :            :                          convert_local_reference_op, info,
    2170                 :         36 :                          &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
    2171                 :         36 :               walk_body (convert_local_reference_stmt,
    2172                 :            :                          convert_local_reference_op, info,
    2173                 :         36 :                          &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
    2174                 :         36 :               DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
    2175                 :         36 :                 = old_context;
    2176                 :         36 :               if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
    2177                 :          0 :                 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
    2178                 :          0 :                   = old_context;
    2179                 :            :             }
    2180                 :            :           break;
    2181                 :            : 
    2182                 :        420 :         case OMP_CLAUSE_LASTPRIVATE:
    2183                 :        420 :           walk_body (convert_local_reference_stmt,
    2184                 :            :                      convert_local_reference_op, info,
    2185                 :        420 :                      &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
    2186                 :        420 :           break;
    2187                 :            : 
    2188                 :        215 :         case OMP_CLAUSE_LINEAR:
    2189                 :        215 :           walk_body (convert_local_reference_stmt,
    2190                 :            :                      convert_local_reference_op, info,
    2191                 :        215 :                      &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause));
    2192                 :        215 :           break;
    2193                 :            : 
    2194                 :            :         default:
    2195                 :            :           break;
    2196                 :            :         }
    2197                 :            : 
    2198                 :       3463 :   return need_frame;
    2199                 :            : }
    2200                 :            : 
    2201                 :            : 
    2202                 :            : /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
    2203                 :            :    and PARM_DECLs that were referenced by inner nested functions.
    2204                 :            :    The rewrite will be a structure reference to the local frame variable.  */
    2205                 :            : 
    2206                 :            : static tree
    2207                 :    2626310 : convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
    2208                 :            :                               struct walk_stmt_info *wi)
    2209                 :            : {
    2210                 :    2626310 :   struct nesting_info *info = (struct nesting_info *) wi->info;
    2211                 :    2626310 :   tree save_local_var_chain;
    2212                 :    2626310 :   bitmap save_suppress;
    2213                 :    2626310 :   char save_static_chain_added;
    2214                 :    2626310 :   bool frame_decl_added;
    2215                 :    2626310 :   gimple *stmt = gsi_stmt (*gsi);
    2216                 :            : 
    2217                 :    2626310 :   switch (gimple_code (stmt))
    2218                 :            :     {
    2219                 :         15 :     case GIMPLE_OMP_TEAMS:
    2220                 :         15 :       if (!gimple_omp_teams_host (as_a <gomp_teams *> (stmt)))
    2221                 :            :         {
    2222                 :          9 :           save_suppress = info->suppress_expansion;
    2223                 :          9 :           convert_local_omp_clauses (gimple_omp_teams_clauses_ptr (stmt), wi);
    2224                 :          9 :           walk_body (convert_local_reference_stmt, convert_local_reference_op,
    2225                 :            :                      info, gimple_omp_body_ptr (stmt));
    2226                 :          9 :           info->suppress_expansion = save_suppress;
    2227                 :          9 :           break;
    2228                 :            :         }
    2229                 :            :       /* FALLTHRU */
    2230                 :            : 
    2231                 :       1134 :     case GIMPLE_OMP_PARALLEL:
    2232                 :       1134 :     case GIMPLE_OMP_TASK:
    2233                 :       1134 :       save_suppress = info->suppress_expansion;
    2234                 :       1134 :       frame_decl_added = false;
    2235                 :       1134 :       if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
    2236                 :            :                                      wi))
    2237                 :            :         {
    2238                 :         37 :           tree c = build_omp_clause (gimple_location (stmt),
    2239                 :            :                                      OMP_CLAUSE_SHARED);
    2240                 :         37 :           (void) get_frame_type (info);
    2241                 :         37 :           OMP_CLAUSE_DECL (c) = info->frame_decl;
    2242                 :         37 :           OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
    2243                 :         37 :           gimple_omp_taskreg_set_clauses (stmt, c);
    2244                 :         37 :           info->static_chain_added |= 4;
    2245                 :         37 :           frame_decl_added = true;
    2246                 :            :         }
    2247                 :            : 
    2248                 :       1134 :       save_local_var_chain = info->new_local_var_chain;
    2249                 :       1134 :       save_static_chain_added = info->static_chain_added;
    2250                 :       1134 :       info->new_local_var_chain = NULL;
    2251                 :       1134 :       info->static_chain_added = 0;
    2252                 :            : 
    2253                 :       1134 :       walk_body (convert_local_reference_stmt, convert_local_reference_op, info,
    2254                 :            :                  gimple_omp_body_ptr (stmt));
    2255                 :            : 
    2256                 :       1134 :       if ((info->static_chain_added & 4) != 0 && !frame_decl_added)
    2257                 :            :         {
    2258                 :          1 :           tree c = build_omp_clause (gimple_location (stmt),
    2259                 :            :                                      OMP_CLAUSE_SHARED);
    2260                 :          1 :           (void) get_frame_type (info);
    2261                 :          1 :           OMP_CLAUSE_DECL (c) = info->frame_decl;
    2262                 :          1 :           OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
    2263                 :          1 :           info->static_chain_added |= 4;
    2264                 :          1 :           gimple_omp_taskreg_set_clauses (stmt, c);
    2265                 :            :         }
    2266                 :       1134 :       if (info->new_local_var_chain)
    2267                 :         16 :         declare_vars (info->new_local_var_chain,
    2268                 :            :                       gimple_seq_first_stmt (gimple_omp_body (stmt)), false);
    2269                 :       1134 :       info->new_local_var_chain = save_local_var_chain;
    2270                 :       1134 :       info->suppress_expansion = save_suppress;
    2271                 :       1134 :       info->static_chain_added |= save_static_chain_added;
    2272                 :       1134 :       break;
    2273                 :            : 
    2274                 :       1194 :     case GIMPLE_OMP_FOR:
    2275                 :       1194 :       save_suppress = info->suppress_expansion;
    2276                 :       1194 :       convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
    2277                 :       1194 :       walk_gimple_omp_for (as_a <gomp_for *> (stmt),
    2278                 :            :                            convert_local_reference_stmt,
    2279                 :            :                            convert_local_reference_op, info);
    2280                 :       1194 :       walk_body (convert_local_reference_stmt, convert_local_reference_op,
    2281                 :            :                  info, gimple_omp_body_ptr (stmt));
    2282                 :       1194 :       info->suppress_expansion = save_suppress;
    2283                 :       1194 :       break;
    2284                 :            : 
    2285                 :         42 :     case GIMPLE_OMP_SECTIONS:
    2286                 :         42 :       save_suppress = info->suppress_expansion;
    2287                 :         42 :       convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
    2288                 :         42 :       walk_body (convert_local_reference_stmt, convert_local_reference_op,
    2289                 :            :                  info, gimple_omp_body_ptr (stmt));
    2290                 :         42 :       info->suppress_expansion = save_suppress;
    2291                 :         42 :       break;
    2292                 :            : 
    2293                 :        178 :     case GIMPLE_OMP_SINGLE:
    2294                 :        178 :       save_suppress = info->suppress_expansion;
    2295                 :        178 :       convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
    2296                 :        178 :       walk_body (convert_local_reference_stmt, convert_local_reference_op,
    2297                 :            :                  info, gimple_omp_body_ptr (stmt));
    2298                 :        178 :       info->suppress_expansion = save_suppress;
    2299                 :        178 :       break;
    2300                 :            : 
    2301                 :         32 :     case GIMPLE_OMP_TASKGROUP:
    2302                 :         32 :       save_suppress = info->suppress_expansion;
    2303                 :         32 :       convert_local_omp_clauses (gimple_omp_taskgroup_clauses_ptr (stmt), wi);
    2304                 :         32 :       walk_body (convert_local_reference_stmt, convert_local_reference_op,
    2305                 :            :                  info, gimple_omp_body_ptr (stmt));
    2306                 :         32 :       info->suppress_expansion = save_suppress;
    2307                 :         32 :       break;
    2308                 :            : 
    2309                 :        874 :     case GIMPLE_OMP_TARGET:
    2310                 :        874 :       if (!is_gimple_omp_offloaded (stmt))
    2311                 :            :         {
    2312                 :        338 :           save_suppress = info->suppress_expansion;
    2313                 :        338 :           convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt), wi);
    2314                 :        338 :           info->suppress_expansion = save_suppress;
    2315                 :        338 :           walk_body (convert_local_reference_stmt, convert_local_reference_op,
    2316                 :            :                      info, gimple_omp_body_ptr (stmt));
    2317                 :        338 :           break;
    2318                 :            :         }
    2319                 :        536 :       save_suppress = info->suppress_expansion;
    2320                 :        536 :       frame_decl_added = false;
    2321                 :        536 :       if (convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt), wi))
    2322                 :            :         {
    2323                 :          0 :           tree c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP);
    2324                 :          0 :           (void) get_frame_type (info);
    2325                 :          0 :           OMP_CLAUSE_DECL (c) = info->frame_decl;
    2326                 :          0 :           OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM);
    2327                 :          0 :           OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (info->frame_decl);
    2328                 :          0 :           OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
    2329                 :          0 :           gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt), c);
    2330                 :          0 :           info->static_chain_added |= 4;
    2331                 :          0 :           frame_decl_added = true;
    2332                 :            :         }
    2333                 :            : 
    2334                 :        536 :       save_local_var_chain = info->new_local_var_chain;
    2335                 :        536 :       save_static_chain_added = info->static_chain_added;
    2336                 :        536 :       info->new_local_var_chain = NULL;
    2337                 :        536 :       info->static_chain_added = 0;
    2338                 :            : 
    2339                 :        536 :       walk_body (convert_local_reference_stmt, convert_local_reference_op, info,
    2340                 :            :                  gimple_omp_body_ptr (stmt));
    2341                 :            : 
    2342                 :        536 :       if ((info->static_chain_added & 4) != 0 && !frame_decl_added)
    2343                 :            :         {
    2344                 :          0 :           tree c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP);
    2345                 :          0 :           (void) get_frame_type (info);
    2346                 :          0 :           OMP_CLAUSE_DECL (c) = info->frame_decl;
    2347                 :          0 :           OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM);
    2348                 :          0 :           OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (info->frame_decl);
    2349                 :          0 :           OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
    2350                 :          0 :           gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt), c);
    2351                 :          0 :           info->static_chain_added |= 4;
    2352                 :            :         }
    2353                 :            : 
    2354                 :        536 :       if (info->new_local_var_chain)
    2355                 :          1 :         declare_vars (info->new_local_var_chain,
    2356                 :            :                       gimple_seq_first_stmt (gimple_omp_body (stmt)), false);
    2357                 :        536 :       info->new_local_var_chain = save_local_var_chain;
    2358                 :        536 :       info->suppress_expansion = save_suppress;
    2359                 :        536 :       info->static_chain_added |= save_static_chain_added;
    2360                 :        536 :       break;
    2361                 :            : 
    2362                 :        146 :     case GIMPLE_OMP_SECTION:
    2363                 :        146 :     case GIMPLE_OMP_MASTER:
    2364                 :        146 :     case GIMPLE_OMP_ORDERED:
    2365                 :        146 :     case GIMPLE_OMP_SCAN:
    2366                 :        146 :       walk_body (convert_local_reference_stmt, convert_local_reference_op,
    2367                 :            :                  info, gimple_omp_body_ptr (stmt));
    2368                 :        146 :       break;
    2369                 :            : 
    2370                 :     161869 :     case GIMPLE_COND:
    2371                 :     161869 :       wi->val_only = true;
    2372                 :     161869 :       wi->is_lhs = false;
    2373                 :     161869 :       *handled_ops_p = false;
    2374                 :     161869 :       return NULL_TREE;
    2375                 :            : 
    2376                 :    1507520 :     case GIMPLE_ASSIGN:
    2377                 :    1507520 :       if (gimple_clobber_p (stmt))
    2378                 :            :         {
    2379                 :      67045 :           tree lhs = gimple_assign_lhs (stmt);
    2380                 :      67045 :           if (DECL_P (lhs)
    2381                 :      67035 :               && !use_pointer_in_frame (lhs)
    2382                 :     134080 :               && lookup_field_for_decl (info, lhs, NO_INSERT))
    2383                 :            :             {
    2384                 :       1273 :               gsi_replace (gsi, gimple_build_nop (), true);
    2385                 :       1273 :               break;
    2386                 :            :             }
    2387                 :            :         }
    2388                 :    1506250 :       *handled_ops_p = false;
    2389                 :    1506250 :       return NULL_TREE;
    2390                 :            : 
    2391                 :     135361 :     case GIMPLE_BIND:
    2392                 :     596823 :       for (tree var = gimple_bind_vars (as_a <gbind *> (stmt));
    2393                 :     596823 :            var;
    2394                 :     461462 :            var = DECL_CHAIN (var))
    2395                 :     461462 :         if (TREE_CODE (var) == NAMELIST_DECL)
    2396                 :            :           {
    2397                 :            :             /* Adjust decls mentioned in NAMELIST_DECL.  */
    2398                 :        119 :             tree decls = NAMELIST_DECL_ASSOCIATED_DECL (var);
    2399                 :        119 :             tree decl;
    2400                 :        119 :             unsigned int i;
    2401                 :            : 
    2402                 :       1568 :             FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls), i, decl)
    2403                 :            :               {
    2404                 :        753 :                 if (VAR_P (decl)
    2405                 :        941 :                     && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
    2406                 :         88 :                   continue;
    2407                 :        577 :                 if (decl_function_context (decl) == info->context
    2408                 :        577 :                     && !use_pointer_in_frame (decl))
    2409                 :            :                   {
    2410                 :        577 :                     tree field = lookup_field_for_decl (info, decl, NO_INSERT);
    2411                 :        577 :                     if (field)
    2412                 :            :                       {
    2413                 :          2 :                         CONSTRUCTOR_ELT (decls, i)->value
    2414                 :          2 :                           = get_local_debug_decl (info, decl, field);
    2415                 :            :                       }
    2416                 :            :                   }
    2417                 :            :               }
    2418                 :            :           }
    2419                 :            : 
    2420                 :     135361 :       *handled_ops_p = false;
    2421                 :     135361 :       return NULL_TREE;
    2422                 :            : 
    2423                 :     817952 :     default:
    2424                 :            :       /* For every other statement that we are not interested in
    2425                 :            :          handling here, let the walker traverse the operands.  */
    2426                 :     817952 :       *handled_ops_p = false;
    2427                 :     817952 :       return NULL_TREE;
    2428                 :            :     }
    2429                 :            : 
    2430                 :            :   /* Indicate that we have handled all the operands ourselves.  */
    2431                 :       4882 :   *handled_ops_p = true;
    2432                 :       4882 :   return NULL_TREE;
    2433                 :            : }
    2434                 :            : 
    2435                 :            : 
    2436                 :            : /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_GOTOs
    2437                 :            :    that reference labels from outer functions.  The rewrite will be a
    2438                 :            :    call to __builtin_nonlocal_goto.  */
    2439                 :            : 
    2440                 :            : static tree
    2441                 :    2628660 : convert_nl_goto_reference (gimple_stmt_iterator *gsi, bool *handled_ops_p,
    2442                 :            :                            struct walk_stmt_info *wi)
    2443                 :            : {
    2444                 :    2628660 :   struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
    2445                 :    2628660 :   tree label, new_label, target_context, x, field;
    2446                 :    2628660 :   gcall *call;
    2447                 :    2628660 :   gimple *stmt = gsi_stmt (*gsi);
    2448                 :            : 
    2449                 :    2628660 :   if (gimple_code (stmt) != GIMPLE_GOTO)
    2450                 :            :     {
    2451                 :    2529560 :       *handled_ops_p = false;
    2452                 :    2529560 :       return NULL_TREE;
    2453                 :            :     }
    2454                 :            : 
    2455                 :      99105 :   label = gimple_goto_dest (stmt);
    2456                 :      99105 :   if (TREE_CODE (label) != LABEL_DECL)
    2457                 :            :     {
    2458                 :         74 :       *handled_ops_p = false;
    2459                 :         74 :       return NULL_TREE;
    2460                 :            :     }
    2461                 :            : 
    2462                 :      99031 :   target_context = decl_function_context (label);
    2463                 :      99031 :   if (target_context == info->context)
    2464                 :            :     {
    2465                 :      98512 :       *handled_ops_p = false;
    2466                 :      98512 :       return NULL_TREE;
    2467                 :            :     }
    2468                 :            : 
    2469                 :        519 :   for (i = info->outer; target_context != i->context; i = i->outer)
    2470                 :          0 :     continue;
    2471                 :            : 
    2472                 :            :   /* The original user label may also be use for a normal goto, therefore
    2473                 :            :      we must create a new label that will actually receive the abnormal
    2474                 :            :      control transfer.  This new label will be marked LABEL_NONLOCAL; this
    2475                 :            :      mark will trigger proper behavior in the cfg, as well as cause the
    2476                 :            :      (hairy target-specific) non-local goto receiver code to be generated
    2477                 :            :      when we expand rtl.  Enter this association into var_map so that we
    2478                 :            :      can insert the new label into the IL during a second pass.  */
    2479                 :        519 :   tree *slot = &i->var_map->get_or_insert (label);
    2480                 :        519 :   if (*slot == NULL)
    2481                 :            :     {
    2482                 :        476 :       new_label = create_artificial_label (UNKNOWN_LOCATION);
    2483                 :        476 :       DECL_NONLOCAL (new_label) = 1;
    2484                 :        476 :       *slot = new_label;
    2485                 :            :     }
    2486                 :            :   else
    2487                 :            :     new_label = *slot;
    2488                 :            : 
    2489                 :            :   /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field).  */
    2490                 :        519 :   field = get_nl_goto_field (i);
    2491                 :        519 :   x = get_frame_field (info, target_context, field, gsi);
    2492                 :        519 :   x = build_addr (x);
    2493                 :        519 :   x = gsi_gimplify_val (info, x, gsi);
    2494                 :       1038 :   call = gimple_build_call (builtin_decl_implicit (BUILT_IN_NONLOCAL_GOTO),
    2495                 :            :                             2, build_addr (new_label), x);
    2496                 :        519 :   gsi_replace (gsi, call, false);
    2497                 :            : 
    2498                 :            :   /* We have handled all of STMT's operands, no need to keep going.  */
    2499                 :        519 :   *handled_ops_p = true;
    2500                 :        519 :   return NULL_TREE;
    2501                 :            : }
    2502                 :            : 
    2503                 :            : 
    2504                 :            : /* Called via walk_function+walk_tree, rewrite all GIMPLE_LABELs whose labels
    2505                 :            :    are referenced via nonlocal goto from a nested function.  The rewrite
    2506                 :            :    will involve installing a newly generated DECL_NONLOCAL label, and
    2507                 :            :    (potentially) a branch around the rtl gunk that is assumed to be
    2508                 :            :    attached to such a label.  */
    2509                 :            : 
    2510                 :            : static tree
    2511                 :    2629180 : convert_nl_goto_receiver (gimple_stmt_iterator *gsi, bool *handled_ops_p,
    2512                 :            :                           struct walk_stmt_info *wi)
    2513                 :            : {
    2514                 :    2629180 :   struct nesting_info *const info = (struct nesting_info *) wi->info;
    2515                 :    2629180 :   tree label, new_label;
    2516                 :    2629180 :   gimple_stmt_iterator tmp_gsi;
    2517                 :    2629180 :   glabel *stmt = dyn_cast <glabel *> (gsi_stmt (*gsi));
    2518                 :            : 
    2519                 :     470506 :   if (!stmt)
    2520                 :            :     {
    2521                 :    2158670 :       *handled_ops_p = false;
    2522                 :    2158670 :       return NULL_TREE;
    2523                 :            :     }
    2524                 :            : 
    2525                 :     470506 :   label = gimple_label_label (stmt);
    2526                 :            : 
    2527                 :     470506 :   tree *slot = info->var_map->get (label);
    2528                 :        476 :   if (!slot)
    2529                 :            :     {
    2530                 :     470030 :       *handled_ops_p = false;
    2531                 :     470030 :       return NULL_TREE;
    2532                 :            :     }
    2533                 :            : 
    2534                 :            :   /* If there's any possibility that the previous statement falls through,
    2535                 :            :      then we must branch around the new non-local label.  */
    2536                 :        476 :   tmp_gsi = wi->gsi;
    2537                 :        476 :   gsi_prev (&tmp_gsi);
    2538                 :        476 :   if (gsi_end_p (tmp_gsi) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi)))
    2539                 :            :     {
    2540                 :        265 :       gimple *stmt = gimple_build_goto (label);
    2541                 :        265 :       gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    2542                 :            :     }
    2543                 :            : 
    2544                 :        476 :   new_label = (tree) *slot;
    2545                 :        476 :   stmt = gimple_build_label (new_label);
    2546                 :        476 :   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    2547                 :            : 
    2548                 :        476 :   *handled_ops_p = true;
    2549                 :        476 :   return NULL_TREE;
    2550                 :            : }
    2551                 :            : 
    2552                 :            : 
    2553                 :            : /* Called via walk_function+walk_stmt, rewrite all references to addresses
    2554                 :            :    of nested functions that require the use of trampolines.  The rewrite
    2555                 :            :    will involve a reference a trampoline generated for the occasion.  */
    2556                 :            : 
    2557                 :            : static tree
    2558                 :    8067390 : convert_tramp_reference_op (tree *tp, int *walk_subtrees, void *data)
    2559                 :            : {
    2560                 :    8067390 :   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
    2561                 :    8067390 :   struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
    2562                 :    8067390 :   tree t = *tp, decl, target_context, x, builtin;
    2563                 :    8067390 :   bool descr;
    2564                 :    8067390 :   gcall *call;
    2565                 :            : 
    2566                 :    8067390 :   *walk_subtrees = 0;
    2567                 :    8067390 :   switch (TREE_CODE (t))
    2568                 :            :     {
    2569                 :     226079 :     case ADDR_EXPR:
    2570                 :            :       /* Build
    2571                 :            :            T.1 = &CHAIN->tramp;
    2572                 :            :            T.2 = __builtin_adjust_trampoline (T.1);
    2573                 :            :            T.3 = (func_type)T.2;
    2574                 :            :       */
    2575                 :            : 
    2576                 :     226079 :       decl = TREE_OPERAND (t, 0);
    2577                 :     226079 :       if (TREE_CODE (decl) != FUNCTION_DECL)
    2578                 :            :         break;
    2579                 :            : 
    2580                 :            :       /* Only need to process nested functions.  */
    2581                 :        869 :       target_context = decl_function_context (decl);
    2582                 :        869 :       if (!target_context)
    2583                 :            :         break;
    2584                 :            : 
    2585                 :            :       /* If the nested function doesn't use a static chain, then
    2586                 :            :          it doesn't need a trampoline.  */
    2587                 :        627 :       if (!DECL_STATIC_CHAIN (decl))
    2588                 :            :         break;
    2589                 :            : 
    2590                 :            :       /* If we don't want a trampoline, then don't build one.  */
    2591                 :        308 :       if (TREE_NO_TRAMPOLINE (t))
    2592                 :            :         break;
    2593                 :            : 
    2594                 :            :       /* Lookup the immediate parent of the callee, as that's where
    2595                 :            :          we need to insert the trampoline.  */
    2596                 :        334 :       for (i = info; i->context != target_context; i = i->outer)
    2597                 :         26 :         continue;
    2598                 :            : 
    2599                 :            :       /* Decide whether to generate a descriptor or a trampoline. */
    2600                 :        308 :       descr = FUNC_ADDR_BY_DESCRIPTOR (t) && !flag_trampolines;
    2601                 :            : 
    2602                 :        308 :       if (descr)
    2603                 :          0 :         x = lookup_descr_for_decl (i, decl, INSERT);
    2604                 :            :       else
    2605                 :        308 :         x = lookup_tramp_for_decl (i, decl, INSERT);
    2606                 :            : 
    2607                 :            :       /* Compute the address of the field holding the trampoline.  */
    2608                 :        308 :       x = get_frame_field (info, target_context, x, &wi->gsi);
    2609                 :        308 :       x = build_addr (x);
    2610                 :        308 :       x = gsi_gimplify_val (info, x, &wi->gsi);
    2611                 :            : 
    2612                 :            :       /* Do machine-specific ugliness.  Normally this will involve
    2613                 :            :          computing extra alignment, but it can really be anything.  */
    2614                 :        308 :       if (descr)
    2615                 :          0 :         builtin = builtin_decl_implicit (BUILT_IN_ADJUST_DESCRIPTOR);
    2616                 :            :       else
    2617                 :        308 :         builtin = builtin_decl_implicit (BUILT_IN_ADJUST_TRAMPOLINE);
    2618                 :        308 :       call = gimple_build_call (builtin, 1, x);
    2619                 :        308 :       x = init_tmp_var_with_call (info, &wi->gsi, call);
    2620                 :            : 
    2621                 :            :       /* Cast back to the proper function type.  */
    2622                 :        308 :       x = build1 (NOP_EXPR, TREE_TYPE (t), x);
    2623                 :        308 :       x = init_tmp_var (info, x, &wi->gsi);
    2624                 :            : 
    2625                 :        308 :       *tp = x;
    2626                 :        308 :       break;
    2627                 :            : 
    2628                 :    7841310 :     default:
    2629                 :    7841310 :       if (!IS_TYPE_OR_DECL_P (t))
    2630                 :    4076550 :         *walk_subtrees = 1;
    2631                 :            :       break;
    2632                 :            :     }
    2633                 :            : 
    2634                 :    8067390 :   return NULL_TREE;
    2635                 :            : }
    2636                 :            : 
    2637                 :            : 
    2638                 :            : /* Called via walk_function+walk_gimple_stmt, rewrite all references
    2639                 :            :    to addresses of nested functions that require the use of
    2640                 :            :    trampolines.  The rewrite will involve a reference a trampoline
    2641                 :            :    generated for the occasion.  */
    2642                 :            : 
    2643                 :            : static tree
    2644                 :    2650720 : convert_tramp_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
    2645                 :            :                               struct walk_stmt_info *wi)
    2646                 :            : {
    2647                 :    2650720 :   struct nesting_info *info = (struct nesting_info *) wi->info;
    2648                 :    2650720 :   gimple *stmt = gsi_stmt (*gsi);
    2649                 :            : 
    2650                 :    2650720 :   switch (gimple_code (stmt))
    2651                 :            :     {
    2652                 :     197053 :     case GIMPLE_CALL:
    2653                 :     197053 :       {
    2654                 :            :         /* Only walk call arguments, lest we generate trampolines for
    2655                 :            :            direct calls.  */
    2656                 :     197053 :         unsigned long i, nargs = gimple_call_num_args (stmt);
    2657                 :     676438 :         for (i = 0; i < nargs; i++)
    2658                 :     479385 :           walk_tree (gimple_call_arg_ptr (stmt, i), convert_tramp_reference_op,
    2659                 :            :                      wi, NULL);
    2660                 :            :         break;
    2661                 :            :       }
    2662                 :            : 
    2663                 :         15 :     case GIMPLE_OMP_TEAMS:
    2664                 :         15 :       if (!gimple_omp_teams_host (as_a <gomp_teams *> (stmt)))
    2665                 :            :         {
    2666                 :          9 :           *handled_ops_p = false;
    2667                 :          9 :           return NULL_TREE;
    2668                 :            :         }
    2669                 :          6 :       goto do_parallel;
    2670                 :            : 
    2671                 :        874 :     case GIMPLE_OMP_TARGET:
    2672                 :        874 :       if (!is_gimple_omp_offloaded (stmt))
    2673                 :            :         {
    2674                 :        338 :           *handled_ops_p = false;
    2675                 :        338 :           return NULL_TREE;
    2676                 :            :         }
    2677                 :            :       /* FALLTHRU */
    2678                 :       1686 :     case GIMPLE_OMP_PARALLEL:
    2679                 :       1686 :     case GIMPLE_OMP_TASK:
    2680                 :        536 :     do_parallel:
    2681                 :       1686 :       {
    2682                 :       1686 :         tree save_local_var_chain = info->new_local_var_chain;
    2683                 :       1686 :         walk_gimple_op (stmt, convert_tramp_reference_op, wi);
    2684                 :       1686 :         info->new_local_var_chain = NULL;
    2685                 :       1686 :         char save_static_chain_added = info->static_chain_added;
    2686                 :       1686 :         info->static_chain_added = 0;
    2687                 :       1686 :         walk_body (convert_tramp_reference_stmt, convert_tramp_reference_op,
    2688                 :            :                    info, gimple_omp_body_ptr (stmt));
    2689                 :       1686 :         if (info->new_local_var_chain)
    2690                 :          6 :           declare_vars (info->new_local_var_chain,
    2691                 :            :                         gimple_seq_first_stmt (gimple_omp_body (stmt)),
    2692                 :            :                         false);
    2693                 :       5058 :         for (int i = 0; i < 2; i++)
    2694                 :            :           {
    2695                 :       3372 :             tree c, decl;
    2696                 :       3372 :             if ((info->static_chain_added & (1 << i)) == 0)
    2697                 :       3366 :               continue;
    2698                 :          6 :             decl = i ? get_chain_decl (info) : info->frame_decl;
    2699                 :            :             /* Don't add CHAIN.* or FRAME.* twice.  */
    2700                 :          6 :             for (c = gimple_omp_taskreg_clauses (stmt);
    2701                 :          6 :                  c;
    2702                 :          0 :                  c = OMP_CLAUSE_CHAIN (c))
    2703                 :          1 :               if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
    2704                 :          1 :                    || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
    2705                 :          2 :                   && OMP_CLAUSE_DECL (c) == decl)
    2706                 :            :                 break;
    2707                 :          6 :             if (c == NULL && gimple_code (stmt) != GIMPLE_OMP_TARGET)
    2708                 :            :               {
    2709                 :          8 :                 c = build_omp_clause (gimple_location (stmt),
    2710                 :            :                                       i ? OMP_CLAUSE_FIRSTPRIVATE
    2711                 :            :                                       : OMP_CLAUSE_SHARED);
    2712                 :          5 :                 OMP_CLAUSE_DECL (c) = decl;
    2713                 :          5 :                 OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
    2714                 :          5 :                 gimple_omp_taskreg_set_clauses (stmt, c);
    2715                 :            :               }
    2716                 :          1 :             else if (c == NULL)
    2717                 :            :               {
    2718                 :          0 :                 c = build_omp_clause (gimple_location (stmt),
    2719                 :            :                                       OMP_CLAUSE_MAP);
    2720                 :          0 :                 OMP_CLAUSE_DECL (c) = decl;
    2721                 :          0 :                 OMP_CLAUSE_SET_MAP_KIND (c,
    2722                 :            :                                          i ? GOMP_MAP_TO : GOMP_MAP_TOFROM);
    2723                 :          0 :                 OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
    2724                 :          0 :                 OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
    2725                 :       3372 :                 gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt),
    2726                 :            :                                                c);
    2727                 :            :               }
    2728                 :            :           }
    2729                 :       1686 :         info->new_local_var_chain = save_local_var_chain;
    2730                 :       1686 :         info->static_chain_added |= save_static_chain_added;
    2731                 :            :       }
    2732                 :       1686 :       break;
    2733                 :            : 
    2734                 :    2451630 :     default:
    2735                 :    2451630 :       *handled_ops_p = false;
    2736                 :    2451630 :       return NULL_TREE;
    2737                 :            :     }
    2738                 :            : 
    2739                 :     198739 :   *handled_ops_p = true;
    2740                 :     198739 :   return NULL_TREE;
    2741                 :            : }
    2742                 :            : 
    2743                 :            : 
    2744                 :            : 
    2745                 :            : /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_CALLs
    2746                 :            :    that reference nested functions to make sure that the static chain
    2747                 :            :    is set up properly for the call.  */
    2748                 :            : 
    2749                 :            : static tree
    2750                 :    2651360 : convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
    2751                 :            :                      struct walk_stmt_info *wi)
    2752                 :            : {
    2753                 :    2651360 :   struct nesting_info *const info = (struct nesting_info *) wi->info;
    2754                 :    2651360 :   tree decl, target_context;
    2755                 :    2651360 :   char save_static_chain_added;
    2756                 :    2651360 :   int i;
    2757                 :    2651360 :   gimple *stmt = gsi_stmt (*gsi);
    2758                 :            : 
    2759                 :    2651360 :   switch (gimple_code (stmt))
    2760                 :            :     {
    2761                 :     197361 :     case GIMPLE_CALL:
    2762                 :     197361 :       if (gimple_call_chain (stmt))
    2763                 :            :         break;
    2764                 :     197258 :       decl = gimple_call_fndecl (stmt);
    2765                 :     197258 :       if (!decl)
    2766                 :            :         break;
    2767                 :     180139 :       target_context = decl_function_context (decl);
    2768                 :     211777 :       if (target_context && DECL_STATIC_CHAIN (decl))
    2769                 :            :         {
    2770                 :            :           struct nesting_info *i = info;
    2771                 :      10650 :           while (i && i->context != target_context)
    2772                 :       1145 :             i = i->outer;
    2773                 :            :           /* If none of the outer contexts is the target context, this means
    2774                 :            :              that the function is called in a wrong context.  */
    2775                 :       9505 :           if (!i)
    2776                 :          0 :             internal_error ("%s from %s called in %s",
    2777                 :          0 :                             IDENTIFIER_POINTER (DECL_NAME (decl)),
    2778                 :          0 :                             IDENTIFIER_POINTER (DECL_NAME (target_context)),
    2779                 :          0 :                             IDENTIFIER_POINTER (DECL_NAME (info->context)));
    2780                 :            : 
    2781                 :       9505 :           gimple_call_set_chain (as_a <gcall *> (stmt),
    2782                 :            :                                  get_static_chain (info, target_context,
    2783                 :            :                                                    &wi->gsi));
    2784                 :      17867 :           info->static_chain_added |= (1 << (info->context != target_context));
    2785                 :            :         }
    2786                 :            :       break;
    2787                 :            : 
    2788                 :         15 :     case GIMPLE_OMP_TEAMS:
    2789                 :         15 :       if (!gimple_omp_teams_host (as_a <gomp_teams *> (stmt)))
    2790                 :            :         {
    2791                 :          9 :           walk_body (convert_gimple_call, NULL, info,
    2792                 :            :                      gimple_omp_body_ptr (stmt));
    2793                 :          9 :           break;
    2794                 :            :         }
    2795                 :            :       /* FALLTHRU */
    2796                 :            : 
    2797                 :       1150 :     case GIMPLE_OMP_PARALLEL:
    2798                 :       1150 :     case GIMPLE_OMP_TASK:
    2799                 :       1150 :       save_static_chain_added = info->static_chain_added;
    2800                 :       1150 :       info->static_chain_added = 0;
    2801                 :       1150 :       walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
    2802                 :       3450 :       for (i = 0; i < 2; i++)
    2803                 :            :         {
    2804                 :       2300 :           tree c, decl;
    2805                 :       2300 :           if ((info->static_chain_added & (1 << i)) == 0)
    2806                 :       2237 :             continue;
    2807                 :         63 :           decl = i ? get_chain_decl (info) : info->frame_decl;
    2808                 :            :           /* Don't add CHAIN.* or FRAME.* twice.  */
    2809                 :        723 :           for (c = gimple_omp_taskreg_clauses (stmt);
    2810                 :        723 :                c;
    2811                 :        660 :                c = OMP_CLAUSE_CHAIN (c))
    2812                 :        662 :             if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
    2813                 :        250 :                  || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
    2814                 :        709 :                 && OMP_CLAUSE_DECL (c) == decl)
    2815                 :            :               break;
    2816                 :         63 :           if (c == NULL)
    2817                 :            :             {
    2818                 :        104 :               c = build_omp_clause (gimple_location (stmt),
    2819                 :            :                                     i ? OMP_CLAUSE_FIRSTPRIVATE
    2820                 :            :                                     : OMP_CLAUSE_SHARED);
    2821                 :         61 :               OMP_CLAUSE_DECL (c) = decl;
    2822                 :         61 :               OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
    2823                 :       2361 :               gimple_omp_taskreg_set_clauses (stmt, c);
    2824                 :            :             }
    2825                 :            :         }
    2826                 :       1150 :       info->static_chain_added |= save_static_chain_added;
    2827                 :       1150 :       break;
    2828                 :            : 
    2829                 :        874 :     case GIMPLE_OMP_TARGET:
    2830                 :        874 :       if (!is_gimple_omp_offloaded (stmt))
    2831                 :            :         {
    2832                 :        338 :           walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
    2833                 :        338 :           break;
    2834                 :            :         }
    2835                 :        536 :       save_static_chain_added = info->static_chain_added;
    2836                 :        536 :       info->static_chain_added = 0;
    2837                 :        536 :       walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
    2838                 :       1608 :       for (i = 0; i < 2; i++)
    2839                 :            :         {
    2840                 :       1072 :           tree c, decl;
    2841                 :       1072 :           if ((info->static_chain_added & (1 << i)) == 0)
    2842                 :       1062 :             continue;
    2843                 :         10 :           decl = i ? get_chain_decl (info) : info->frame_decl;
    2844                 :            :           /* Don't add CHAIN.* or FRAME.* twice.  */
    2845                 :         45 :           for (c = gimple_omp_target_clauses (stmt);
    2846                 :         45 :                c;
    2847                 :         35 :                c = OMP_CLAUSE_CHAIN (c))
    2848                 :         35 :             if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
    2849                 :         35 :                 && OMP_CLAUSE_DECL (c) == decl)
    2850                 :            :               break;
    2851                 :         10 :           if (c == NULL)
    2852                 :            :             {
    2853                 :         10 :               c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP);
    2854                 :         10 :               OMP_CLAUSE_DECL (c) = decl;
    2855                 :         17 :               OMP_CLAUSE_SET_MAP_KIND (c, i ? GOMP_MAP_TO : GOMP_MAP_TOFROM);
    2856                 :         10 :               OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
    2857                 :         10 :               OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
    2858                 :       1072 :               gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt),
    2859                 :            :                                              c);
    2860                 :            :             }
    2861                 :            :         }
    2862                 :        536 :       info->static_chain_added |= save_static_chain_added;
    2863                 :        536 :       break;
    2864                 :            : 
    2865                 :       1194 :     case GIMPLE_OMP_FOR:
    2866                 :       1194 :       walk_body (convert_gimple_call, NULL, info,
    2867                 :            :                  gimple_omp_for_pre_body_ptr (stmt));
    2868                 :            :       /* FALLTHRU */
    2869                 :       1633 :     case GIMPLE_OMP_SECTIONS:
    2870                 :       1633 :     case GIMPLE_OMP_SECTION:
    2871                 :       1633 :     case GIMPLE_OMP_SINGLE:
    2872                 :       1633 :     case GIMPLE_OMP_MASTER:
    2873                 :       1633 :     case GIMPLE_OMP_TASKGROUP:
    2874                 :       1633 :     case GIMPLE_OMP_ORDERED:
    2875                 :       1633 :     case GIMPLE_OMP_SCAN:
    2876                 :       1633 :     case GIMPLE_OMP_CRITICAL:
    2877                 :       1633 :       walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
    2878                 :       1633 :       break;
    2879                 :            : 
    2880                 :    2450340 :     default:
    2881                 :            :       /* Keep looking for other operands.  */
    2882                 :    2450340 :       *handled_ops_p = false;
    2883                 :    2450340 :       return NULL_TREE;
    2884                 :            :     }
    2885                 :            : 
    2886                 :     201027 :   *handled_ops_p = true;
    2887                 :     201027 :   return NULL_TREE;
    2888                 :            : }
    2889                 :            : 
    2890                 :            : /* Walk the nesting tree starting with ROOT.  Convert all trampolines and
    2891                 :            :    call expressions.  At the same time, determine if a nested function
    2892                 :            :    actually uses its static chain; if not, remember that.  */
    2893                 :            : 
    2894                 :            : static void
    2895                 :       6910 : convert_all_function_calls (struct nesting_info *root)
    2896                 :            : {
    2897                 :       6910 :   unsigned int chain_count = 0, old_chain_count, iter_count;
    2898                 :       6910 :   struct nesting_info *n;
    2899                 :            : 
    2900                 :            :   /* First, optimistically clear static_chain for all decls that haven't
    2901                 :            :      used the static chain already for variable access.  But always create
    2902                 :            :      it if not optimizing.  This makes it possible to reconstruct the static
    2903                 :            :      nesting tree at run time and thus to resolve up-level references from
    2904                 :            :      within the debugger.  */
    2905                 :      55188 :   FOR_EACH_NEST_INFO (n, root)
    2906                 :            :     {
    2907                 :      20684 :       if (n->thunk_p)
    2908                 :          0 :         continue;
    2909                 :      20684 :       tree decl = n->context;
    2910                 :      20684 :       if (!optimize)
    2911                 :            :         {
    2912                 :       3318 :           if (n->inner)
    2913                 :       1115 :             (void) get_frame_type (n);
    2914                 :       3318 :           if (n->outer)
    2915                 :       2206 :             (void) get_chain_decl (n);
    2916                 :            :         }
    2917                 :      17366 :       else if (!n->outer || (!n->chain_decl && !n->chain_field))
    2918                 :            :         {
    2919                 :      15372 :           DECL_STATIC_CHAIN (decl) = 0;
    2920                 :      15372 :           if (dump_file && (dump_flags & TDF_DETAILS))
    2921                 :          0 :             fprintf (dump_file, "Guessing no static-chain for %s\n",
    2922                 :          0 :                      lang_hooks.decl_printable_name (decl, 2));
    2923                 :            :         }
    2924                 :            :       else
    2925                 :       1994 :         DECL_STATIC_CHAIN (decl) = 1;
    2926                 :      20684 :       chain_count += DECL_STATIC_CHAIN (decl);
    2927                 :            :     }
    2928                 :            : 
    2929                 :      48278 :   FOR_EACH_NEST_INFO (n, root)
    2930                 :      20684 :     if (n->thunk_p)
    2931                 :            :       {
    2932                 :          0 :         tree decl = n->context;
    2933                 :          0 :         tree alias = cgraph_node::get (decl)->thunk.alias;
    2934                 :          0 :         DECL_STATIC_CHAIN (decl) = DECL_STATIC_CHAIN (alias);
    2935                 :            :       }
    2936                 :            : 
    2937                 :            :   /* Walk the functions and perform transformations.  Note that these
    2938                 :            :      transformations can induce new uses of the static chain, which in turn
    2939                 :            :      require re-examining all users of the decl.  */
    2940                 :            :   /* ??? It would make sense to try to use the call graph to speed this up,
    2941                 :            :      but the call graph hasn't really been built yet.  Even if it did, we
    2942                 :            :      would still need to iterate in this loop since address-of references
    2943                 :            :      wouldn't show up in the callgraph anyway.  */
    2944                 :            :   iter_count = 0;
    2945                 :       6951 :   do
    2946                 :            :     {
    2947                 :       6951 :       old_chain_count = chain_count;
    2948                 :       6951 :       chain_count = 0;
    2949                 :       6951 :       iter_count++;
    2950                 :            : 
    2951                 :       6951 :       if (dump_file && (dump_flags & TDF_DETAILS))
    2952                 :          0 :         fputc ('\n', dump_file);
    2953                 :            : 
    2954                 :      55658 :       FOR_EACH_NEST_INFO (n, root)
    2955                 :            :         {
    2956                 :      20878 :           if (n->thunk_p)
    2957                 :          0 :             continue;
    2958                 :      20878 :           tree decl = n->context;
    2959                 :      20878 :           walk_function (convert_tramp_reference_stmt,
    2960                 :            :                          convert_tramp_reference_op, n);
    2961                 :      20878 :           walk_function (convert_gimple_call, NULL, n);
    2962                 :      20878 :           chain_count += DECL_STATIC_CHAIN (decl);
    2963                 :            :         }
    2964                 :            : 
    2965                 :      48707 :       FOR_EACH_NEST_INFO (n, root)
    2966                 :      20878 :         if (n->thunk_p)
    2967                 :            :           {
    2968                 :          0 :             tree decl = n->context;
    2969                 :          0 :             tree alias = cgraph_node::get (decl)->thunk.alias;
    2970                 :          0 :             DECL_STATIC_CHAIN (decl) = DECL_STATIC_CHAIN (alias);
    2971                 :            :           }
    2972                 :            :     }
    2973                 :       6951 :   while (chain_count != old_chain_count);
    2974                 :            : 
    2975                 :       6910 :   if (dump_file && (dump_flags & TDF_DETAILS))
    2976                 :          0 :     fprintf (dump_file, "convert_all_function_calls iterations: %u\n\n",
    2977                 :            :              iter_count);
    2978                 :       6910 : }
    2979                 :            : 
    2980                 :            : struct nesting_copy_body_data
    2981                 :            : {
    2982                 :            :   copy_body_data cb;
    2983                 :            :   struct nesting_info *root;
    2984                 :            : };
    2985                 :            : 
    2986                 :            : /* A helper subroutine for debug_var_chain type remapping.  */
    2987                 :            : 
    2988                 :            : static tree
    2989                 :         30 : nesting_copy_decl (tree decl, copy_body_data *id)
    2990                 :            : {
    2991                 :         30 :   struct nesting_copy_body_data *nid = (struct nesting_copy_body_data *) id;
    2992                 :         30 :   tree *slot = nid->root->var_map->get (decl);
    2993                 :            : 
    2994                 :          6 :   if (slot)
    2995                 :          6 :     return (tree) *slot;
    2996                 :            : 
    2997                 :         24 :   if (TREE_CODE (decl) == TYPE_DECL && DECL_ORIGINAL_TYPE (decl))
    2998                 :            :     {
    2999                 :          6 :       tree new_decl = copy_decl_no_change (decl, id);
    3000                 :         12 :       DECL_ORIGINAL_TYPE (new_decl)
    3001                 :          6 :         = remap_type (DECL_ORIGINAL_TYPE (decl), id);
    3002                 :          6 :       return new_decl;
    3003                 :            :     }
    3004                 :            : 
    3005                 :         18 :   if (VAR_P (decl)
    3006                 :         18 :       || TREE_CODE (decl) == PARM_DECL
    3007                 :          0 :       || TREE_CODE (decl) == RESULT_DECL)
    3008                 :            :     return decl;
    3009                 :            : 
    3010                 :          0 :   return copy_decl_no_change (decl, id);
    3011                 :            : }
    3012                 :            : 
    3013                 :            : /* A helper function for remap_vla_decls.  See if *TP contains
    3014                 :            :    some remapped variables.  */
    3015                 :            : 
    3016                 :            : static tree
    3017                 :         36 : contains_remapped_vars (tree *tp, int *walk_subtrees, void *data)
    3018                 :            : {
    3019                 :         36 :   struct nesting_info *root = (struct nesting_info *) data;
    3020                 :         36 :   tree t = *tp;
    3021                 :            : 
    3022                 :         36 :   if (DECL_P (t))
    3023                 :            :     {
    3024                 :          0 :       *walk_subtrees = 0;
    3025                 :          0 :       tree *slot = root->var_map->get (t);
    3026                 :            : 
    3027                 :          0 :       if (slot)
    3028                 :          0 :         return *slot;
    3029                 :            :     }
    3030                 :            :   return NULL;
    3031                 :            : }
    3032                 :            : 
    3033                 :            : /* Remap VLA decls in BLOCK and subblocks if remapped variables are
    3034                 :            :    involved.  */
    3035                 :            : 
    3036                 :            : static void
    3037                 :       2476 : remap_vla_decls (tree block, struct nesting_info *root)
    3038                 :            : {
    3039                 :       2476 :   tree var, subblock, val, type;
    3040                 :       2476 :   struct nesting_copy_body_data id;
    3041                 :            : 
    3042                 :       4624 :   for (subblock = BLOCK_SUBBLOCKS (block);
    3043                 :       4624 :        subblock;
    3044                 :       2148 :        subblock = BLOCK_CHAIN (subblock))
    3045                 :       2148 :     remap_vla_decls (subblock, root);
    3046                 :            : 
    3047                 :       8074 :   for (var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
    3048                 :       5598 :     if (VAR_P (var) && DECL_HAS_VALUE_EXPR_P (var))
    3049                 :            :       {
    3050                 :         81 :         val = DECL_VALUE_EXPR (var);
    3051                 :         81 :         type = TREE_TYPE (var);
    3052                 :            : 
    3053                 :         93 :         if (!(TREE_CODE (val) == INDIRECT_REF
    3054                 :         12 :               && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
    3055                 :         12 :               && variably_modified_type_p (type, NULL)))
    3056                 :         69 :           continue;
    3057                 :            : 
    3058                 :         12 :         if (root->var_map->get (TREE_OPERAND (val, 0))
    3059                 :         12 :             || walk_tree (&type, contains_remapped_vars, root, NULL))
    3060                 :            :           break;
    3061                 :            :       }
    3062                 :            : 
    3063                 :       2476 :   if (var == NULL_TREE)
    3064                 :       2476 :     return;
    3065                 :            : 
    3066                 :          0 :   memset (&id, 0, sizeof (id));
    3067                 :          0 :   id.cb.copy_decl = nesting_copy_decl;
    3068                 :          0 :   id.cb.decl_map = new hash_map<tree, tree>;
    3069                 :          0 :   id.root = root;
    3070                 :            : 
    3071                 :          0 :   for (; var; var = DECL_CHAIN (var))
    3072                 :          0 :     if (VAR_P (var) && DECL_HAS_VALUE_EXPR_P (var))
    3073                 :            :       {
    3074                 :          0 :         struct nesting_info *i;
    3075                 :          0 :         tree newt, context;
    3076                 :            : 
    3077                 :          0 :         val = DECL_VALUE_EXPR (var);
    3078                 :          0 :         type = TREE_TYPE (var);
    3079                 :            : 
    3080                 :          0 :         if (!(TREE_CODE (val) == INDIRECT_REF
    3081                 :          0 :               && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
    3082                 :          0 :               && variably_modified_type_p (type, NULL)))
    3083                 :          0 :           continue;
    3084                 :            : 
    3085                 :          0 :         tree *slot = root->var_map->get (TREE_OPERAND (val, 0));
    3086                 :          0 :         if (!slot && !walk_tree (&type, contains_remapped_vars, root, NULL))
    3087                 :          0 :           continue;
    3088                 :            : 
    3089                 :          0 :         context = decl_function_context (var);
    3090                 :          0 :         for (i = root; i; i = i->outer)
    3091                 :          0 :           if (i->context == context)
    3092                 :            :             break;
    3093                 :            : 
    3094                 :          0 :         if (i == NULL)
    3095                 :          0 :           continue;
    3096                 :            : 
    3097                 :            :         /* Fully expand value expressions.  This avoids having debug variables
    3098                 :            :            only referenced from them and that can be swept during GC.  */
    3099                 :          0 :         if (slot)
    3100                 :            :           {
    3101                 :          0 :             tree t = (tree) *slot;
    3102                 :          0 :             gcc_assert (DECL_P (t) && DECL_HAS_VALUE_EXPR_P (t));
    3103                 :          0 :             val = build1 (INDIRECT_REF, TREE_TYPE (val), DECL_VALUE_EXPR (t));
    3104                 :            :           }
    3105                 :            : 
    3106                 :          0 :         id.cb.src_fn = i->context;
    3107                 :          0 :         id.cb.dst_fn = i->context;
    3108                 :          0 :         id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
    3109                 :            : 
    3110                 :          0 :         TREE_TYPE (var) = newt = remap_type (type, &id.cb);
    3111                 :          0 :         while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
    3112                 :            :           {
    3113                 :          0 :             newt = TREE_TYPE (newt);
    3114                 :          0 :             type = TREE_TYPE (type);
    3115                 :            :           }
    3116                 :          0 :         if (TYPE_NAME (newt)
    3117                 :          0 :             && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
    3118                 :          0 :             && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
    3119                 :          0 :             && newt != type
    3120                 :          0 :             && TYPE_NAME (newt) == TYPE_NAME (type))
    3121                 :          0 :           TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
    3122                 :            : 
    3123                 :          0 :         walk_tree (&val, copy_tree_body_r, &id.cb, NULL);
    3124                 :          0 :         if (val != DECL_VALUE_EXPR (var))
    3125                 :          0 :           SET_DECL_VALUE_EXPR (var, val);
    3126                 :            :       }
    3127                 :            : 
    3128                 :          0 :   delete id.cb.decl_map;
    3129                 :            : }
    3130                 :            : 
    3131                 :            : /* Fixup VLA decls in BLOCK and subblocks if remapped variables are
    3132                 :            :    involved.  */
    3133                 :            : 
    3134                 :            : static void
    3135                 :     132359 : fixup_vla_decls (tree block)
    3136                 :            : {
    3137                 :     519102 :   for (tree var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
    3138                 :     386743 :     if (VAR_P (var) && DECL_HAS_VALUE_EXPR_P (var))
    3139                 :            :       {
    3140                 :       3216 :         tree val = DECL_VALUE_EXPR (var);
    3141                 :            : 
    3142                 :       3216 :         if (!(TREE_CODE (val) == INDIRECT_REF
    3143                 :        314 :               && VAR_P (TREE_OPERAND (val, 0))
    3144                 :        312 :               && DECL_HAS_VALUE_EXPR_P (TREE_OPERAND (val, 0))))
    3145                 :       3183 :           continue;
    3146                 :            : 
    3147                 :            :         /* Fully expand value expressions.  This avoids having debug variables
    3148                 :            :            only referenced from them and that can be swept during GC.  */
    3149                 :         33 :         val = build1 (INDIRECT_REF, TREE_TYPE (val),
    3150                 :         33 :                       DECL_VALUE_EXPR (TREE_OPERAND (val, 0)));
    3151                 :         33 :         SET_DECL_VALUE_EXPR (var, val);
    3152                 :            :       }
    3153                 :            : 
    3154                 :     244362 :   for (tree sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub))
    3155                 :     112003 :     fixup_vla_decls (sub);
    3156                 :     132359 : }
    3157                 :            : 
    3158                 :            : /* Fold the MEM_REF *E.  */
    3159                 :            : bool
    3160                 :          0 : fold_mem_refs (tree *const &e, void *data ATTRIBUTE_UNUSED)
    3161                 :            : {
    3162                 :          0 :   tree *ref_p = CONST_CAST2 (tree *, const tree *, (const tree *)e);
    3163                 :          0 :   *ref_p = fold (*ref_p);
    3164                 :          0 :   return true;
    3165                 :            : }
    3166                 :            : 
    3167                 :            : /* Given DECL, a nested function, build an initialization call for FIELD,
    3168                 :            :    the trampoline or descriptor for DECL, using FUNC as the function.  */
    3169                 :            : 
    3170                 :            : static gcall *
    3171                 :        290 : build_init_call_stmt (struct nesting_info *info, tree decl, tree field,
    3172                 :            :                       tree func)
    3173                 :            : {
    3174                 :        290 :   tree arg1, arg2, arg3, x;
    3175                 :            : 
    3176                 :        290 :   gcc_assert (DECL_STATIC_CHAIN (decl));
    3177                 :        290 :   arg3 = build_addr (info->frame_decl);
    3178                 :            : 
    3179                 :        290 :   arg2 = build_addr (decl);
    3180                 :            : 
    3181                 :        290 :   x = build3 (COMPONENT_REF, TREE_TYPE (field),
    3182                 :            :               info->frame_decl, field, NULL_TREE);
    3183                 :        290 :   arg1 = build_addr (x);
    3184                 :            : 
    3185                 :        290 :   return gimple_build_call (func, 3, arg1, arg2, arg3);
    3186                 :            : }
    3187                 :            : 
    3188                 :            : /* Do "everything else" to clean up or complete state collected by the various
    3189                 :            :    walking passes -- create a field to hold the frame base address, lay out the
    3190                 :            :    types and decls, generate code to initialize the frame decl, store critical
    3191                 :            :    expressions in the struct function for rtl to find.  */
    3192                 :            : 
    3193                 :            : static void
    3194                 :      20684 : finalize_nesting_tree_1 (struct nesting_info *root)
    3195                 :            : {
    3196                 :      20684 :   gimple_seq stmt_list = NULL;
    3197                 :      20684 :   gimple *stmt;
    3198                 :      20684 :   tree context = root->context;
    3199                 :      20684 :   struct function *sf;
    3200                 :            : 
    3201                 :      20684 :   if (root->thunk_p)
    3202                 :          0 :     return;
    3203                 :            : 
    3204                 :            :   /* If we created a non-local frame type or decl, we need to lay them
    3205                 :            :      out at this time.  */
    3206                 :      20684 :   if (root->frame_type)
    3207                 :            :     {
    3208                 :            :       /* Debugging information needs to compute the frame base address of the
    3209                 :            :          parent frame out of the static chain from the nested frame.
    3210                 :            : 
    3211                 :            :          The static chain is the address of the FRAME record, so one could
    3212                 :            :          imagine it would be possible to compute the frame base address just
    3213                 :            :          adding a constant offset to this address.  Unfortunately, this is not
    3214                 :            :          possible: if the FRAME object has alignment constraints that are
    3215                 :            :          stronger than the stack, then the offset between the frame base and
    3216                 :            :          the FRAME object will be dynamic.
    3217                 :            : 
    3218                 :            :          What we do instead is to append a field to the FRAME object that holds
    3219                 :            :          the frame base address: then debug info just has to fetch this
    3220                 :            :          field.  */
    3221                 :            : 
    3222                 :            :       /* Debugging information will refer to the CFA as the frame base
    3223                 :            :          address: we will do the same here.  */
    3224                 :       2631 :       const tree frame_addr_fndecl
    3225                 :       2631 :         = builtin_decl_explicit (BUILT_IN_DWARF_CFA);
    3226                 :            : 
    3227                 :            :       /* Create a field in the FRAME record to hold the frame base address for
    3228                 :            :          this stack frame.  Since it will be used only by the debugger, put it
    3229                 :            :          at the end of the record in order not to shift all other offsets.  */
    3230                 :       2631 :       tree fb_decl = make_node (FIELD_DECL);
    3231                 :            : 
    3232                 :       2631 :       DECL_NAME (fb_decl) = get_identifier ("FRAME_BASE.PARENT");
    3233                 :       2631 :       TREE_TYPE (fb_decl) = ptr_type_node;
    3234                 :       2631 :       TREE_ADDRESSABLE (fb_decl) = 1;
    3235                 :       2631 :       DECL_CONTEXT (fb_decl) = root->frame_type;
    3236                 :       2631 :       TYPE_FIELDS (root->frame_type) = chainon (TYPE_FIELDS (root->frame_type),
    3237                 :            :                                                 fb_decl);
    3238                 :            : 
    3239                 :            :       /* In some cases the frame type will trigger the -Wpadded warning.
    3240                 :            :          This is not helpful; suppress it. */
    3241                 :       2631 :       int save_warn_padded = warn_padded;
    3242                 :       2631 :       warn_padded = 0;
    3243                 :       2631 :       layout_type (root->frame_type);
    3244                 :       2631 :       warn_padded = save_warn_padded;
    3245                 :       2631 :       layout_decl (root->frame_decl, 0);
    3246                 :            : 
    3247                 :            :       /* Initialize the frame base address field.  If the builtin we need is
    3248                 :            :          not available, set it to NULL so that debugging information does not
    3249                 :            :          reference junk.  */
    3250                 :       2631 :       tree fb_ref = build3 (COMPONENT_REF, TREE_TYPE (fb_decl),
    3251                 :            :                             root->frame_decl, fb_decl, NULL_TREE);
    3252                 :       2631 :       tree fb_tmp;
    3253                 :            : 
    3254                 :       2631 :       if (frame_addr_fndecl != NULL_TREE)
    3255                 :            :         {
    3256                 :       1025 :           gcall *fb_gimple = gimple_build_call (frame_addr_fndecl, 1,
    3257                 :            :                                                 integer_zero_node);
    3258                 :       1025 :           gimple_stmt_iterator gsi = gsi_last (stmt_list);
    3259                 :            : 
    3260                 :       1025 :           fb_tmp = init_tmp_var_with_call (root, &gsi, fb_gimple);
    3261                 :            :         }
    3262                 :            :       else
    3263                 :       1606 :         fb_tmp = build_int_cst (TREE_TYPE (fb_ref), 0);
    3264                 :       2631 :       gimple_seq_add_stmt (&stmt_list,
    3265                 :       2631 :                            gimple_build_assign (fb_ref, fb_tmp));
    3266                 :            : 
    3267                 :       2631 :       declare_vars (root->frame_decl,
    3268                 :            :                     gimple_seq_first_stmt (gimple_body (context)), true);
    3269                 :            :     }
    3270                 :            : 
    3271                 :            :   /* If any parameters were referenced non-locally, then we need to insert
    3272                 :            :      a copy or a pointer.  */
    3273                 :      20684 :   if (root->any_parm_remapped)
    3274                 :            :     {
    3275                 :        180 :       tree p;
    3276                 :        519 :       for (p = DECL_ARGUMENTS (context); p ; p = DECL_CHAIN (p))
    3277                 :            :         {
    3278                 :        339 :           tree field, x, y;
    3279                 :            : 
    3280                 :        339 :           field = lookup_field_for_decl (root, p, NO_INSERT);
    3281                 :        339 :           if (!field)
    3282                 :        120 :             continue;
    3283                 :            : 
    3284                 :        219 :           if (use_pointer_in_frame (p))
    3285                 :          9 :             x = build_addr (p);
    3286                 :            :           else
    3287                 :            :             x = p;
    3288                 :            : 
    3289                 :            :           /* If the assignment is from a non-register the stmt is
    3290                 :            :              not valid gimple.  Make it so by using a temporary instead.  */
    3291                 :        219 :           if (!is_gimple_reg (x)
    3292                 :        243 :               && is_gimple_reg_type (TREE_TYPE (x)))
    3293                 :            :             {
    3294                 :         24 :               gimple_stmt_iterator gsi = gsi_last (stmt_list);
    3295                 :         24 :               x = init_tmp_var (root, x, &gsi);
    3296                 :            :             }
    3297                 :            : 
    3298                 :        219 :           y = build3 (COMPONENT_REF, TREE_TYPE (field),
    3299                 :            :                       root->frame_decl, field, NULL_TREE);
    3300                 :        219 :           stmt = gimple_build_assign (y, x);
    3301                 :        219 :           gimple_seq_add_stmt (&stmt_list, stmt);
    3302                 :            :         }
    3303                 :            :     }
    3304                 :            : 
    3305                 :            :   /* If a chain_field was created, then it needs to be initialized
    3306                 :            :      from chain_decl.  */
    3307                 :      20684 :   if (root->chain_field)
    3308                 :            :     {
    3309                 :         11 :       tree x = build3 (COMPONENT_REF, TREE_TYPE (root->chain_field),
    3310                 :            :                        root->frame_decl, root->chain_field, NULL_TREE);
    3311                 :         11 :       stmt = gimple_build_assign (x, get_chain_decl (root));
    3312                 :         11 :       gimple_seq_add_stmt (&stmt_list, stmt);
    3313                 :            :     }
    3314                 :            : 
    3315                 :            :   /* If trampolines were created, then we need to initialize them.  */
    3316                 :      20684 :   if (root->any_tramp_created)
    3317                 :            :     {
    3318                 :        262 :       struct nesting_info *i;
    3319                 :        622 :       for (i = root->inner; i ; i = i->next)
    3320                 :            :         {
    3321                 :        360 :           tree field, x;
    3322                 :            : 
    3323                 :        360 :           field = lookup_tramp_for_decl (root, i->context, NO_INSERT);
    3324                 :        360 :           if (!field)
    3325                 :         70 :             continue;
    3326                 :            : 
    3327                 :        290 :           x = builtin_decl_implicit (BUILT_IN_INIT_TRAMPOLINE);
    3328                 :        290 :           stmt = build_init_call_stmt (root, i->context, field, x);
    3329                 :        290 :           gimple_seq_add_stmt (&stmt_list, stmt);
    3330                 :            :         }
    3331                 :            :     }
    3332                 :            : 
    3333                 :            :   /* If descriptors were created, then we need to initialize them.  */
    3334                 :      20684 :   if (root->any_descr_created)
    3335                 :            :     {
    3336                 :          0 :       struct nesting_info *i;
    3337                 :          0 :       for (i = root->inner; i ; i = i->next)
    3338                 :            :         {
    3339                 :          0 :           tree field, x;
    3340                 :            : 
    3341                 :          0 :           field = lookup_descr_for_decl (root, i->context, NO_INSERT);
    3342                 :          0 :           if (!field)
    3343                 :          0 :             continue;
    3344                 :            : 
    3345                 :          0 :           x = builtin_decl_implicit (BUILT_IN_INIT_DESCRIPTOR);
    3346                 :          0 :           stmt = build_init_call_stmt (root, i->context, field, x);
    3347                 :          0 :           gimple_seq_add_stmt (&stmt_list, stmt);
    3348                 :            :         }
    3349                 :            :     }
    3350                 :            : 
    3351                 :            :   /* If we created initialization statements, insert them.  */
    3352                 :      20684 :   if (stmt_list)
    3353                 :            :     {
    3354                 :       2631 :       gbind *bind;
    3355                 :       2631 :       annotate_all_with_location (stmt_list, DECL_SOURCE_LOCATION (context));
    3356                 :       2631 :       bind = gimple_seq_first_stmt_as_a_bind (gimple_body (context));
    3357                 :       2631 :       gimple_seq_add_seq (&stmt_list, gimple_bind_body (bind));
    3358                 :       2631 :       gimple_bind_set_body (bind, stmt_list);
    3359                 :            :     }
    3360                 :            : 
    3361                 :            :   /* If a chain_decl was created, then it needs to be registered with
    3362                 :            :      struct function so that it gets initialized from the static chain
    3363                 :            :      register at the beginning of the function.  */
    3364                 :      20684 :   sf = DECL_STRUCT_FUNCTION (root->context);
    3365                 :      20684 :   sf->static_chain_decl = root->chain_decl;
    3366                 :            : 
    3367                 :            :   /* Similarly for the non-local goto save area.  */
    3368                 :      20684 :   if (root->nl_goto_field)
    3369                 :            :     {
    3370                 :        373 :       sf->nonlocal_goto_save_area
    3371                 :        373 :         = get_frame_field (root, context, root->nl_goto_field, NULL);
    3372                 :        373 :       sf->has_nonlocal_label = 1;
    3373                 :            :     }
    3374                 :            : 
    3375                 :            :   /* Make sure all new local variables get inserted into the
    3376                 :            :      proper BIND_EXPR.  */
    3377                 :      20684 :   if (root->new_local_var_chain)
    3378                 :       2986 :     declare_vars (root->new_local_var_chain,
    3379                 :            :                   gimple_seq_first_stmt (gimple_body (root->context)),
    3380                 :            :                   false);
    3381                 :            : 
    3382                 :      20684 :   if (root->debug_var_chain)
    3383                 :            :     {
    3384                 :        328 :       tree debug_var;
    3385                 :        328 :       gbind *scope;
    3386                 :            : 
    3387                 :        328 :       remap_vla_decls (DECL_INITIAL (root->context), root);
    3388                 :            : 
    3389                 :       1630 :       for (debug_var = root->debug_var_chain; debug_var;
    3390                 :        651 :            debug_var = DECL_CHAIN (debug_var))
    3391                 :        657 :         if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
    3392                 :            :           break;
    3393                 :            : 
    3394                 :            :       /* If there are any debug decls with variable length types,
    3395                 :            :          remap those types using other debug_var_chain variables.  */
    3396                 :        328 :       if (debug_var)
    3397                 :            :         {
    3398                 :          6 :           struct nesting_copy_body_data id;
    3399                 :            : 
    3400                 :          6 :           memset (&id, 0, sizeof (id));
    3401                 :          6 :           id.cb.copy_decl = nesting_copy_decl;
    3402                 :          6 :           id.cb.decl_map = new hash_map<tree, tree>;
    3403                 :          6 :           id.root = root;
    3404                 :            : 
    3405                 :         36 :           for (; debug_var; debug_var = DECL_CHAIN (debug_var))
    3406                 :         30 :             if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
    3407                 :            :               {
    3408                 :          6 :                 tree type = TREE_TYPE (debug_var);
    3409                 :          6 :                 tree newt, t = type;
    3410                 :          6 :                 struct nesting_info *i;
    3411                 :            : 
    3412                 :         12 :                 for (i = root; i; i = i->outer)
    3413                 :         12 :                   if (variably_modified_type_p (type, i->context))
    3414                 :            :                     break;
    3415                 :            : 
    3416                 :          6 :                 if (i == NULL)
    3417                 :          0 :                   continue;
    3418                 :            : 
    3419                 :          6 :                 id.cb.src_fn = i->context;
    3420                 :          6 :                 id.cb.dst_fn = i->context;
    3421                 :          6 :                 id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
    3422                 :            : 
    3423                 :          6 :                 TREE_TYPE (debug_var) = newt = remap_type (type, &id.cb);
    3424                 :         18 :                 while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
    3425                 :            :                   {
    3426                 :          6 :                     newt = TREE_TYPE (newt);
    3427                 :          6 :                     t = TREE_TYPE (t);
    3428                 :            :                   }
    3429                 :          6 :                 if (TYPE_NAME (newt)
    3430                 :          6 :                     && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
    3431                 :          6 :                     && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
    3432                 :          6 :                     && newt != t
    3433                 :         12 :                     && TYPE_NAME (newt) == TYPE_NAME (t))
    3434                 :          6 :                   TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
    3435                 :            :               }
    3436                 :            : 
    3437                 :         12 :           delete id.cb.decl_map;
    3438                 :            :         }
    3439                 :            : 
    3440                 :        328 :       scope = gimple_seq_first_stmt_as_a_bind (gimple_body (root->context));
    3441                 :        328 :       if (gimple_bind_block (scope))
    3442                 :        326 :         declare_vars (root->debug_var_chain, scope, true);
    3443                 :            :       else
    3444                 :          4 :         BLOCK_VARS (DECL_INITIAL (root->context))
    3445                 :          2 :           = chainon (BLOCK_VARS (DECL_INITIAL (root->context)),
    3446                 :            :                      root->debug_var_chain);
    3447                 :            :     }
    3448                 :            :   else
    3449                 :      20356 :     fixup_vla_decls (DECL_INITIAL (root->context));
    3450                 :            : 
    3451                 :            :   /* Fold the rewritten MEM_REF trees.  */
    3452                 :      20684 :   root->mem_refs->traverse<void *, fold_mem_refs> (NULL);
    3453                 :            : 
    3454                 :            :   /* Dump the translated tree function.  */
    3455                 :      20684 :   if (dump_file)
    3456                 :            :     {
    3457                 :          0 :       fputs ("\n\n", dump_file);
    3458                 :          0 :       dump_function_to_file (root->context, dump_file, dump_flags);
    3459                 :            :     }
    3460                 :            : }
    3461                 :            : 
    3462                 :            : static void
    3463                 :       6910 : finalize_nesting_tree (struct nesting_info *root)
    3464                 :            : {
    3465                 :       6910 :   struct nesting_info *n;
    3466                 :      55188 :   FOR_EACH_NEST_INFO (n, root)
    3467                 :      20684 :     finalize_nesting_tree_1 (n);
    3468                 :       6910 : }
    3469                 :            : 
    3470                 :            : /* Unnest the nodes and pass them to cgraph.  */
    3471                 :            : 
    3472                 :            : static void
    3473                 :      20684 : unnest_nesting_tree_1 (struct nesting_info *root)
    3474                 :            : {
    3475                 :      20684 :   struct cgraph_node *node = cgraph_node::get (root->context);
    3476                 :            : 
    3477                 :            :   /* For nested functions update the cgraph to reflect unnesting.
    3478                 :            :      We also delay finalizing of these functions up to this point.  */
    3479                 :      20684 :   if (node->origin)
    3480                 :            :     {
    3481                 :      13774 :        node->unnest ();
    3482                 :      13774 :        if (!root->thunk_p)
    3483                 :      13774 :          cgraph_node::finalize_function (root->context, true);
    3484                 :            :     }
    3485                 :      20684 : }
    3486                 :            : 
    3487                 :            : static void
    3488                 :       6910 : unnest_nesting_tree (struct nesting_info *root)
    3489                 :            : {
    3490                 :       6910 :   struct nesting_info *n;
    3491                 :      55188 :   FOR_EACH_NEST_INFO (n, root)
    3492                 :      20684 :     unnest_nesting_tree_1 (n);
    3493                 :       6910 : }
    3494                 :            : 
    3495                 :            : /* Free the data structures allocated during this pass.  */
    3496                 :            : 
    3497                 :            : static void
    3498                 :       6910 : free_nesting_tree (struct nesting_info *root)
    3499                 :            : {
    3500                 :       6910 :   struct nesting_info *node, *next;
    3501                 :            : 
    3502                 :       6910 :   node = iter_nestinfo_start (root);
    3503                 :      20684 :   do
    3504                 :            :     {
    3505                 :      20684 :       next = iter_nestinfo_next (node);
    3506                 :      41368 :       delete node->var_map;
    3507                 :      41368 :       delete node->field_map;
    3508                 :      41368 :       delete node->mem_refs;
    3509                 :      20684 :       free (node);
    3510                 :      20684 :       node = next;
    3511                 :            :     }
    3512                 :      20684 :   while (node);
    3513                 :       6910 : }
    3514                 :            : 
    3515                 :            : /* Gimplify a function and all its nested functions.  */
    3516                 :            : static void
    3517                 :      20684 : gimplify_all_functions (struct cgraph_node *root)
    3518                 :            : {
    3519                 :      20684 :   struct cgraph_node *iter;
    3520                 :      20684 :   if (!gimple_body (root->decl))
    3521                 :      13774 :     gimplify_function_tree (root->decl);
    3522                 :      34458 :   for (iter = root->nested; iter; iter = iter->next_nested)
    3523                 :      13774 :     if (!iter->thunk.thunk_p)
    3524                 :      13774 :       gimplify_all_functions (iter);
    3525                 :      20684 : }
    3526                 :            : 
    3527                 :            : /* Main entry point for this pass.  Process FNDECL and all of its nested
    3528                 :            :    subroutines and turn them into something less tightly bound.  */
    3529                 :            : 
    3530                 :            : void
    3531                 :       6910 : lower_nested_functions (tree fndecl)
    3532                 :            : {
    3533                 :       6910 :   struct cgraph_node *cgn;
    3534                 :       6910 :   struct nesting_info *root;
    3535                 :            : 
    3536                 :            :   /* If there are no nested functions, there's nothing to do.  */
    3537                 :       6910 :   cgn = cgraph_node::get (fndecl);
    3538                 :       6910 :   if (!cgn->nested)
    3539                 :            :     return;
    3540                 :            : 
    3541                 :       6910 :   gimplify_all_functions (cgn);
    3542                 :            : 
    3543                 :       6910 :   set_dump_file (dump_begin (TDI_nested, &dump_flags));
    3544                 :       6910 :   if (dump_file)
    3545                 :          0 :     fprintf (dump_file, "\n;; Function %s\n\n",
    3546                 :          0 :              lang_hooks.decl_printable_name (fndecl, 2));
    3547                 :            : 
    3548                 :       6910 :   bitmap_obstack_initialize (&nesting_info_bitmap_obstack);
    3549                 :       6910 :   root = create_nesting_tree (cgn);
    3550                 :            : 
    3551                 :       6910 :   walk_all_functions (convert_nonlocal_reference_stmt,
    3552                 :            :                       convert_nonlocal_reference_op,
    3553                 :            :                       root);
    3554                 :       6910 :   walk_all_functions (convert_local_reference_stmt,
    3555                 :            :                       convert_local_reference_op,
    3556                 :            :                       root);
    3557                 :       6910 :   walk_all_functions (convert_nl_goto_reference, NULL, root);
    3558                 :       6910 :   walk_all_functions (convert_nl_goto_receiver, NULL, root);
    3559                 :            : 
    3560                 :       6910 :   convert_all_function_calls (root);
    3561                 :       6910 :   finalize_nesting_tree (root);
    3562                 :       6910 :   unnest_nesting_tree (root);
    3563                 :            : 
    3564                 :       6910 :   free_nesting_tree (root);
    3565                 :       6910 :   bitmap_obstack_release (&nesting_info_bitmap_obstack);
    3566                 :            : 
    3567                 :       6910 :   if (dump_file)
    3568                 :            :     {
    3569                 :          0 :       dump_end (TDI_nested, dump_file);
    3570                 :          0 :       set_dump_file (NULL);
    3571                 :            :     }
    3572                 :            : }
    3573                 :            : 
    3574                 :            : #include "gt-tree-nested.h"

Generated by: LCOV version 1.0

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