gcc/tree-nested.c

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