gcc/tree-nested.c

   1 /* Nested function decomposition for GIMPLE.
   2    Copyright (C) 2004-2013 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 "tm.h"
  24 #include "tree.h"
  25 #include "stringpool.h"
  26 #include "stor-layout.h"
  27 #include "tm_p.h"
  28 #include "function.h"
  29 #include "tree-dump.h"
  30 #include "tree-inline.h"
  31 #include "pointer-set.h"
  32 #include "basic-block.h"
  33 #include "tree-ssa-alias.h"
  34 #include "internal-fn.h"
  35 #include "gimple-expr.h"
  36 #include "is-a.h"
  37 #include "gimple.h"
  38 #include "gimplify.h"
  39 #include "gimple-iterator.h"
  40 #include "gimple-walk.h"
  41 #include "tree-iterator.h"
  42 #include "bitmap.h"
  43 #include "cgraph.h"
  44 #include "tree-cfg.h"
  45 #include "expr.h"       /* FIXME: For STACK_SAVEAREA_MODE and SAVE_NONLOCAL.  */
  46 #include "langhooks.h"
  47 #include "gimple-low.h"
  48
  49
  50 /* The object of this pass is to lower the representation of a set of nested
  51    functions in order to expose all of the gory details of the various
  52    nonlocal references.  We want to do this sooner rather than later, in
  53    order to give us more freedom in emitting all of the functions in question.
  54
  55    Back in olden times, when gcc was young, we developed an insanely
  56    complicated scheme whereby variables which were referenced nonlocally
  57    were forced to live in the stack of the declaring function, and then
  58    the nested functions magically discovered where these variables were
  59    placed.  In order for this scheme to function properly, it required
  60    that the outer function be partially expanded, then we switch to
  61    compiling the inner function, and once done with those we switch back
  62    to compiling the outer function.  Such delicate ordering requirements
  63    makes it difficult to do whole translation unit optimizations
  64    involving such functions.
  65
  66    The implementation here is much more direct.  Everything that can be
  67    referenced by an inner function is a member of an explicitly created
  68    structure herein called the "nonlocal frame struct".  The incoming
  69    static chain for a nested function is a pointer to this struct in
  70    the parent.  In this way, we settle on known offsets from a known
  71    base, and so are decoupled from the logic that places objects in the
  72    function's stack frame.  More importantly, we don't have to wait for
  73    that to happen -- since the compilation of the inner function is no
  74    longer tied to a real stack frame, the nonlocal frame struct can be
  75    allocated anywhere.  Which means that the outer function is now
  76    inlinable.
  77
  78    Theory of operation here is very simple.  Iterate over all the
  79    statements in all the functions (depth first) several times,
  80    allocating structures and fields on demand.  In general we want to
  81    examine inner functions first, so that we can avoid making changes
  82    to outer functions which are unnecessary.
  83
  84    The order of the passes matters a bit, in that later passes will be
  85    skipped if it is discovered that the functions don't actually interact
  86    at all.  That is, they're nested in the lexical sense but could have
  87    been written as independent functions without change.  */
  88
  89
  90 struct nesting_info
  91 {
  92   struct nesting_info *outer;
  93   struct nesting_info *inner;
  94   struct nesting_info *next;
  95
  96   struct pointer_map_t *field_map;
  97   struct pointer_map_t *var_map;
  98   struct pointer_set_t *mem_refs;
  99   bitmap suppress_expansion;
 100
 101   tree context;
 102   tree new_local_var_chain;
 103   tree debug_var_chain;
 104   tree frame_type;
 105   tree frame_decl;
 106   tree chain_field;
 107   tree chain_decl;
 108   tree nl_goto_field;
 109
 110   bool any_parm_remapped;
 111   bool any_tramp_created;
 112   char static_chain_added;
 113 };
 114
 115
 116 /* Iterate over the nesting tree, starting with ROOT, depth first.  */
 117
 118 static inline struct nesting_info *
 119 iter_nestinfo_start (struct nesting_info *root)
 120 {
 121   while (root->inner)
 122     root = root->inner;
 123   return root;
 124 }
 125
 126 static inline struct nesting_info *
 127 iter_nestinfo_next (struct nesting_info *node)
 128 {
 129   if (node->next)
 130     return iter_nestinfo_start (node->next);
 131   return node->outer;
 132 }
 133
 134 #define FOR_EACH_NEST_INFO(I, ROOT) \
 135   for ((I) = iter_nestinfo_start (ROOT); (I); (I) = iter_nestinfo_next (I))
 136
 137 /* Obstack used for the bitmaps in the struct above.  */
 138 static struct bitmap_obstack nesting_info_bitmap_obstack;
 139
 140
 141 /* We're working in so many different function contexts simultaneously,
 142    that create_tmp_var is dangerous.  Prevent mishap.  */
 143 #define create_tmp_var cant_use_create_tmp_var_here_dummy
 144
 145 /* Like create_tmp_var, except record the variable for registration at
 146    the given nesting level.  */
 147
 148 static tree
 149 create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix)
 150 {
 151   tree tmp_var;
 152
 153   /* If the type is of variable size or a type which must be created by the
 154      frontend, something is wrong.  Note that we explicitly allow
 155      incomplete types here, since we create them ourselves here.  */
 156   gcc_assert (!TREE_ADDRESSABLE (type));
 157   gcc_assert (!TYPE_SIZE_UNIT (type)
 158               || TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
 159
 160   tmp_var = create_tmp_var_raw (type, prefix);
 161   DECL_CONTEXT (tmp_var) = info->context;
 162   DECL_CHAIN (tmp_var) = info->new_local_var_chain;
 163   DECL_SEEN_IN_BIND_EXPR_P (tmp_var) = 1;
 164   if (TREE_CODE (type) == COMPLEX_TYPE
 165       || TREE_CODE (type) == VECTOR_TYPE)
 166     DECL_GIMPLE_REG_P (tmp_var) = 1;
 167
 168   info->new_local_var_chain = tmp_var;
 169
 170   return tmp_var;
 171 }
 172
 173 /* Take the address of EXP to be used within function CONTEXT.
 174    Mark it for addressability as necessary.  */
 175
 176 tree
 177 build_addr (tree exp, tree context)
 178 {
 179   tree base = exp;
 180   tree save_context;
 181   tree retval;
 182
 183   while (handled_component_p (base))
 184     base = TREE_OPERAND (base, 0);
 185
 186   if (DECL_P (base))
 187     TREE_ADDRESSABLE (base) = 1;
 188
 189   /* Building the ADDR_EXPR will compute a set of properties for
 190      that ADDR_EXPR.  Those properties are unfortunately context
 191      specific, i.e., they are dependent on CURRENT_FUNCTION_DECL.
 192
 193      Temporarily set CURRENT_FUNCTION_DECL to the desired context,
 194      build the ADDR_EXPR, then restore CURRENT_FUNCTION_DECL.  That
 195      way the properties are for the ADDR_EXPR are computed properly.  */
 196   save_context = current_function_decl;
 197   current_function_decl = context;
 198   retval = build_fold_addr_expr (exp);
 199   current_function_decl = save_context;
 200   return retval;
 201 }
 202
 203 /* Insert FIELD into TYPE, sorted by alignment requirements.  */
 204
 205 void
 206 insert_field_into_struct (tree type, tree field)
 207 {
 208   tree *p;
 209
 210   DECL_CONTEXT (field) = type;
 211
 212   for (p = &TYPE_FIELDS (type); *p ; p = &DECL_CHAIN (*p))
 213     if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
 214       break;
 215
 216   DECL_CHAIN (field) = *p;
 217   *p = field;
 218
 219   /* Set correct alignment for frame struct type.  */
 220   if (TYPE_ALIGN (type) < DECL_ALIGN (field))
 221     TYPE_ALIGN (type) = DECL_ALIGN (field);
 222 }
 223
 224 /* Build or return the RECORD_TYPE that describes the frame state that is
 225    shared between INFO->CONTEXT and its nested functions.  This record will
 226    not be complete until finalize_nesting_tree; up until that point we'll
 227    be adding fields as necessary.
 228
 229    We also build the DECL that represents this frame in the function.  */
 230
 231 static tree
 232 get_frame_type (struct nesting_info *info)
 233 {
 234   tree type = info->frame_type;
 235   if (!type)
 236     {
 237       char *name;
 238
 239       type = make_node (RECORD_TYPE);
 240
 241       name = concat ("FRAME.",
 242                      IDENTIFIER_POINTER (DECL_NAME (info->context)),
 243                      NULL);
 244       TYPE_NAME (type) = get_identifier (name);
 245       free (name);
 246
 247       info->frame_type = type;
 248       info->frame_decl = create_tmp_var_for (info, type, "FRAME");
 249       DECL_NONLOCAL_FRAME (info->frame_decl) = 1;
 250
 251       /* ??? Always make it addressable for now, since it is meant to
 252          be pointed to by the static chain pointer.  This pessimizes
 253          when it turns out that no static chains are needed because
 254          the nested functions referencing non-local variables are not
 255          reachable, but the true pessimization is to create the non-
 256          local frame structure in the first place.  */
 257       TREE_ADDRESSABLE (info->frame_decl) = 1;
 258     }
 259   return type;
 260 }
 261
 262 /* Return true if DECL should be referenced by pointer in the non-local
 263    frame structure.  */
 264
 265 static bool
 266 use_pointer_in_frame (tree decl)
 267 {
 268   if (TREE_CODE (decl) == PARM_DECL)
 269     {
 270       /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable
 271          sized decls, and inefficient to copy large aggregates.  Don't bother
 272          moving anything but scalar variables.  */
 273       return AGGREGATE_TYPE_P (TREE_TYPE (decl));
 274     }
 275   else
 276     {
 277       /* Variable sized types make things "interesting" in the frame.  */
 278       return DECL_SIZE (decl) == NULL || !TREE_CONSTANT (DECL_SIZE (decl));
 279     }
 280 }
 281
 282 /* Given DECL, a non-locally accessed variable, find or create a field
 283    in the non-local frame structure for the given nesting context.  */
 284
 285 static tree
 286 lookup_field_for_decl (struct nesting_info *info, tree decl,
 287                        enum insert_option insert)
 288 {
 289   void **slot;
 290
 291   if (insert == NO_INSERT)
 292     {
 293       slot = pointer_map_contains (info->field_map, decl);
 294       return slot ? (tree) *slot : NULL_TREE;
 295     }
 296
 297   slot = pointer_map_insert (info->field_map, decl);
 298   if (!*slot)
 299     {
 300       tree field = make_node (FIELD_DECL);
 301       DECL_NAME (field) = DECL_NAME (decl);
 302
 303       if (use_pointer_in_frame (decl))
 304         {
 305           TREE_TYPE (field) = build_pointer_type (TREE_TYPE (decl));
 306           DECL_ALIGN (field) = TYPE_ALIGN (TREE_TYPE (field));
 307           DECL_NONADDRESSABLE_P (field) = 1;
 308         }
 309       else
 310         {
 311           TREE_TYPE (field) = TREE_TYPE (decl);
 312           DECL_SOURCE_LOCATION (field) = DECL_SOURCE_LOCATION (decl);
 313           DECL_ALIGN (field) = DECL_ALIGN (decl);
 314           DECL_USER_ALIGN (field) = DECL_USER_ALIGN (decl);
 315           TREE_ADDRESSABLE (field) = TREE_ADDRESSABLE (decl);
 316           DECL_NONADDRESSABLE_P (field) = !TREE_ADDRESSABLE (decl);
 317           TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (decl);
 318         }
 319
 320       insert_field_into_struct (get_frame_type (info), field);
 321       *slot = field;
 322
 323       if (TREE_CODE (decl) == PARM_DECL)
 324         info->any_parm_remapped = true;
 325     }
 326
 327   return (tree) *slot;
 328 }
 329
 330 /* Build or return the variable that holds the static chain within
 331    INFO->CONTEXT.  This variable may only be used within INFO->CONTEXT.  */
 332
 333 static tree
 334 get_chain_decl (struct nesting_info *info)
 335 {
 336   tree decl = info->chain_decl;
 337
 338   if (!decl)
 339     {
 340       tree type;
 341
 342       type = get_frame_type (info->outer);
 343       type = build_pointer_type (type);
 344
 345       /* Note that this variable is *not* entered into any BIND_EXPR;
 346          the construction of this variable is handled specially in
 347          expand_function_start and initialize_inlined_parameters.
 348          Note also that it's represented as a parameter.  This is more
 349          close to the truth, since the initial value does come from
 350          the caller.  */
 351       decl = build_decl (DECL_SOURCE_LOCATION (info->context),
 352                          PARM_DECL, create_tmp_var_name ("CHAIN"), type);
 353       DECL_ARTIFICIAL (decl) = 1;
 354       DECL_IGNORED_P (decl) = 1;
 355       TREE_USED (decl) = 1;
 356       DECL_CONTEXT (decl) = info->context;
 357       DECL_ARG_TYPE (decl) = type;
 358
 359       /* Tell tree-inline.c that we never write to this variable, so
 360          it can copy-prop the replacement value immediately.  */
 361       TREE_READONLY (decl) = 1;
 362
 363       info->chain_decl = decl;
 364
 365       if (dump_file
 366           && (dump_flags & TDF_DETAILS)
 367           && !DECL_STATIC_CHAIN (info->context))
 368         fprintf (dump_file, "Setting static-chain for %s\n",
 369                  lang_hooks.decl_printable_name (info->context, 2));
 370
 371       DECL_STATIC_CHAIN (info->context) = 1;
 372     }
 373   return decl;
 374 }
 375
 376 /* Build or return the field within the non-local frame state that holds
 377    the static chain for INFO->CONTEXT.  This is the way to walk back up
 378    multiple nesting levels.  */
 379
 380 static tree
 381 get_chain_field (struct nesting_info *info)
 382 {
 383   tree field = info->chain_field;
 384
 385   if (!field)
 386     {
 387       tree type = build_pointer_type (get_frame_type (info->outer));
 388
 389       field = make_node (FIELD_DECL);
 390       DECL_NAME (field) = get_identifier ("__chain");
 391       TREE_TYPE (field) = type;
 392       DECL_ALIGN (field) = TYPE_ALIGN (type);
 393       DECL_NONADDRESSABLE_P (field) = 1;
 394
 395       insert_field_into_struct (get_frame_type (info), field);
 396
 397       info->chain_field = field;
 398
 399       if (dump_file
 400           && (dump_flags & TDF_DETAILS)
 401           && !DECL_STATIC_CHAIN (info->context))
 402         fprintf (dump_file, "Setting static-chain for %s\n",
 403                  lang_hooks.decl_printable_name (info->context, 2));
 404
 405       DECL_STATIC_CHAIN (info->context) = 1;
 406     }
 407   return field;
 408 }
 409
 410 /* Initialize a new temporary with the GIMPLE_CALL STMT.  */
 411
 412 static tree
 413 init_tmp_var_with_call (struct nesting_info *info, gimple_stmt_iterator *gsi,
 414                         gimple call)
 415 {
 416   tree t;
 417
 418   t = create_tmp_var_for (info, gimple_call_return_type (call), NULL);
 419   gimple_call_set_lhs (call, t);
 420   if (! gsi_end_p (*gsi))
 421     gimple_set_location (call, gimple_location (gsi_stmt (*gsi)));
 422   gsi_insert_before (gsi, call, GSI_SAME_STMT);
 423
 424   return t;
 425 }
 426
 427
 428 /* Copy EXP into a temporary.  Allocate the temporary in the context of
 429    INFO and insert the initialization statement before GSI.  */
 430
 431 static tree
 432 init_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
 433 {
 434   tree t;
 435   gimple stmt;
 436
 437   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
 438   stmt = gimple_build_assign (t, exp);
 439   if (! gsi_end_p (*gsi))
 440     gimple_set_location (stmt, gimple_location (gsi_stmt (*gsi)));
 441   gsi_insert_before_without_update (gsi, stmt, GSI_SAME_STMT);
 442
 443   return t;
 444 }
 445
 446
 447 /* Similarly, but only do so to force EXP to satisfy is_gimple_val.  */
 448
 449 static tree
 450 gsi_gimplify_val (struct nesting_info *info, tree exp,
 451                   gimple_stmt_iterator *gsi)
 452 {
 453   if (is_gimple_val (exp))
 454     return exp;
 455   else
 456     return init_tmp_var (info, exp, gsi);
 457 }
 458
 459 /* Similarly, but copy from the temporary and insert the statement
 460    after the iterator.  */
 461
 462 static tree
 463 save_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
 464 {
 465   tree t;
 466   gimple stmt;
 467
 468   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
 469   stmt = gimple_build_assign (exp, t);
 470   if (! gsi_end_p (*gsi))
 471     gimple_set_location (stmt, gimple_location (gsi_stmt (*gsi)));
 472   gsi_insert_after_without_update (gsi, stmt, GSI_SAME_STMT);
 473
 474   return t;
 475 }
 476
 477 /* Build or return the type used to represent a nested function trampoline.  */
 478
 479 static GTY(()) tree trampoline_type;
 480
 481 static tree
 482 get_trampoline_type (struct nesting_info *info)
 483 {
 484   unsigned align, size;
 485   tree t;
 486
 487   if (trampoline_type)
 488     return trampoline_type;
 489
 490   align = TRAMPOLINE_ALIGNMENT;
 491   size = TRAMPOLINE_SIZE;
 492
 493   /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
 494      then allocate extra space so that we can do dynamic alignment.  */
 495   if (align > STACK_BOUNDARY)
 496     {
 497       size += ((align/BITS_PER_UNIT) - 1) & -(STACK_BOUNDARY/BITS_PER_UNIT);
 498       align = STACK_BOUNDARY;
 499     }
 500
 501   t = build_index_type (size_int (size - 1));
 502   t = build_array_type (char_type_node, t);
 503   t = build_decl (DECL_SOURCE_LOCATION (info->context),
 504                   FIELD_DECL, get_identifier ("__data"), t);
 505   DECL_ALIGN (t) = align;
 506   DECL_USER_ALIGN (t) = 1;
 507
 508   trampoline_type = make_node (RECORD_TYPE);
 509   TYPE_NAME (trampoline_type) = get_identifier ("__builtin_trampoline");
 510   TYPE_FIELDS (trampoline_type) = t;
 511   layout_type (trampoline_type);
 512   DECL_CONTEXT (t) = trampoline_type;
 513
 514   return trampoline_type;
 515 }
 516
 517 /* Given DECL, a nested function, find or create a field in the non-local
 518    frame structure for a trampoline for this function.  */
 519
 520 static tree
 521 lookup_tramp_for_decl (struct nesting_info *info, tree decl,
 522                        enum insert_option insert)
 523 {
 524   void **slot;
 525
 526   if (insert == NO_INSERT)
 527     {
 528       slot = pointer_map_contains (info->var_map, decl);
 529       return slot ? (tree) *slot : NULL_TREE;
 530     }
 531
 532   slot = pointer_map_insert (info->var_map, decl);
 533   if (!*slot)
 534     {
 535       tree field = make_node (FIELD_DECL);
 536       DECL_NAME (field) = DECL_NAME (decl);
 537       TREE_TYPE (field) = get_trampoline_type (info);
 538       TREE_ADDRESSABLE (field) = 1;
 539
 540       insert_field_into_struct (get_frame_type (info), field);
 541       *slot = field;
 542
 543       info->any_tramp_created = true;
 544     }
 545
 546   return (tree) *slot;
 547 }
 548
 549 /* Build or return the field within the non-local frame state that holds
 550    the non-local goto "jmp_buf".  The buffer itself is maintained by the
 551    rtl middle-end as dynamic stack space is allocated.  */
 552
 553 static tree
 554 get_nl_goto_field (struct nesting_info *info)
 555 {
 556   tree field = info->nl_goto_field;
 557   if (!field)
 558     {
 559       unsigned size;
 560       tree type;
 561
 562       /* For __builtin_nonlocal_goto, we need N words.  The first is the
 563          frame pointer, the rest is for the target's stack pointer save
 564          area.  The number of words is controlled by STACK_SAVEAREA_MODE;
 565          not the best interface, but it'll do for now.  */
 566       if (Pmode == ptr_mode)
 567         type = ptr_type_node;
 568       else
 569         type = lang_hooks.types.type_for_mode (Pmode, 1);
 570
 571       size = GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL));
 572       size = size / GET_MODE_SIZE (Pmode);
 573       size = size + 1;
 574
 575       type = build_array_type
 576         (type, build_index_type (size_int (size)));
 577
 578       field = make_node (FIELD_DECL);
 579       DECL_NAME (field) = get_identifier ("__nl_goto_buf");
 580       TREE_TYPE (field) = type;
 581       DECL_ALIGN (field) = TYPE_ALIGN (type);
 582       TREE_ADDRESSABLE (field) = 1;
 583
 584       insert_field_into_struct (get_frame_type (info), field);
 585
 586       info->nl_goto_field = field;
 587     }
 588
 589   return field;
 590 }
 591
 592 /* Invoke CALLBACK on all statements of GIMPLE sequence *PSEQ.  */
 593
 594 static void
 595 walk_body (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
 596            struct nesting_info *info, gimple_seq *pseq)
 597 {
 598   struct walk_stmt_info wi;
 599
 600   memset (&wi, 0, sizeof (wi));
 601   wi.info = info;
 602   wi.val_only = true;
 603   walk_gimple_seq_mod (pseq, callback_stmt, callback_op, &wi);
 604 }
 605
 606
 607 /* Invoke CALLBACK_STMT/CALLBACK_OP on all statements of INFO->CONTEXT.  */
 608
 609 static inline void
 610 walk_function (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
 611                struct nesting_info *info)
 612 {
 613   gimple_seq body = gimple_body (info->context);
 614   walk_body (callback_stmt, callback_op, info, &body);
 615   gimple_set_body (info->context, body);
 616 }
 617
 618 /* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body.  */
 619
 620 static void
 621 walk_gimple_omp_for (gimple for_stmt,
 622                      walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
 623                      struct nesting_info *info)
 624 {
 625   struct walk_stmt_info wi;
 626   gimple_seq seq;
 627   tree t;
 628   size_t i;
 629
 630   walk_body (callback_stmt, callback_op, info, gimple_omp_for_pre_body_ptr (for_stmt));
 631
 632   seq = NULL;
 633   memset (&wi, 0, sizeof (wi));
 634   wi.info = info;
 635   wi.gsi = gsi_last (seq);
 636
 637   for (i = 0; i < gimple_omp_for_collapse (for_stmt); i++)
 638     {
 639       wi.val_only = false;
 640       walk_tree (gimple_omp_for_index_ptr (for_stmt, i), callback_op,
 641                  &wi, NULL);
 642       wi.val_only = true;
 643       wi.is_lhs = false;
 644       walk_tree (gimple_omp_for_initial_ptr (for_stmt, i), callback_op,
 645                  &wi, NULL);
 646
 647       wi.val_only = true;
 648       wi.is_lhs = false;
 649       walk_tree (gimple_omp_for_final_ptr (for_stmt, i), callback_op,
 650                  &wi, NULL);
 651
 652       t = gimple_omp_for_incr (for_stmt, i);
 653       gcc_assert (BINARY_CLASS_P (t));
 654       wi.val_only = false;
 655       walk_tree (&TREE_OPERAND (t, 0), callback_op, &wi, NULL);
 656       wi.val_only = true;
 657       wi.is_lhs = false;
 658       walk_tree (&TREE_OPERAND (t, 1), callback_op, &wi, NULL);
 659     }
 660
 661   seq = gsi_seq (wi.gsi);
 662   if (!gimple_seq_empty_p (seq))
 663     {
 664       gimple_seq pre_body = gimple_omp_for_pre_body (for_stmt);
 665       annotate_all_with_location (seq, gimple_location (for_stmt));
 666       gimple_seq_add_seq (&pre_body, seq);
 667       gimple_omp_for_set_pre_body (for_stmt, pre_body);
 668     }
 669 }
 670
 671 /* Similarly for ROOT and all functions nested underneath, depth first.  */
 672
 673 static void
 674 walk_all_functions (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
 675                     struct nesting_info *root)
 676 {
 677   struct nesting_info *n;
 678   FOR_EACH_NEST_INFO (n, root)
 679     walk_function (callback_stmt, callback_op, n);
 680 }
 681
 682
 683 /* We have to check for a fairly pathological case.  The operands of function
 684    nested function are to be interpreted in the context of the enclosing
 685    function.  So if any are variably-sized, they will get remapped when the
 686    enclosing function is inlined.  But that remapping would also have to be
 687    done in the types of the PARM_DECLs of the nested function, meaning the
 688    argument types of that function will disagree with the arguments in the
 689    calls to that function.  So we'd either have to make a copy of the nested
 690    function corresponding to each time the enclosing function was inlined or
 691    add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
 692    function.  The former is not practical.  The latter would still require
 693    detecting this case to know when to add the conversions.  So, for now at
 694    least, we don't inline such an enclosing function.
 695
 696    We have to do that check recursively, so here return indicating whether
 697    FNDECL has such a nested function.  ORIG_FN is the function we were
 698    trying to inline to use for checking whether any argument is variably
 699    modified by anything in it.
 700
 701    It would be better to do this in tree-inline.c so that we could give
 702    the appropriate warning for why a function can't be inlined, but that's
 703    too late since the nesting structure has already been flattened and
 704    adding a flag just to record this fact seems a waste of a flag.  */
 705
 706 static bool
 707 check_for_nested_with_variably_modified (tree fndecl, tree orig_fndecl)
 708 {
 709   struct cgraph_node *cgn = cgraph_get_node (fndecl);
 710   tree arg;
 711
 712   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 713     {
 714       for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = DECL_CHAIN (arg))
 715         if (variably_modified_type_p (TREE_TYPE (arg), orig_fndecl))
 716           return true;
 717
 718       if (check_for_nested_with_variably_modified (cgn->decl,
 719                                                    orig_fndecl))
 720         return true;
 721     }
 722
 723   return false;
 724 }
 725
 726 /* Construct our local datastructure describing the function nesting
 727    tree rooted by CGN.  */
 728
 729 static struct nesting_info *
 730 create_nesting_tree (struct cgraph_node *cgn)
 731 {
 732   struct nesting_info *info = XCNEW (struct nesting_info);
 733   info->field_map = pointer_map_create ();
 734   info->var_map = pointer_map_create ();
 735   info->mem_refs = pointer_set_create ();
 736   info->suppress_expansion = BITMAP_ALLOC (&nesting_info_bitmap_obstack);
 737   info->context = cgn->decl;
 738
 739   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 740     {
 741       struct nesting_info *sub = create_nesting_tree (cgn);
 742       sub->outer = info;
 743       sub->next = info->inner;
 744       info->inner = sub;
 745     }
 746
 747   /* See discussion at check_for_nested_with_variably_modified for a
 748      discussion of why this has to be here.  */
 749   if (check_for_nested_with_variably_modified (info->context, info->context))
 750     DECL_UNINLINABLE (info->context) = true;
 751
 752   return info;
 753 }
 754
 755 /* Return an expression computing the static chain for TARGET_CONTEXT
 756    from INFO->CONTEXT.  Insert any necessary computations before TSI.  */
 757
 758 static tree
 759 get_static_chain (struct nesting_info *info, tree target_context,
 760                   gimple_stmt_iterator *gsi)
 761 {
 762   struct nesting_info *i;
 763   tree x;
 764
 765   if (info->context == target_context)
 766     {
 767       x = build_addr (info->frame_decl, target_context);
 768     }
 769   else
 770     {
 771       x = get_chain_decl (info);
 772
 773       for (i = info->outer; i->context != target_context; i = i->outer)
 774         {
 775           tree field = get_chain_field (i);
 776
 777           x = build_simple_mem_ref (x);
 778           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 779           x = init_tmp_var (info, x, gsi);
 780         }
 781     }
 782
 783   return x;
 784 }
 785
 786
 787 /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
 788    frame as seen from INFO->CONTEXT.  Insert any necessary computations
 789    before GSI.  */
 790
 791 static tree
 792 get_frame_field (struct nesting_info *info, tree target_context,
 793                  tree field, gimple_stmt_iterator *gsi)
 794 {
 795   struct nesting_info *i;
 796   tree x;
 797
 798   if (info->context == target_context)
 799     {
 800       /* Make sure frame_decl gets created.  */
 801       (void) get_frame_type (info);
 802       x = info->frame_decl;
 803     }
 804   else
 805     {
 806       x = get_chain_decl (info);
 807
 808       for (i = info->outer; i->context != target_context; i = i->outer)
 809         {
 810           tree field = get_chain_field (i);
 811
 812           x = build_simple_mem_ref (x);
 813           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 814           x = init_tmp_var (info, x, gsi);
 815         }
 816
 817       x = build_simple_mem_ref (x);
 818     }
 819
 820   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 821   return x;
 822 }
 823
 824 static void note_nonlocal_vla_type (struct nesting_info *info, tree type);
 825
 826 /* A subroutine of convert_nonlocal_reference_op.  Create a local variable
 827    in the nested function with DECL_VALUE_EXPR set to reference the true
 828    variable in the parent function.  This is used both for debug info
 829    and in OpenMP lowering.  */
 830
 831 static tree
 832 get_nonlocal_debug_decl (struct nesting_info *info, tree decl)
 833 {
 834   tree target_context;
 835   struct nesting_info *i;
 836   tree x, field, new_decl;
 837   void **slot;
 838
 839   slot = pointer_map_insert (info->var_map, decl);
 840
 841   if (*slot)
 842     return (tree) *slot;
 843
 844   target_context = decl_function_context (decl);
 845
 846   /* A copy of the code in get_frame_field, but without the temporaries.  */
 847   if (info->context == target_context)
 848     {
 849       /* Make sure frame_decl gets created.  */
 850       (void) get_frame_type (info);
 851       x = info->frame_decl;
 852       i = info;
 853     }
 854   else
 855     {
 856       x = get_chain_decl (info);
 857       for (i = info->outer; i->context != target_context; i = i->outer)
 858         {
 859           field = get_chain_field (i);
 860           x = build_simple_mem_ref (x);
 861           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 862         }
 863       x = build_simple_mem_ref (x);
 864     }
 865
 866   field = lookup_field_for_decl (i, decl, INSERT);
 867   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 868   if (use_pointer_in_frame (decl))
 869     x = build_simple_mem_ref (x);
 870
 871   /* ??? We should be remapping types as well, surely.  */
 872   new_decl = build_decl (DECL_SOURCE_LOCATION (decl),
 873                          VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
 874   DECL_CONTEXT (new_decl) = info->context;
 875   DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
 876   DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
 877   TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
 878   TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
 879   TREE_READONLY (new_decl) = TREE_READONLY (decl);
 880   TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
 881   DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
 882   if ((TREE_CODE (decl) == PARM_DECL
 883        || TREE_CODE (decl) == RESULT_DECL
 884        || TREE_CODE (decl) == VAR_DECL)
 885       && DECL_BY_REFERENCE (decl))
 886     DECL_BY_REFERENCE (new_decl) = 1;
 887
 888   SET_DECL_VALUE_EXPR (new_decl, x);
 889   DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
 890
 891   *slot = new_decl;
 892   DECL_CHAIN (new_decl) = info->debug_var_chain;
 893   info->debug_var_chain = new_decl;
 894
 895   if (!optimize
 896       && info->context != target_context
 897       && variably_modified_type_p (TREE_TYPE (decl), NULL))
 898     note_nonlocal_vla_type (info, TREE_TYPE (decl));
 899
 900   return new_decl;
 901 }
 902
 903
 904 /* Callback for walk_gimple_stmt, rewrite all references to VAR
 905    and PARM_DECLs that belong to outer functions.
 906
 907    The rewrite will involve some number of structure accesses back up
 908    the static chain.  E.g. for a variable FOO up one nesting level it'll
 909    be CHAIN->FOO.  For two levels it'll be CHAIN->__chain->FOO.  Further
 910    indirections apply to decls for which use_pointer_in_frame is true.  */
 911
 912 static tree
 913 convert_nonlocal_reference_op (tree *tp, int *walk_subtrees, void *data)
 914 {
 915   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
 916   struct nesting_info *const info = (struct nesting_info *) wi->info;
 917   tree t = *tp;
 918
 919   *walk_subtrees = 0;
 920   switch (TREE_CODE (t))
 921     {
 922     case VAR_DECL:
 923       /* Non-automatic variables are never processed.  */
 924       if (TREE_STATIC (t) || DECL_EXTERNAL (t))
 925         break;
 926       /* FALLTHRU */
 927
 928     case PARM_DECL:
 929       if (decl_function_context (t) != info->context)
 930         {
 931           tree x;
 932           wi->changed = true;
 933
 934           x = get_nonlocal_debug_decl (info, t);
 935           if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
 936             {
 937               tree target_context = decl_function_context (t);
 938               struct nesting_info *i;
 939               for (i = info->outer; i->context != target_context; i = i->outer)
 940                 continue;
 941               x = lookup_field_for_decl (i, t, INSERT);
 942               x = get_frame_field (info, target_context, x, &wi->gsi);
 943               if (use_pointer_in_frame (t))
 944                 {
 945                   x = init_tmp_var (info, x, &wi->gsi);
 946                   x = build_simple_mem_ref (x);
 947                 }
 948             }
 949
 950           if (wi->val_only)
 951             {
 952               if (wi->is_lhs)
 953                 x = save_tmp_var (info, x, &wi->gsi);
 954               else
 955                 x = init_tmp_var (info, x, &wi->gsi);
 956             }
 957
 958           *tp = x;
 959         }
 960       break;
 961
 962     case LABEL_DECL:
 963       /* We're taking the address of a label from a parent function, but
 964          this is not itself a non-local goto.  Mark the label such that it
 965          will not be deleted, much as we would with a label address in
 966          static storage.  */
 967       if (decl_function_context (t) != info->context)
 968         FORCED_LABEL (t) = 1;
 969       break;
 970
 971     case ADDR_EXPR:
 972       {
 973         bool save_val_only = wi->val_only;
 974
 975         wi->val_only = false;
 976         wi->is_lhs = false;
 977         wi->changed = false;
 978         walk_tree (&TREE_OPERAND (t, 0), convert_nonlocal_reference_op, wi, 0);
 979         wi->val_only = true;
 980
 981         if (wi->changed)
 982           {
 983             tree save_context;
 984
 985             /* If we changed anything, we might no longer be directly
 986                referencing a decl.  */
 987             save_context = current_function_decl;
 988             current_function_decl = info->context;
 989             recompute_tree_invariant_for_addr_expr (t);
 990             current_function_decl = save_context;
 991
 992             /* If the callback converted the address argument in a context
 993                where we only accept variables (and min_invariant, presumably),
 994                then compute the address into a temporary.  */
 995             if (save_val_only)
 996               *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
 997                                       t, &wi->gsi);
 998           }
 999       }
1000       break;
1001
1002     case REALPART_EXPR:
1003     case IMAGPART_EXPR:
1004     case COMPONENT_REF:
1005     case ARRAY_REF:
1006     case ARRAY_RANGE_REF:
1007     case BIT_FIELD_REF:
1008       /* Go down this entire nest and just look at the final prefix and
1009          anything that describes the references.  Otherwise, we lose track
1010          of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
1011       wi->val_only = true;
1012       wi->is_lhs = false;
1013       for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1014         {
1015           if (TREE_CODE (t) == COMPONENT_REF)
1016             walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op, wi,
1017                        NULL);
1018           else if (TREE_CODE (t) == ARRAY_REF
1019                    || TREE_CODE (t) == ARRAY_RANGE_REF)
1020             {
1021               walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference_op,
1022                          wi, NULL);
1023               walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op,
1024                          wi, NULL);
1025               walk_tree (&TREE_OPERAND (t, 3), convert_nonlocal_reference_op,
1026                          wi, NULL);
1027             }
1028         }
1029       wi->val_only = false;
1030       walk_tree (tp, convert_nonlocal_reference_op, wi, NULL);
1031       break;
1032
1033     case VIEW_CONVERT_EXPR:
1034       /* Just request to look at the subtrees, leaving val_only and lhs
1035          untouched.  This might actually be for !val_only + lhs, in which
1036          case we don't want to force a replacement by a temporary.  */
1037       *walk_subtrees = 1;
1038       break;
1039
1040     default:
1041       if (!IS_TYPE_OR_DECL_P (t))
1042         {
1043           *walk_subtrees = 1;
1044           wi->val_only = true;
1045           wi->is_lhs = false;
1046         }
1047       break;
1048     }
1049
1050   return NULL_TREE;
1051 }
1052
1053 static tree convert_nonlocal_reference_stmt (gimple_stmt_iterator *, bool *,
1054                                              struct walk_stmt_info *);
1055
1056 /* Helper for convert_nonlocal_references, rewrite all references to VAR
1057    and PARM_DECLs that belong to outer functions.  */
1058
1059 static bool
1060 convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1061 {
1062   struct nesting_info *const info = (struct nesting_info *) wi->info;
1063   bool need_chain = false, need_stmts = false;
1064   tree clause, decl;
1065   int dummy;
1066   bitmap new_suppress;
1067
1068   new_suppress = BITMAP_GGC_ALLOC ();
1069   bitmap_copy (new_suppress, info->suppress_expansion);
1070
1071   for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1072     {
1073       switch (OMP_CLAUSE_CODE (clause))
1074         {
1075         case OMP_CLAUSE_REDUCTION:
1076           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1077             need_stmts = true;
1078           goto do_decl_clause;
1079
1080         case OMP_CLAUSE_LASTPRIVATE:
1081           if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
1082             need_stmts = true;
1083           goto do_decl_clause;
1084
1085         case OMP_CLAUSE_PRIVATE:
1086         case OMP_CLAUSE_FIRSTPRIVATE:
1087         case OMP_CLAUSE_COPYPRIVATE:
1088         case OMP_CLAUSE_SHARED:
1089         do_decl_clause:
1090           decl = OMP_CLAUSE_DECL (clause);
1091           if (TREE_CODE (decl) == VAR_DECL
1092               && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1093             break;
1094           if (decl_function_context (decl) != info->context)
1095             {
1096               bitmap_set_bit (new_suppress, DECL_UID (decl));
1097               OMP_CLAUSE_DECL (clause) = get_nonlocal_debug_decl (info, decl);
1098               if (OMP_CLAUSE_CODE (clause) != OMP_CLAUSE_PRIVATE)
1099                 need_chain = true;
1100             }
1101           break;
1102
1103         case OMP_CLAUSE_SCHEDULE:
1104           if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1105             break;
1106           /* FALLTHRU */
1107         case OMP_CLAUSE_FINAL:
1108         case OMP_CLAUSE_IF:
1109         case OMP_CLAUSE_NUM_THREADS:
1110           wi->val_only = true;
1111           wi->is_lhs = false;
1112           convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
1113                                          &dummy, wi);
1114           break;
1115
1116         case OMP_CLAUSE_NOWAIT:
1117         case OMP_CLAUSE_ORDERED:
1118         case OMP_CLAUSE_DEFAULT:
1119         case OMP_CLAUSE_COPYIN:
1120         case OMP_CLAUSE_COLLAPSE:
1121         case OMP_CLAUSE_UNTIED:
1122         case OMP_CLAUSE_MERGEABLE:
1123           break;
1124
1125         default:
1126           gcc_unreachable ();
1127         }
1128     }
1129
1130   info->suppress_expansion = new_suppress;
1131
1132   if (need_stmts)
1133     for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1134       switch (OMP_CLAUSE_CODE (clause))
1135         {
1136         case OMP_CLAUSE_REDUCTION:
1137           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1138             {
1139               tree old_context
1140                 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1141               DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1142                 = info->context;
1143               walk_body (convert_nonlocal_reference_stmt,
1144                          convert_nonlocal_reference_op, info,
1145                          &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
1146               walk_body (convert_nonlocal_reference_stmt,
1147                          convert_nonlocal_reference_op, info,
1148                          &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
1149               DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1150                 = old_context;
1151             }
1152           break;
1153
1154         case OMP_CLAUSE_LASTPRIVATE:
1155           walk_body (convert_nonlocal_reference_stmt,
1156                      convert_nonlocal_reference_op, info,
1157                      &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
1158           break;
1159
1160         default:
1161           break;
1162         }
1163
1164   return need_chain;
1165 }
1166
1167 /* Create nonlocal debug decls for nonlocal VLA array bounds.  */
1168
1169 static void
1170 note_nonlocal_vla_type (struct nesting_info *info, tree type)
1171 {
1172   while (POINTER_TYPE_P (type) && !TYPE_NAME (type))
1173     type = TREE_TYPE (type);
1174
1175   if (TYPE_NAME (type)
1176       && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1177       && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1178     type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1179
1180   while (POINTER_TYPE_P (type)
1181          || TREE_CODE (type) == VECTOR_TYPE
1182          || TREE_CODE (type) == FUNCTION_TYPE
1183          || TREE_CODE (type) == METHOD_TYPE)
1184     type = TREE_TYPE (type);
1185
1186   if (TREE_CODE (type) == ARRAY_TYPE)
1187     {
1188       tree domain, t;
1189
1190       note_nonlocal_vla_type (info, TREE_TYPE (type));
1191       domain = TYPE_DOMAIN (type);
1192       if (domain)
1193         {
1194           t = TYPE_MIN_VALUE (domain);
1195           if (t && (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
1196               && decl_function_context (t) != info->context)
1197             get_nonlocal_debug_decl (info, t);
1198           t = TYPE_MAX_VALUE (domain);
1199           if (t && (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
1200               && decl_function_context (t) != info->context)
1201             get_nonlocal_debug_decl (info, t);
1202         }
1203     }
1204 }
1205
1206 /* Create nonlocal debug decls for nonlocal VLA array bounds for VLAs
1207    in BLOCK.  */
1208
1209 static void
1210 note_nonlocal_block_vlas (struct nesting_info *info, tree block)
1211 {
1212   tree var;
1213
1214   for (var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
1215     if (TREE_CODE (var) == VAR_DECL
1216         && variably_modified_type_p (TREE_TYPE (var), NULL)
1217         && DECL_HAS_VALUE_EXPR_P (var)
1218         && decl_function_context (var) != info->context)
1219       note_nonlocal_vla_type (info, TREE_TYPE (var));
1220 }
1221
1222 /* Callback for walk_gimple_stmt.  Rewrite all references to VAR and
1223    PARM_DECLs that belong to outer functions.  This handles statements
1224    that are not handled via the standard recursion done in
1225    walk_gimple_stmt.  STMT is the statement to examine, DATA is as in
1226    convert_nonlocal_reference_op.  Set *HANDLED_OPS_P to true if all the
1227    operands of STMT have been handled by this function.  */
1228
1229 static tree
1230 convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1231                                  struct walk_stmt_info *wi)
1232 {
1233   struct nesting_info *info = (struct nesting_info *) wi->info;
1234   tree save_local_var_chain;
1235   bitmap save_suppress;
1236   gimple stmt = gsi_stmt (*gsi);
1237
1238   switch (gimple_code (stmt))
1239     {
1240     case GIMPLE_GOTO:
1241       /* Don't walk non-local gotos for now.  */
1242       if (TREE_CODE (gimple_goto_dest (stmt)) != LABEL_DECL)
1243         {
1244           wi->val_only = true;
1245           wi->is_lhs = false;
1246           *handled_ops_p = true;
1247           return NULL_TREE;
1248         }
1249       break;
1250
1251     case GIMPLE_OMP_PARALLEL:
1252     case GIMPLE_OMP_TASK:
1253       save_suppress = info->suppress_expansion;
1254       if (convert_nonlocal_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
1255                                         wi))
1256         {
1257           tree c, decl;
1258           decl = get_chain_decl (info);
1259           c = build_omp_clause (gimple_location (stmt),
1260                                 OMP_CLAUSE_FIRSTPRIVATE);
1261           OMP_CLAUSE_DECL (c) = decl;
1262           OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
1263           gimple_omp_taskreg_set_clauses (stmt, c);
1264         }
1265
1266       save_local_var_chain = info->new_local_var_chain;
1267       info->new_local_var_chain = NULL;
1268
1269       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1270                  info, gimple_omp_body_ptr (stmt));
1271
1272       if (info->new_local_var_chain)
1273         declare_vars (info->new_local_var_chain,
1274                       gimple_seq_first_stmt (gimple_omp_body (stmt)),
1275                       false);
1276       info->new_local_var_chain = save_local_var_chain;
1277       info->suppress_expansion = save_suppress;
1278       break;
1279
1280     case GIMPLE_OMP_FOR:
1281       save_suppress = info->suppress_expansion;
1282       convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
1283       walk_gimple_omp_for (stmt, convert_nonlocal_reference_stmt,
1284                            convert_nonlocal_reference_op, info);
1285       walk_body (convert_nonlocal_reference_stmt,
1286                  convert_nonlocal_reference_op, info, gimple_omp_body_ptr (stmt));
1287       info->suppress_expansion = save_suppress;
1288       break;
1289
1290     case GIMPLE_OMP_SECTIONS:
1291       save_suppress = info->suppress_expansion;
1292       convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
1293       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1294                  info, gimple_omp_body_ptr (stmt));
1295       info->suppress_expansion = save_suppress;
1296       break;
1297
1298     case GIMPLE_OMP_SINGLE:
1299       save_suppress = info->suppress_expansion;
1300       convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
1301       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1302                  info, gimple_omp_body_ptr (stmt));
1303       info->suppress_expansion = save_suppress;
1304       break;
1305
1306     case GIMPLE_OMP_TARGET:
1307       save_suppress = info->suppress_expansion;
1308       convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt), wi);
1309       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1310                  info, gimple_omp_body_ptr (stmt));
1311       info->suppress_expansion = save_suppress;
1312       break;
1313
1314     case GIMPLE_OMP_TEAMS:
1315       save_suppress = info->suppress_expansion;
1316       convert_nonlocal_omp_clauses (gimple_omp_teams_clauses_ptr (stmt), wi);
1317       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1318                  info, gimple_omp_body_ptr (stmt));
1319       info->suppress_expansion = save_suppress;
1320       break;
1321
1322     case GIMPLE_OMP_SECTION:
1323     case GIMPLE_OMP_MASTER:
1324     case GIMPLE_OMP_TASKGROUP:
1325     case GIMPLE_OMP_ORDERED:
1326       walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1327                  info, gimple_omp_body_ptr (stmt));
1328       break;
1329
1330     case GIMPLE_BIND:
1331       if (!optimize && gimple_bind_block (stmt))
1332         note_nonlocal_block_vlas (info, gimple_bind_block (stmt));
1333
1334       *handled_ops_p = false;
1335       return NULL_TREE;
1336
1337     case GIMPLE_COND:
1338       wi->val_only = true;
1339       wi->is_lhs = false;
1340       *handled_ops_p = false;
1341       return NULL_TREE;
1342
1343     default:
1344       /* For every other statement that we are not interested in
1345          handling here, let the walker traverse the operands.  */
1346       *handled_ops_p = false;
1347       return NULL_TREE;
1348     }
1349
1350   /* We have handled all of STMT operands, no need to traverse the operands.  */
1351   *handled_ops_p = true;
1352   return NULL_TREE;
1353 }
1354
1355
1356 /* A subroutine of convert_local_reference.  Create a local variable
1357    in the parent function with DECL_VALUE_EXPR set to reference the
1358    field in FRAME.  This is used both for debug info and in OpenMP
1359    lowering.  */
1360
1361 static tree
1362 get_local_debug_decl (struct nesting_info *info, tree decl, tree field)
1363 {
1364   tree x, new_decl;
1365   void **slot;
1366
1367   slot = pointer_map_insert (info->var_map, decl);
1368   if (*slot)
1369     return (tree) *slot;
1370
1371   /* Make sure frame_decl gets created.  */
1372   (void) get_frame_type (info);
1373   x = info->frame_decl;
1374   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1375
1376   new_decl = build_decl (DECL_SOURCE_LOCATION (decl),
1377                          VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
1378   DECL_CONTEXT (new_decl) = info->context;
1379   DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
1380   DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
1381   TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
1382   TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
1383   TREE_READONLY (new_decl) = TREE_READONLY (decl);
1384   TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
1385   DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
1386   if ((TREE_CODE (decl) == PARM_DECL
1387        || TREE_CODE (decl) == RESULT_DECL
1388        || TREE_CODE (decl) == VAR_DECL)
1389       && DECL_BY_REFERENCE (decl))
1390     DECL_BY_REFERENCE (new_decl) = 1;
1391
1392   SET_DECL_VALUE_EXPR (new_decl, x);
1393   DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
1394   *slot = new_decl;
1395
1396   DECL_CHAIN (new_decl) = info->debug_var_chain;
1397   info->debug_var_chain = new_decl;
1398
1399   /* Do not emit debug info twice.  */
1400   DECL_IGNORED_P (decl) = 1;
1401
1402   return new_decl;
1403 }
1404
1405
1406 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1407    and PARM_DECLs that were referenced by inner nested functions.
1408    The rewrite will be a structure reference to the local frame variable.  */
1409
1410 static bool convert_local_omp_clauses (tree *, struct walk_stmt_info *);
1411
1412 static tree
1413 convert_local_reference_op (tree *tp, int *walk_subtrees, void *data)
1414 {
1415   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1416   struct nesting_info *const info = (struct nesting_info *) wi->info;
1417   tree t = *tp, field, x;
1418   bool save_val_only;
1419
1420   *walk_subtrees = 0;
1421   switch (TREE_CODE (t))
1422     {
1423     case VAR_DECL:
1424       /* Non-automatic variables are never processed.  */
1425       if (TREE_STATIC (t) || DECL_EXTERNAL (t))
1426         break;
1427       /* FALLTHRU */
1428
1429     case PARM_DECL:
1430       if (decl_function_context (t) == info->context)
1431         {
1432           /* If we copied a pointer to the frame, then the original decl
1433              is used unchanged in the parent function.  */
1434           if (use_pointer_in_frame (t))
1435             break;
1436
1437           /* No need to transform anything if no child references the
1438              variable.  */
1439           field = lookup_field_for_decl (info, t, NO_INSERT);
1440           if (!field)
1441             break;
1442           wi->changed = true;
1443
1444           x = get_local_debug_decl (info, t, field);
1445           if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
1446             x = get_frame_field (info, info->context, field, &wi->gsi);
1447
1448           if (wi->val_only)
1449             {
1450               if (wi->is_lhs)
1451                 x = save_tmp_var (info, x, &wi->gsi);
1452               else
1453                 x = init_tmp_var (info, x, &wi->gsi);
1454             }
1455
1456           *tp = x;
1457         }
1458       break;
1459
1460     case ADDR_EXPR:
1461       save_val_only = wi->val_only;
1462       wi->val_only = false;
1463       wi->is_lhs = false;
1464       wi->changed = false;
1465       walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op, wi, NULL);
1466       wi->val_only = save_val_only;
1467
1468       /* If we converted anything ... */
1469       if (wi->changed)
1470         {
1471           tree save_context;
1472
1473           /* Then the frame decl is now addressable.  */
1474           TREE_ADDRESSABLE (info->frame_decl) = 1;
1475
1476           save_context = current_function_decl;
1477           current_function_decl = info->context;
1478           recompute_tree_invariant_for_addr_expr (t);
1479           current_function_decl = save_context;
1480
1481           /* If we are in a context where we only accept values, then
1482              compute the address into a temporary.  */
1483           if (save_val_only)
1484             *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
1485                                     t, &wi->gsi);
1486         }
1487       break;
1488
1489     case REALPART_EXPR:
1490     case IMAGPART_EXPR:
1491     case COMPONENT_REF:
1492     case ARRAY_REF:
1493     case ARRAY_RANGE_REF:
1494     case BIT_FIELD_REF:
1495       /* Go down this entire nest and just look at the final prefix and
1496          anything that describes the references.  Otherwise, we lose track
1497          of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
1498       save_val_only = wi->val_only;
1499       wi->val_only = true;
1500       wi->is_lhs = false;
1501       for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1502         {
1503           if (TREE_CODE (t) == COMPONENT_REF)
1504             walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
1505                        NULL);
1506           else if (TREE_CODE (t) == ARRAY_REF
1507                    || TREE_CODE (t) == ARRAY_RANGE_REF)
1508             {
1509               walk_tree (&TREE_OPERAND (t, 1), convert_local_reference_op, wi,
1510                          NULL);
1511               walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
1512                          NULL);
1513               walk_tree (&TREE_OPERAND (t, 3), convert_local_reference_op, wi,
1514                          NULL);
1515             }
1516         }
1517       wi->val_only = false;
1518       walk_tree (tp, convert_local_reference_op, wi, NULL);
1519       wi->val_only = save_val_only;
1520       break;
1521
1522     case MEM_REF:
1523       save_val_only = wi->val_only;
1524       wi->val_only = true;
1525       wi->is_lhs = false;
1526       walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op,
1527                  wi, NULL);
1528       /* We need to re-fold the MEM_REF as component references as
1529          part of a ADDR_EXPR address are not allowed.  But we cannot
1530          fold here, as the chain record type is not yet finalized.  */
1531       if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
1532           && !DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
1533         pointer_set_insert (info->mem_refs, tp);
1534       wi->val_only = save_val_only;
1535       break;
1536
1537     case VIEW_CONVERT_EXPR:
1538       /* Just request to look at the subtrees, leaving val_only and lhs
1539          untouched.  This might actually be for !val_only + lhs, in which
1540          case we don't want to force a replacement by a temporary.  */
1541       *walk_subtrees = 1;
1542       break;
1543
1544     default:
1545       if (!IS_TYPE_OR_DECL_P (t))
1546         {
1547           *walk_subtrees = 1;
1548           wi->val_only = true;
1549           wi->is_lhs = false;
1550         }
1551       break;
1552     }
1553
1554   return NULL_TREE;
1555 }
1556
1557 static tree convert_local_reference_stmt (gimple_stmt_iterator *, bool *,
1558                                           struct walk_stmt_info *);
1559
1560 /* Helper for convert_local_reference.  Convert all the references in
1561    the chain of clauses at *PCLAUSES.  WI is as in convert_local_reference.  */
1562
1563 static bool
1564 convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1565 {
1566   struct nesting_info *const info = (struct nesting_info *) wi->info;
1567   bool need_frame = false, need_stmts = false;
1568   tree clause, decl;
1569   int dummy;
1570   bitmap new_suppress;
1571
1572   new_suppress = BITMAP_GGC_ALLOC ();
1573   bitmap_copy (new_suppress, info->suppress_expansion);
1574
1575   for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1576     {
1577       switch (OMP_CLAUSE_CODE (clause))
1578         {
1579         case OMP_CLAUSE_REDUCTION:
1580           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1581             need_stmts = true;
1582           goto do_decl_clause;
1583
1584         case OMP_CLAUSE_LASTPRIVATE:
1585           if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
1586             need_stmts = true;
1587           goto do_decl_clause;
1588
1589         case OMP_CLAUSE_PRIVATE:
1590         case OMP_CLAUSE_FIRSTPRIVATE:
1591         case OMP_CLAUSE_COPYPRIVATE:
1592         case OMP_CLAUSE_SHARED:
1593         do_decl_clause:
1594           decl = OMP_CLAUSE_DECL (clause);
1595           if (TREE_CODE (decl) == VAR_DECL
1596               && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1597             break;
1598           if (decl_function_context (decl) == info->context
1599               && !use_pointer_in_frame (decl))
1600             {
1601               tree field = lookup_field_for_decl (info, decl, NO_INSERT);
1602               if (field)
1603                 {
1604                   bitmap_set_bit (new_suppress, DECL_UID (decl));
1605                   OMP_CLAUSE_DECL (clause)
1606                     = get_local_debug_decl (info, decl, field);
1607                   need_frame = true;
1608                 }
1609             }
1610           break;
1611
1612         case OMP_CLAUSE_SCHEDULE:
1613           if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1614             break;
1615           /* FALLTHRU */
1616         case OMP_CLAUSE_FINAL:
1617         case OMP_CLAUSE_IF:
1618         case OMP_CLAUSE_NUM_THREADS:
1619           wi->val_only = true;
1620           wi->is_lhs = false;
1621           convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause, 0), &dummy,
1622                                       wi);
1623           break;
1624
1625         case OMP_CLAUSE_NOWAIT:
1626         case OMP_CLAUSE_ORDERED:
1627         case OMP_CLAUSE_DEFAULT:
1628         case OMP_CLAUSE_COPYIN:
1629         case OMP_CLAUSE_COLLAPSE:
1630         case OMP_CLAUSE_UNTIED:
1631         case OMP_CLAUSE_MERGEABLE:
1632           break;
1633
1634         default:
1635           gcc_unreachable ();
1636         }
1637     }
1638
1639   info->suppress_expansion = new_suppress;
1640
1641   if (need_stmts)
1642     for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1643       switch (OMP_CLAUSE_CODE (clause))
1644         {
1645         case OMP_CLAUSE_REDUCTION:
1646           if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1647             {
1648               tree old_context
1649                 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1650               DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1651                 = info->context;
1652               walk_body (convert_local_reference_stmt,
1653                          convert_local_reference_op, info,
1654                          &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
1655               walk_body (convert_local_reference_stmt,
1656                          convert_local_reference_op, info,
1657                          &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
1658               DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1659                 = old_context;
1660             }
1661           break;
1662
1663         case OMP_CLAUSE_LASTPRIVATE:
1664           walk_body (convert_local_reference_stmt,
1665                      convert_local_reference_op, info,
1666                      &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
1667           break;
1668
1669         default:
1670           break;
1671         }
1672
1673   return need_frame;
1674 }
1675
1676
1677 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1678    and PARM_DECLs that were referenced by inner nested functions.
1679    The rewrite will be a structure reference to the local frame variable.  */
1680
1681 static tree
1682 convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1683                               struct walk_stmt_info *wi)
1684 {
1685   struct nesting_info *info = (struct nesting_info *) wi->info;
1686   tree save_local_var_chain;
1687   bitmap save_suppress;
1688   gimple stmt = gsi_stmt (*gsi);
1689
1690   switch (gimple_code (stmt))
1691     {
1692     case GIMPLE_OMP_PARALLEL:
1693     case GIMPLE_OMP_TASK:
1694       save_suppress = info->suppress_expansion;
1695       if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
1696                                      wi))
1697         {
1698           tree c;
1699           (void) get_frame_type (info);
1700           c = build_omp_clause (gimple_location (stmt),
1701                                 OMP_CLAUSE_SHARED);
1702           OMP_CLAUSE_DECL (c) = info->frame_decl;
1703           OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
1704           gimple_omp_taskreg_set_clauses (stmt, c);
1705         }
1706
1707       save_local_var_chain = info->new_local_var_chain;
1708       info->new_local_var_chain = NULL;
1709
1710       walk_body (convert_local_reference_stmt, convert_local_reference_op, info,
1711                  gimple_omp_body_ptr (stmt));
1712
1713       if (info->new_local_var_chain)
1714         declare_vars (info->new_local_var_chain,
1715                       gimple_seq_first_stmt (gimple_omp_body (stmt)), false);
1716       info->new_local_var_chain = save_local_var_chain;
1717       info->suppress_expansion = save_suppress;
1718       break;
1719
1720     case GIMPLE_OMP_FOR:
1721       save_suppress = info->suppress_expansion;
1722       convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
1723       walk_gimple_omp_for (stmt, convert_local_reference_stmt,
1724                            convert_local_reference_op, info);
1725       walk_body (convert_local_reference_stmt, convert_local_reference_op,
1726                  info, gimple_omp_body_ptr (stmt));
1727       info->suppress_expansion = save_suppress;
1728       break;
1729
1730     case GIMPLE_OMP_SECTIONS:
1731       save_suppress = info->suppress_expansion;
1732       convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
1733       walk_body (convert_local_reference_stmt, convert_local_reference_op,
1734                  info, gimple_omp_body_ptr (stmt));
1735       info->suppress_expansion = save_suppress;
1736       break;
1737
1738     case GIMPLE_OMP_SINGLE:
1739       save_suppress = info->suppress_expansion;
1740       convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
1741       walk_body (convert_local_reference_stmt, convert_local_reference_op,
1742                  info, gimple_omp_body_ptr (stmt));
1743       info->suppress_expansion = save_suppress;
1744       break;
1745
1746     case GIMPLE_OMP_TARGET:
1747       save_suppress = info->suppress_expansion;
1748       convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt), wi);
1749       walk_body (convert_local_reference_stmt, convert_local_reference_op,
1750                  info, gimple_omp_body_ptr (stmt));
1751       info->suppress_expansion = save_suppress;
1752       break;
1753
1754     case GIMPLE_OMP_TEAMS:
1755       save_suppress = info->suppress_expansion;
1756       convert_local_omp_clauses (gimple_omp_teams_clauses_ptr (stmt), wi);
1757       walk_body (convert_local_reference_stmt, convert_local_reference_op,
1758                  info, gimple_omp_body_ptr (stmt));
1759       info->suppress_expansion = save_suppress;
1760       break;
1761
1762     case GIMPLE_OMP_SECTION:
1763     case GIMPLE_OMP_MASTER:
1764     case GIMPLE_OMP_TASKGROUP:
1765     case GIMPLE_OMP_ORDERED:
1766       walk_body (convert_local_reference_stmt, convert_local_reference_op,
1767                  info, gimple_omp_body_ptr (stmt));
1768       break;
1769
1770     case GIMPLE_COND:
1771       wi->val_only = true;
1772       wi->is_lhs = false;
1773       *handled_ops_p = false;
1774       return NULL_TREE;
1775
1776     case GIMPLE_ASSIGN:
1777       if (gimple_clobber_p (stmt))
1778         {
1779           tree lhs = gimple_assign_lhs (stmt);
1780           if (!use_pointer_in_frame (lhs)
1781               && lookup_field_for_decl (info, lhs, NO_INSERT))
1782             {
1783               gsi_replace (gsi, gimple_build_nop (), true);
1784               break;
1785             }
1786         }
1787       *handled_ops_p = false;
1788       return NULL_TREE;
1789
1790     default:
1791       /* For every other statement that we are not interested in
1792          handling here, let the walker traverse the operands.  */
1793       *handled_ops_p = false;
1794       return NULL_TREE;
1795     }
1796
1797   /* Indicate that we have handled all the operands ourselves.  */
1798   *handled_ops_p = true;
1799   return NULL_TREE;
1800 }
1801
1802
1803 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_GOTOs
1804    that reference labels from outer functions.  The rewrite will be a
1805    call to __builtin_nonlocal_goto.  */
1806
1807 static tree
1808 convert_nl_goto_reference (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1809                            struct walk_stmt_info *wi)
1810 {
1811   struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
1812   tree label, new_label, target_context, x, field;
1813   void **slot;
1814   gimple call;
1815   gimple stmt = gsi_stmt (*gsi);
1816
1817   if (gimple_code (stmt) != GIMPLE_GOTO)
1818     {
1819       *handled_ops_p = false;
1820       return NULL_TREE;
1821     }
1822
1823   label = gimple_goto_dest (stmt);
1824   if (TREE_CODE (label) != LABEL_DECL)
1825     {
1826       *handled_ops_p = false;
1827       return NULL_TREE;
1828     }
1829
1830   target_context = decl_function_context (label);
1831   if (target_context == info->context)
1832     {
1833       *handled_ops_p = false;
1834       return NULL_TREE;
1835     }
1836
1837   for (i = info->outer; target_context != i->context; i = i->outer)
1838     continue;
1839
1840   /* The original user label may also be use for a normal goto, therefore
1841      we must create a new label that will actually receive the abnormal
1842      control transfer.  This new label will be marked LABEL_NONLOCAL; this
1843      mark will trigger proper behavior in the cfg, as well as cause the
1844      (hairy target-specific) non-local goto receiver code to be generated
1845      when we expand rtl.  Enter this association into var_map so that we
1846      can insert the new label into the IL during a second pass.  */
1847   slot = pointer_map_insert (i->var_map, label);
1848   if (*slot == NULL)
1849     {
1850       new_label = create_artificial_label (UNKNOWN_LOCATION);
1851       DECL_NONLOCAL (new_label) = 1;
1852       *slot = new_label;
1853     }
1854   else
1855     new_label = (tree) *slot;
1856
1857   /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field).  */
1858   field = get_nl_goto_field (i);
1859   x = get_frame_field (info, target_context, field, gsi);
1860   x = build_addr (x, target_context);
1861   x = gsi_gimplify_val (info, x, gsi);
1862   call = gimple_build_call (builtin_decl_implicit (BUILT_IN_NONLOCAL_GOTO),
1863                             2, build_addr (new_label, target_context), x);
1864   gsi_replace (gsi, call, false);
1865
1866   /* We have handled all of STMT's operands, no need to keep going.  */
1867   *handled_ops_p = true;
1868   return NULL_TREE;
1869 }
1870
1871
1872 /* Called via walk_function+walk_tree, rewrite all GIMPLE_LABELs whose labels
1873    are referenced via nonlocal goto from a nested function.  The rewrite
1874    will involve installing a newly generated DECL_NONLOCAL label, and
1875    (potentially) a branch around the rtl gunk that is assumed to be
1876    attached to such a label.  */
1877
1878 static tree
1879 convert_nl_goto_receiver (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1880                           struct walk_stmt_info *wi)
1881 {
1882   struct nesting_info *const info = (struct nesting_info *) wi->info;
1883   tree label, new_label;
1884   gimple_stmt_iterator tmp_gsi;
1885   void **slot;
1886   gimple stmt = gsi_stmt (*gsi);
1887
1888   if (gimple_code (stmt) != GIMPLE_LABEL)
1889     {
1890       *handled_ops_p = false;
1891       return NULL_TREE;
1892     }
1893
1894   label = gimple_label_label (stmt);
1895
1896   slot = pointer_map_contains (info->var_map, label);
1897   if (!slot)
1898     {
1899       *handled_ops_p = false;
1900       return NULL_TREE;
1901     }
1902
1903   /* If there's any possibility that the previous statement falls through,
1904      then we must branch around the new non-local label.  */
1905   tmp_gsi = wi->gsi;
1906   gsi_prev (&tmp_gsi);
1907   if (gsi_end_p (tmp_gsi) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi)))
1908     {
1909       gimple stmt = gimple_build_goto (label);
1910       gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
1911     }
1912
1913   new_label = (tree) *slot;
1914   stmt = gimple_build_label (new_label);
1915   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
1916
1917   *handled_ops_p = true;
1918   return NULL_TREE;
1919 }
1920
1921
1922 /* Called via walk_function+walk_stmt, rewrite all references to addresses
1923    of nested functions that require the use of trampolines.  The rewrite
1924    will involve a reference a trampoline generated for the occasion.  */
1925
1926 static tree
1927 convert_tramp_reference_op (tree *tp, int *walk_subtrees, void *data)
1928 {
1929   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1930   struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
1931   tree t = *tp, decl, target_context, x, builtin;
1932   gimple call;
1933
1934   *walk_subtrees = 0;
1935   switch (TREE_CODE (t))
1936     {
1937     case ADDR_EXPR:
1938       /* Build
1939            T.1 = &CHAIN->tramp;
1940            T.2 = __builtin_adjust_trampoline (T.1);
1941            T.3 = (func_type)T.2;
1942       */
1943
1944       decl = TREE_OPERAND (t, 0);
1945       if (TREE_CODE (decl) != FUNCTION_DECL)
1946         break;
1947
1948       /* Only need to process nested functions.  */
1949       target_context = decl_function_context (decl);
1950       if (!target_context)
1951         break;
1952
1953       /* If the nested function doesn't use a static chain, then
1954          it doesn't need a trampoline.  */
1955       if (!DECL_STATIC_CHAIN (decl))
1956         break;
1957
1958       /* If we don't want a trampoline, then don't build one.  */
1959       if (TREE_NO_TRAMPOLINE (t))
1960         break;
1961
1962       /* Lookup the immediate parent of the callee, as that's where
1963          we need to insert the trampoline.  */
1964       for (i = info; i->context != target_context; i = i->outer)
1965         continue;
1966       x = lookup_tramp_for_decl (i, decl, INSERT);
1967
1968       /* Compute the address of the field holding the trampoline.  */
1969       x = get_frame_field (info, target_context, x, &wi->gsi);
1970       x = build_addr (x, target_context);
1971       x = gsi_gimplify_val (info, x, &wi->gsi);
1972
1973       /* Do machine-specific ugliness.  Normally this will involve
1974          computing extra alignment, but it can really be anything.  */
1975       builtin = builtin_decl_implicit (BUILT_IN_ADJUST_TRAMPOLINE);
1976       call = gimple_build_call (builtin, 1, x);
1977       x = init_tmp_var_with_call (info, &wi->gsi, call);
1978
1979       /* Cast back to the proper function type.  */
1980       x = build1 (NOP_EXPR, TREE_TYPE (t), x);
1981       x = init_tmp_var (info, x, &wi->gsi);
1982
1983       *tp = x;
1984       break;
1985
1986     default:
1987       if (!IS_TYPE_OR_DECL_P (t))
1988         *walk_subtrees = 1;
1989       break;
1990     }
1991
1992   return NULL_TREE;
1993 }
1994
1995
1996 /* Called via walk_function+walk_gimple_stmt, rewrite all references
1997    to addresses of nested functions that require the use of
1998    trampolines.  The rewrite will involve a reference a trampoline
1999    generated for the occasion.  */
2000
2001 static tree
2002 convert_tramp_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2003                               struct walk_stmt_info *wi)
2004 {
2005   struct nesting_info *info = (struct nesting_info *) wi->info;
2006   gimple stmt = gsi_stmt (*gsi);
2007
2008   switch (gimple_code (stmt))
2009     {
2010     case GIMPLE_CALL:
2011       {
2012         /* Only walk call arguments, lest we generate trampolines for
2013            direct calls.  */
2014         unsigned long i, nargs = gimple_call_num_args (stmt);
2015         for (i = 0; i < nargs; i++)
2016           walk_tree (gimple_call_arg_ptr (stmt, i), convert_tramp_reference_op,
2017                      wi, NULL);
2018         break;
2019       }
2020
2021     case GIMPLE_OMP_PARALLEL:
2022     case GIMPLE_OMP_TASK:
2023       {
2024         tree save_local_var_chain;
2025         walk_gimple_op (stmt, convert_tramp_reference_op, wi);
2026         save_local_var_chain = info->new_local_var_chain;
2027         info->new_local_var_chain = NULL;
2028         walk_body (convert_tramp_reference_stmt, convert_tramp_reference_op,
2029                    info, gimple_omp_body_ptr (stmt));
2030         if (info->new_local_var_chain)
2031           declare_vars (info->new_local_var_chain,
2032                         gimple_seq_first_stmt (gimple_omp_body (stmt)),
2033                         false);
2034         info->new_local_var_chain = save_local_var_chain;
2035       }
2036       break;
2037
2038     default:
2039       *handled_ops_p = false;
2040       return NULL_TREE;
2041       break;
2042     }
2043
2044   *handled_ops_p = true;
2045   return NULL_TREE;
2046 }
2047
2048
2049
2050 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_CALLs
2051    that reference nested functions to make sure that the static chain
2052    is set up properly for the call.  */
2053
2054 static tree
2055 convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2056                      struct walk_stmt_info *wi)
2057 {
2058   struct nesting_info *const info = (struct nesting_info *) wi->info;
2059   tree decl, target_context;
2060   char save_static_chain_added;
2061   int i;
2062   gimple stmt = gsi_stmt (*gsi);
2063
2064   switch (gimple_code (stmt))
2065     {
2066     case GIMPLE_CALL:
2067       if (gimple_call_chain (stmt))
2068         break;
2069       decl = gimple_call_fndecl (stmt);
2070       if (!decl)
2071         break;
2072       target_context = decl_function_context (decl);
2073       if (target_context && DECL_STATIC_CHAIN (decl))
2074         {
2075           gimple_call_set_chain (stmt, get_static_chain (info, target_context,
2076                                                          &wi->gsi));
2077           info->static_chain_added |= (1 << (info->context != target_context));
2078         }
2079       break;
2080
2081     case GIMPLE_OMP_PARALLEL:
2082     case GIMPLE_OMP_TASK:
2083       save_static_chain_added = info->static_chain_added;
2084       info->static_chain_added = 0;
2085       walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
2086       for (i = 0; i < 2; i++)
2087         {
2088           tree c, decl;
2089           if ((info->static_chain_added & (1 << i)) == 0)
2090             continue;
2091           decl = i ? get_chain_decl (info) : info->frame_decl;
2092           /* Don't add CHAIN.* or FRAME.* twice.  */
2093           for (c = gimple_omp_taskreg_clauses (stmt);
2094                c;
2095                c = OMP_CLAUSE_CHAIN (c))
2096             if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
2097                  || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
2098                 && OMP_CLAUSE_DECL (c) == decl)
2099               break;
2100           if (c == NULL)
2101             {
2102               c = build_omp_clause (gimple_location (stmt),
2103                                     i ? OMP_CLAUSE_FIRSTPRIVATE
2104                                     : OMP_CLAUSE_SHARED);
2105               OMP_CLAUSE_DECL (c) = decl;
2106               OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
2107               gimple_omp_taskreg_set_clauses (stmt, c);
2108             }
2109         }
2110       info->static_chain_added |= save_static_chain_added;
2111       break;
2112
2113     case GIMPLE_OMP_FOR:
2114       walk_body (convert_gimple_call, NULL, info,
2115                  gimple_omp_for_pre_body_ptr (stmt));
2116       /* FALLTHRU */
2117     case GIMPLE_OMP_SECTIONS:
2118     case GIMPLE_OMP_SECTION:
2119     case GIMPLE_OMP_SINGLE:
2120     case GIMPLE_OMP_TARGET:
2121     case GIMPLE_OMP_TEAMS:
2122     case GIMPLE_OMP_MASTER:
2123     case GIMPLE_OMP_TASKGROUP:
2124     case GIMPLE_OMP_ORDERED:
2125     case GIMPLE_OMP_CRITICAL:
2126       walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
2127       break;
2128
2129     default:
2130       /* Keep looking for other operands.  */
2131       *handled_ops_p = false;
2132       return NULL_TREE;
2133     }
2134
2135   *handled_ops_p = true;
2136   return NULL_TREE;
2137 }
2138
2139 /* Walk the nesting tree starting with ROOT.  Convert all trampolines and
2140    call expressions.  At the same time, determine if a nested function
2141    actually uses its static chain; if not, remember that.  */
2142
2143 static void
2144 convert_all_function_calls (struct nesting_info *root)
2145 {
2146   unsigned int chain_count = 0, old_chain_count, iter_count;
2147   struct nesting_info *n;
2148
2149   /* First, optimistically clear static_chain for all decls that haven't
2150      used the static chain already for variable access.  */
2151   FOR_EACH_NEST_INFO (n, root)
2152     {
2153       tree decl = n->context;
2154       if (!n->outer || (!n->chain_decl && !n->chain_field))
2155         {
2156           DECL_STATIC_CHAIN (decl) = 0;
2157           if (dump_file && (dump_flags & TDF_DETAILS))
2158             fprintf (dump_file, "Guessing no static-chain for %s\n",
2159                      lang_hooks.decl_printable_name (decl, 2));
2160         }
2161       else
2162         DECL_STATIC_CHAIN (decl) = 1;
2163       chain_count += DECL_STATIC_CHAIN (decl);
2164     }
2165
2166   /* Walk the functions and perform transformations.  Note that these
2167      transformations can induce new uses of the static chain, which in turn
2168      require re-examining all users of the decl.  */
2169   /* ??? It would make sense to try to use the call graph to speed this up,
2170      but the call graph hasn't really been built yet.  Even if it did, we
2171      would still need to iterate in this loop since address-of references
2172      wouldn't show up in the callgraph anyway.  */
2173   iter_count = 0;
2174   do
2175     {
2176       old_chain_count = chain_count;
2177       chain_count = 0;
2178       iter_count++;
2179
2180       if (dump_file && (dump_flags & TDF_DETAILS))
2181         fputc ('\n', dump_file);
2182
2183       FOR_EACH_NEST_INFO (n, root)
2184         {
2185           tree decl = n->context;
2186           walk_function (convert_tramp_reference_stmt,
2187                          convert_tramp_reference_op, n);
2188           walk_function (convert_gimple_call, NULL, n);
2189           chain_count += DECL_STATIC_CHAIN (decl);
2190         }
2191     }
2192   while (chain_count != old_chain_count);
2193
2194   if (dump_file && (dump_flags & TDF_DETAILS))
2195     fprintf (dump_file, "convert_all_function_calls iterations: %u\n\n",
2196              iter_count);
2197 }
2198
2199 struct nesting_copy_body_data
2200 {
2201   copy_body_data cb;
2202   struct nesting_info *root;
2203 };
2204
2205 /* A helper subroutine for debug_var_chain type remapping.  */
2206
2207 static tree
2208 nesting_copy_decl (tree decl, copy_body_data *id)
2209 {
2210   struct nesting_copy_body_data *nid = (struct nesting_copy_body_data *) id;
2211   void **slot = pointer_map_contains (nid->root->var_map, decl);
2212
2213   if (slot)
2214     return (tree) *slot;
2215
2216   if (TREE_CODE (decl) == TYPE_DECL && DECL_ORIGINAL_TYPE (decl))
2217     {
2218       tree new_decl = copy_decl_no_change (decl, id);
2219       DECL_ORIGINAL_TYPE (new_decl)
2220         = remap_type (DECL_ORIGINAL_TYPE (decl), id);
2221       return new_decl;
2222     }
2223
2224   if (TREE_CODE (decl) == VAR_DECL
2225       || TREE_CODE (decl) == PARM_DECL
2226       || TREE_CODE (decl) == RESULT_DECL)
2227     return decl;
2228
2229   return copy_decl_no_change (decl, id);
2230 }
2231
2232 /* A helper function for remap_vla_decls.  See if *TP contains
2233    some remapped variables.  */
2234
2235 static tree
2236 contains_remapped_vars (tree *tp, int *walk_subtrees, void *data)
2237 {
2238   struct nesting_info *root = (struct nesting_info *) data;
2239   tree t = *tp;
2240   void **slot;
2241
2242   if (DECL_P (t))
2243     {
2244       *walk_subtrees = 0;
2245       slot = pointer_map_contains (root->var_map, t);
2246
2247       if (slot)
2248         return (tree) *slot;
2249     }
2250   return NULL;
2251 }
2252
2253 /* Remap VLA decls in BLOCK and subblocks if remapped variables are
2254    involved.  */
2255
2256 static void
2257 remap_vla_decls (tree block, struct nesting_info *root)
2258 {
2259   tree var, subblock, val, type;
2260   struct nesting_copy_body_data id;
2261
2262   for (subblock = BLOCK_SUBBLOCKS (block);
2263        subblock;
2264        subblock = BLOCK_CHAIN (subblock))
2265     remap_vla_decls (subblock, root);
2266
2267   for (var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
2268     if (TREE_CODE (var) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (var))
2269       {
2270         val = DECL_VALUE_EXPR (var);
2271         type = TREE_TYPE (var);
2272
2273         if (!(TREE_CODE (val) == INDIRECT_REF
2274               && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
2275               && variably_modified_type_p (type, NULL)))
2276           continue;
2277
2278         if (pointer_map_contains (root->var_map, TREE_OPERAND (val, 0))
2279             || walk_tree (&type, contains_remapped_vars, root, NULL))
2280           break;
2281       }
2282
2283   if (var == NULL_TREE)
2284     return;
2285
2286   memset (&id, 0, sizeof (id));
2287   id.cb.copy_decl = nesting_copy_decl;
2288   id.cb.decl_map = pointer_map_create ();
2289   id.root = root;
2290
2291   for (; var; var = DECL_CHAIN (var))
2292     if (TREE_CODE (var) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (var))
2293       {
2294         struct nesting_info *i;
2295         tree newt, context;
2296         void **slot;
2297
2298         val = DECL_VALUE_EXPR (var);
2299         type = TREE_TYPE (var);
2300
2301         if (!(TREE_CODE (val) == INDIRECT_REF
2302               && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
2303               && variably_modified_type_p (type, NULL)))
2304           continue;
2305
2306         slot = pointer_map_contains (root->var_map, TREE_OPERAND (val, 0));
2307         if (!slot && !walk_tree (&type, contains_remapped_vars, root, NULL))
2308           continue;
2309
2310         context = decl_function_context (var);
2311         for (i = root; i; i = i->outer)
2312           if (i->context == context)
2313             break;
2314
2315         if (i == NULL)
2316           continue;
2317
2318         /* Fully expand value expressions.  This avoids having debug variables
2319            only referenced from them and that can be swept during GC.  */
2320         if (slot)
2321           {
2322             tree t = (tree) *slot;
2323             gcc_assert (DECL_P (t) && DECL_HAS_VALUE_EXPR_P (t));
2324             val = build1 (INDIRECT_REF, TREE_TYPE (val), DECL_VALUE_EXPR (t));
2325           }
2326
2327         id.cb.src_fn = i->context;
2328         id.cb.dst_fn = i->context;
2329         id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
2330
2331         TREE_TYPE (var) = newt = remap_type (type, &id.cb);
2332         while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
2333           {
2334             newt = TREE_TYPE (newt);
2335             type = TREE_TYPE (type);
2336           }
2337         if (TYPE_NAME (newt)
2338             && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
2339             && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
2340             && newt != type
2341             && TYPE_NAME (newt) == TYPE_NAME (type))
2342           TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
2343
2344         walk_tree (&val, copy_tree_body_r, &id.cb, NULL);
2345         if (val != DECL_VALUE_EXPR (var))
2346           SET_DECL_VALUE_EXPR (var, val);
2347       }
2348
2349   pointer_map_destroy (id.cb.decl_map);
2350 }
2351
2352 /* Fold the MEM_REF *E.  */
2353 static bool
2354 fold_mem_refs (const void *e, void *data ATTRIBUTE_UNUSED)
2355 {
2356   tree *ref_p = CONST_CAST2 (tree *, const tree *, (const tree *)e);
2357   *ref_p = fold (*ref_p);
2358   return true;
2359 }
2360
2361 /* Do "everything else" to clean up or complete state collected by the
2362    various walking passes -- lay out the types and decls, generate code
2363    to initialize the frame decl, store critical expressions in the
2364    struct function for rtl to find.  */
2365
2366 static void
2367 finalize_nesting_tree_1 (struct nesting_info *root)
2368 {
2369   gimple_seq stmt_list;
2370   gimple stmt;
2371   tree context = root->context;
2372   struct function *sf;
2373
2374   stmt_list = NULL;
2375
2376   /* If we created a non-local frame type or decl, we need to lay them
2377      out at this time.  */
2378   if (root->frame_type)
2379     {
2380       /* In some cases the frame type will trigger the -Wpadded warning.
2381          This is not helpful; suppress it. */
2382       int save_warn_padded = warn_padded;
2383       tree *adjust;
2384
2385       warn_padded = 0;
2386       layout_type (root->frame_type);
2387       warn_padded = save_warn_padded;
2388       layout_decl (root->frame_decl, 0);
2389
2390       /* Remove root->frame_decl from root->new_local_var_chain, so
2391          that we can declare it also in the lexical blocks, which
2392          helps ensure virtual regs that end up appearing in its RTL
2393          expression get substituted in instantiate_virtual_regs().  */
2394       for (adjust = &root->new_local_var_chain;
2395            *adjust != root->frame_decl;
2396            adjust = &DECL_CHAIN (*adjust))
2397         gcc_assert (DECL_CHAIN (*adjust));
2398       *adjust = DECL_CHAIN (*adjust);
2399
2400       DECL_CHAIN (root->frame_decl) = NULL_TREE;
2401       declare_vars (root->frame_decl,
2402                     gimple_seq_first_stmt (gimple_body (context)), true);
2403     }
2404
2405   /* If any parameters were referenced non-locally, then we need to
2406      insert a copy.  Likewise, if any variables were referenced by
2407      pointer, we need to initialize the address.  */
2408   if (root->any_parm_remapped)
2409     {
2410       tree p;
2411       for (p = DECL_ARGUMENTS (context); p ; p = DECL_CHAIN (p))
2412         {
2413           tree field, x, y;
2414
2415           field = lookup_field_for_decl (root, p, NO_INSERT);
2416           if (!field)
2417             continue;
2418
2419           if (use_pointer_in_frame (p))
2420             x = build_addr (p, context);
2421           else
2422             x = p;
2423
2424           y = build3 (COMPONENT_REF, TREE_TYPE (field),
2425                       root->frame_decl, field, NULL_TREE);
2426           stmt = gimple_build_assign (y, x);
2427           gimple_seq_add_stmt (&stmt_list, stmt);
2428           /* If the assignment is from a non-register the stmt is
2429              not valid gimple.  Make it so by using a temporary instead.  */
2430           if (!is_gimple_reg (x)
2431               && is_gimple_reg_type (TREE_TYPE (x)))
2432             {
2433               gimple_stmt_iterator gsi = gsi_last (stmt_list);
2434               x = init_tmp_var (root, x, &gsi);
2435               gimple_assign_set_rhs1 (stmt, x);
2436             }
2437         }
2438     }
2439
2440   /* If a chain_field was created, then it needs to be initialized
2441      from chain_decl.  */
2442   if (root->chain_field)
2443     {
2444       tree x = build3 (COMPONENT_REF, TREE_TYPE (root->chain_field),
2445                        root->frame_decl, root->chain_field, NULL_TREE);
2446       stmt = gimple_build_assign (x, get_chain_decl (root));
2447       gimple_seq_add_stmt (&stmt_list, stmt);
2448     }
2449
2450   /* If trampolines were created, then we need to initialize them.  */
2451   if (root->any_tramp_created)
2452     {
2453       struct nesting_info *i;
2454       for (i = root->inner; i ; i = i->next)
2455         {
2456           tree arg1, arg2, arg3, x, field;
2457
2458           field = lookup_tramp_for_decl (root, i->context, NO_INSERT);
2459           if (!field)
2460             continue;
2461
2462           gcc_assert (DECL_STATIC_CHAIN (i->context));
2463           arg3 = build_addr (root->frame_decl, context);
2464
2465           arg2 = build_addr (i->context, context);
2466
2467           x = build3 (COMPONENT_REF, TREE_TYPE (field),
2468                       root->frame_decl, field, NULL_TREE);
2469           arg1 = build_addr (x, context);
2470
2471           x = builtin_decl_implicit (BUILT_IN_INIT_TRAMPOLINE);
2472           stmt = gimple_build_call (x, 3, arg1, arg2, arg3);
2473           gimple_seq_add_stmt (&stmt_list, stmt);
2474         }
2475     }
2476
2477   /* If we created initialization statements, insert them.  */
2478   if (stmt_list)
2479     {
2480       gimple bind;
2481       annotate_all_with_location (stmt_list, DECL_SOURCE_LOCATION (context));
2482       bind = gimple_seq_first_stmt (gimple_body (context));
2483       gimple_seq_add_seq (&stmt_list, gimple_bind_body (bind));
2484       gimple_bind_set_body (bind, stmt_list);
2485     }
2486
2487   /* If a chain_decl was created, then it needs to be registered with
2488      struct function so that it gets initialized from the static chain
2489      register at the beginning of the function.  */
2490   sf = DECL_STRUCT_FUNCTION (root->context);
2491   sf->static_chain_decl = root->chain_decl;
2492
2493   /* Similarly for the non-local goto save area.  */
2494   if (root->nl_goto_field)
2495     {
2496       sf->nonlocal_goto_save_area
2497         = get_frame_field (root, context, root->nl_goto_field, NULL);
2498       sf->has_nonlocal_label = 1;
2499     }
2500
2501   /* Make sure all new local variables get inserted into the
2502      proper BIND_EXPR.  */
2503   if (root->new_local_var_chain)
2504     declare_vars (root->new_local_var_chain,
2505                   gimple_seq_first_stmt (gimple_body (root->context)),
2506                   false);
2507
2508   if (root->debug_var_chain)
2509     {
2510       tree debug_var;
2511       gimple scope;
2512
2513       remap_vla_decls (DECL_INITIAL (root->context), root);
2514
2515       for (debug_var = root->debug_var_chain; debug_var;
2516            debug_var = DECL_CHAIN (debug_var))
2517         if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
2518           break;
2519
2520       /* If there are any debug decls with variable length types,
2521          remap those types using other debug_var_chain variables.  */
2522       if (debug_var)
2523         {
2524           struct nesting_copy_body_data id;
2525
2526           memset (&id, 0, sizeof (id));
2527           id.cb.copy_decl = nesting_copy_decl;
2528           id.cb.decl_map = pointer_map_create ();
2529           id.root = root;
2530
2531           for (; debug_var; debug_var = DECL_CHAIN (debug_var))
2532             if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
2533               {
2534                 tree type = TREE_TYPE (debug_var);
2535                 tree newt, t = type;
2536                 struct nesting_info *i;
2537
2538                 for (i = root; i; i = i->outer)
2539                   if (variably_modified_type_p (type, i->context))
2540                     break;
2541
2542                 if (i == NULL)
2543                   continue;
2544
2545                 id.cb.src_fn = i->context;
2546                 id.cb.dst_fn = i->context;
2547                 id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
2548
2549                 TREE_TYPE (debug_var) = newt = remap_type (type, &id.cb);
2550                 while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
2551                   {
2552                     newt = TREE_TYPE (newt);
2553                     t = TREE_TYPE (t);
2554                   }
2555                 if (TYPE_NAME (newt)
2556                     && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
2557                     && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
2558                     && newt != t
2559                     && TYPE_NAME (newt) == TYPE_NAME (t))
2560                   TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
2561               }
2562
2563           pointer_map_destroy (id.cb.decl_map);
2564         }
2565
2566       scope = gimple_seq_first_stmt (gimple_body (root->context));
2567       if (gimple_bind_block (scope))
2568         declare_vars (root->debug_var_chain, scope, true);
2569       else
2570         BLOCK_VARS (DECL_INITIAL (root->context))
2571           = chainon (BLOCK_VARS (DECL_INITIAL (root->context)),
2572                      root->debug_var_chain);
2573     }
2574
2575   /* Fold the rewritten MEM_REF trees.  */
2576   pointer_set_traverse (root->mem_refs, fold_mem_refs, NULL);
2577
2578   /* Dump the translated tree function.  */
2579   if (dump_file)
2580     {
2581       fputs ("\n\n", dump_file);
2582       dump_function_to_file (root->context, dump_file, dump_flags);
2583     }
2584 }
2585
2586 static void
2587 finalize_nesting_tree (struct nesting_info *root)
2588 {
2589   struct nesting_info *n;
2590   FOR_EACH_NEST_INFO (n, root)
2591     finalize_nesting_tree_1 (n);
2592 }
2593
2594 /* Unnest the nodes and pass them to cgraph.  */
2595
2596 static void
2597 unnest_nesting_tree_1 (struct nesting_info *root)
2598 {
2599   struct cgraph_node *node = cgraph_get_node (root->context);
2600
2601   /* For nested functions update the cgraph to reflect unnesting.
2602      We also delay finalizing of these functions up to this point.  */
2603   if (node->origin)
2604     {
2605        cgraph_unnest_node (node);
2606        cgraph_finalize_function (root->context, true);
2607     }
2608 }
2609
2610 static void
2611 unnest_nesting_tree (struct nesting_info *root)
2612 {
2613   struct nesting_info *n;
2614   FOR_EACH_NEST_INFO (n, root)
2615     unnest_nesting_tree_1 (n);
2616 }
2617
2618 /* Free the data structures allocated during this pass.  */
2619
2620 static void
2621 free_nesting_tree (struct nesting_info *root)
2622 {
2623   struct nesting_info *node, *next;
2624
2625   node = iter_nestinfo_start (root);
2626   do
2627     {
2628       next = iter_nestinfo_next (node);
2629       pointer_map_destroy (node->var_map);
2630       pointer_map_destroy (node->field_map);
2631       pointer_set_destroy (node->mem_refs);
2632       free (node);
2633       node = next;
2634     }
2635   while (node);
2636 }
2637
2638 /* Gimplify a function and all its nested functions.  */
2639 static void
2640 gimplify_all_functions (struct cgraph_node *root)
2641 {
2642   struct cgraph_node *iter;
2643   if (!gimple_body (root->decl))
2644     gimplify_function_tree (root->decl);
2645   for (iter = root->nested; iter; iter = iter->next_nested)
2646     gimplify_all_functions (iter);
2647 }
2648
2649 /* Main entry point for this pass.  Process FNDECL and all of its nested
2650    subroutines and turn them into something less tightly bound.  */
2651
2652 void
2653 lower_nested_functions (tree fndecl)
2654 {
2655   struct cgraph_node *cgn;
2656   struct nesting_info *root;
2657
2658   /* If there are no nested functions, there's nothing to do.  */
2659   cgn = cgraph_get_node (fndecl);
2660   if (!cgn->nested)
2661     return;
2662
2663   gimplify_all_functions (cgn);
2664
2665   dump_file = dump_begin (TDI_nested, &dump_flags);
2666   if (dump_file)
2667     fprintf (dump_file, "\n;; Function %s\n\n",
2668              lang_hooks.decl_printable_name (fndecl, 2));
2669
2670   bitmap_obstack_initialize (&nesting_info_bitmap_obstack);
2671   root = create_nesting_tree (cgn);
2672
2673   walk_all_functions (convert_nonlocal_reference_stmt,
2674                       convert_nonlocal_reference_op,
2675                       root);
2676   walk_all_functions (convert_local_reference_stmt,
2677                       convert_local_reference_op,
2678                       root);
2679   walk_all_functions (convert_nl_goto_reference, NULL, root);
2680   walk_all_functions (convert_nl_goto_receiver, NULL, root);
2681
2682   convert_all_function_calls (root);
2683   finalize_nesting_tree (root);
2684   unnest_nesting_tree (root);
2685
2686   free_nesting_tree (root);
2687   bitmap_obstack_release (&nesting_info_bitmap_obstack);
2688
2689   if (dump_file)
2690     {
2691       dump_end (TDI_nested, dump_file);
2692       dump_file = NULL;
2693     }
2694 }
2695
2696 #include "gt-tree-nested.h"