gcc/tree-nested.c

   1 /* Nested function decomposition for trees.
   2    Copyright (C) 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   3
   4    This file is part of GCC.
   5
   6    GCC is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    GCC is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "tree.h"
  25 #include "rtl.h"
  26 #include "tm_p.h"
  27 #include "function.h"
  28 #include "tree-dump.h"
  29 #include "tree-inline.h"
  30 #include "tree-gimple.h"
  31 #include "tree-iterator.h"
  32 #include "tree-flow.h"
  33 #include "cgraph.h"
  34 #include "expr.h"
  35 #include "langhooks.h"
  36 #include "ggc.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 var_map_elt GTY(())
  80 {
  81   tree old;
  82   tree new;
  83 };
  84
  85 struct nesting_info GTY ((chain_next ("%h.next")))
  86 {
  87   struct nesting_info *outer;
  88   struct nesting_info *inner;
  89   struct nesting_info *next;
  90
  91   htab_t GTY ((param_is (struct var_map_elt))) field_map;
  92   htab_t GTY ((param_is (struct var_map_elt))) var_map;
  93   bitmap suppress_expansion;
  94
  95   tree context;
  96   tree new_local_var_chain;
  97   tree debug_var_chain;
  98   tree frame_type;
  99   tree frame_decl;
 100   tree chain_field;
 101   tree chain_decl;
 102   tree nl_goto_field;
 103
 104   bool any_parm_remapped;
 105   bool any_tramp_created;
 106   char static_chain_added;
 107 };
 108
 109
 110 /* Hashing and equality functions for nesting_info->var_map.  */
 111
 112 static hashval_t
 113 var_map_hash (const void *x)
 114 {
 115   const struct var_map_elt *a = (const struct var_map_elt *) x;
 116   return htab_hash_pointer (a->old);
 117 }
 118
 119 static int
 120 var_map_eq (const void *x, const void *y)
 121 {
 122   const struct var_map_elt *a = (const struct var_map_elt *) x;
 123   const struct var_map_elt *b = (const struct var_map_elt *) y;
 124   return a->old == b->old;
 125 }
 126
 127 /* We're working in so many different function contexts simultaneously,
 128    that create_tmp_var is dangerous.  Prevent mishap.  */
 129 #define create_tmp_var cant_use_create_tmp_var_here_dummy
 130
 131 /* Like create_tmp_var, except record the variable for registration at
 132    the given nesting level.  */
 133
 134 static tree
 135 create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix)
 136 {
 137   tree tmp_var;
 138
 139   /* If the type is of variable size or a type which must be created by the
 140      frontend, something is wrong.  Note that we explicitly allow
 141      incomplete types here, since we create them ourselves here.  */
 142   gcc_assert (!TREE_ADDRESSABLE (type));
 143   gcc_assert (!TYPE_SIZE_UNIT (type)
 144               || TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
 145
 146   tmp_var = create_tmp_var_raw (type, prefix);
 147   DECL_CONTEXT (tmp_var) = info->context;
 148   TREE_CHAIN (tmp_var) = info->new_local_var_chain;
 149   DECL_SEEN_IN_BIND_EXPR_P (tmp_var) = 1;
 150   if (TREE_CODE (type) == COMPLEX_TYPE)
 151     DECL_COMPLEX_GIMPLE_REG_P (tmp_var) = 1;
 152
 153   info->new_local_var_chain = tmp_var;
 154
 155   return tmp_var;
 156 }
 157
 158 /* Take the address of EXP to be used within function CONTEXT.
 159    Mark it for addressability as necessary.  */
 160
 161 tree
 162 build_addr (tree exp, tree context)
 163 {
 164   tree base = exp;
 165   tree save_context;
 166   tree retval;
 167
 168   while (handled_component_p (base))
 169     base = TREE_OPERAND (base, 0);
 170
 171   if (DECL_P (base))
 172     TREE_ADDRESSABLE (base) = 1;
 173
 174   /* Building the ADDR_EXPR will compute a set of properties for
 175      that ADDR_EXPR.  Those properties are unfortunately context
 176      specific.  ie, they are dependent on CURRENT_FUNCTION_DECL.
 177
 178      Temporarily set CURRENT_FUNCTION_DECL to the desired context,
 179      build the ADDR_EXPR, then restore CURRENT_FUNCTION_DECL.  That
 180      way the properties are for the ADDR_EXPR are computed properly.  */
 181   save_context = current_function_decl;
 182   current_function_decl = context;
 183   retval = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
 184   current_function_decl = save_context;;
 185   return retval;
 186 }
 187
 188 /* Insert FIELD into TYPE, sorted by alignment requirements.  */
 189
 190 void
 191 insert_field_into_struct (tree type, tree field)
 192 {
 193   tree *p;
 194
 195   DECL_CONTEXT (field) = type;
 196
 197   for (p = &TYPE_FIELDS (type); *p ; p = &TREE_CHAIN (*p))
 198     if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
 199       break;
 200
 201   TREE_CHAIN (field) = *p;
 202   *p = field;
 203 }
 204
 205 /* Build or return the RECORD_TYPE that describes the frame state that is
 206    shared between INFO->CONTEXT and its nested functions.  This record will
 207    not be complete until finalize_nesting_tree; up until that point we'll
 208    be adding fields as necessary.
 209
 210    We also build the DECL that represents this frame in the function.  */
 211
 212 static tree
 213 get_frame_type (struct nesting_info *info)
 214 {
 215   tree type = info->frame_type;
 216   if (!type)
 217     {
 218       char *name;
 219
 220       type = make_node (RECORD_TYPE);
 221
 222       name = concat ("FRAME.",
 223                      IDENTIFIER_POINTER (DECL_NAME (info->context)),
 224                      NULL);
 225       TYPE_NAME (type) = get_identifier (name);
 226       free (name);
 227
 228       info->frame_type = type;
 229       info->frame_decl = create_tmp_var_for (info, type, "FRAME");
 230
 231       /* ??? Always make it addressable for now, since it is meant to
 232          be pointed to by the static chain pointer.  This pessimizes
 233          when it turns out that no static chains are needed because
 234          the nested functions referencing non-local variables are not
 235          reachable, but the true pessimization is to create the non-
 236          local frame structure in the first place.  */
 237       TREE_ADDRESSABLE (info->frame_decl) = 1;
 238     }
 239   return type;
 240 }
 241
 242 /* Return true if DECL should be referenced by pointer in the non-local
 243    frame structure.  */
 244
 245 static bool
 246 use_pointer_in_frame (tree decl)
 247 {
 248   if (TREE_CODE (decl) == PARM_DECL)
 249     {
 250       /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable
 251          sized decls, and inefficient to copy large aggregates.  Don't bother
 252          moving anything but scalar variables.  */
 253       return AGGREGATE_TYPE_P (TREE_TYPE (decl));
 254     }
 255   else
 256     {
 257       /* Variable sized types make things "interesting" in the frame.  */
 258       return DECL_SIZE (decl) == NULL || !TREE_CONSTANT (DECL_SIZE (decl));
 259     }
 260 }
 261
 262 /* Given DECL, a non-locally accessed variable, find or create a field
 263    in the non-local frame structure for the given nesting context.  */
 264
 265 static tree
 266 lookup_field_for_decl (struct nesting_info *info, tree decl,
 267                        enum insert_option insert)
 268 {
 269   struct var_map_elt *elt, dummy;
 270   void **slot;
 271   tree field;
 272
 273   dummy.old = decl;
 274   slot = htab_find_slot (info->field_map, &dummy, insert);
 275   if (!slot)
 276     {
 277       gcc_assert (insert != INSERT);
 278       return NULL;
 279     }
 280   elt = (struct var_map_elt *) *slot;
 281
 282   if (!elt && insert == INSERT)
 283     {
 284       field = make_node (FIELD_DECL);
 285       DECL_NAME (field) = DECL_NAME (decl);
 286
 287       if (use_pointer_in_frame (decl))
 288         {
 289           TREE_TYPE (field) = build_pointer_type (TREE_TYPE (decl));
 290           DECL_ALIGN (field) = TYPE_ALIGN (TREE_TYPE (field));
 291           DECL_NONADDRESSABLE_P (field) = 1;
 292         }
 293       else
 294         {
 295           TREE_TYPE (field) = TREE_TYPE (decl);
 296           DECL_SOURCE_LOCATION (field) = DECL_SOURCE_LOCATION (decl);
 297           DECL_ALIGN (field) = DECL_ALIGN (decl);
 298           DECL_USER_ALIGN (field) = DECL_USER_ALIGN (decl);
 299           TREE_ADDRESSABLE (field) = TREE_ADDRESSABLE (decl);
 300           DECL_NONADDRESSABLE_P (field) = !TREE_ADDRESSABLE (decl);
 301           TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (decl);
 302         }
 303
 304       insert_field_into_struct (get_frame_type (info), field);
 305
 306       elt = GGC_NEW (struct var_map_elt);
 307       elt->old = decl;
 308       elt->new = field;
 309       *slot = elt;
 310
 311       if (TREE_CODE (decl) == PARM_DECL)
 312         info->any_parm_remapped = true;
 313     }
 314   else
 315     field = elt ? elt->new : NULL;
 316
 317   return field;
 318 }
 319
 320 /* Build or return the variable that holds the static chain within
 321    INFO->CONTEXT.  This variable may only be used within INFO->CONTEXT.  */
 322
 323 static tree
 324 get_chain_decl (struct nesting_info *info)
 325 {
 326   tree decl = info->chain_decl;
 327   if (!decl)
 328     {
 329       tree type;
 330
 331       type = get_frame_type (info->outer);
 332       type = build_pointer_type (type);
 333
 334       /* Note that this variable is *not* entered into any BIND_EXPR;
 335          the construction of this variable is handled specially in
 336          expand_function_start and initialize_inlined_parameters.
 337          Note also that it's represented as a parameter.  This is more
 338          close to the truth, since the initial value does come from
 339          the caller.  */
 340       decl = build_decl (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   return decl;
 354 }
 355
 356 /* Build or return the field within the non-local frame state that holds
 357    the static chain for INFO->CONTEXT.  This is the way to walk back up
 358    multiple nesting levels.  */
 359
 360 static tree
 361 get_chain_field (struct nesting_info *info)
 362 {
 363   tree field = info->chain_field;
 364   if (!field)
 365     {
 366       tree type = build_pointer_type (get_frame_type (info->outer));
 367
 368       field = make_node (FIELD_DECL);
 369       DECL_NAME (field) = get_identifier ("__chain");
 370       TREE_TYPE (field) = type;
 371       DECL_ALIGN (field) = TYPE_ALIGN (type);
 372       DECL_NONADDRESSABLE_P (field) = 1;
 373
 374       insert_field_into_struct (get_frame_type (info), field);
 375
 376       info->chain_field = field;
 377     }
 378   return field;
 379 }
 380
 381 /* Copy EXP into a temporary.  Allocate the temporary in the context of
 382    INFO and insert the initialization statement before TSI.  */
 383
 384 static tree
 385 init_tmp_var (struct nesting_info *info, tree exp, tree_stmt_iterator *tsi)
 386 {
 387   tree t, stmt;
 388
 389   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
 390   stmt = build2 (MODIFY_EXPR, TREE_TYPE (t), t, exp);
 391   SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi)));
 392   tsi_link_before (tsi, stmt, TSI_SAME_STMT);
 393
 394   return t;
 395 }
 396
 397 /* Similarly, but only do so to force EXP to satisfy is_gimple_val.  */
 398
 399 static tree
 400 tsi_gimplify_val (struct nesting_info *info, tree exp, tree_stmt_iterator *tsi)
 401 {
 402   if (is_gimple_val (exp))
 403     return exp;
 404   else
 405     return init_tmp_var (info, exp, tsi);
 406 }
 407
 408 /* Similarly, but copy from the temporary and insert the statement
 409    after the iterator.  */
 410
 411 static tree
 412 save_tmp_var (struct nesting_info *info, tree exp,
 413               tree_stmt_iterator *tsi)
 414 {
 415   tree t, stmt;
 416
 417   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
 418   stmt = build2 (MODIFY_EXPR, TREE_TYPE (t), exp, t);
 419   SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi)));
 420   tsi_link_after (tsi, stmt, TSI_SAME_STMT);
 421
 422   return t;
 423 }
 424
 425 /* Build or return the type used to represent a nested function trampoline.  */
 426
 427 static GTY(()) tree trampoline_type;
 428
 429 static tree
 430 get_trampoline_type (void)
 431 {
 432   tree record, t;
 433   unsigned align, size;
 434
 435   if (trampoline_type)
 436     return trampoline_type;
 437
 438   align = TRAMPOLINE_ALIGNMENT;
 439   size = TRAMPOLINE_SIZE;
 440
 441   /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
 442      then allocate extra space so that we can do dynamic alignment.  */
 443   if (align > STACK_BOUNDARY)
 444     {
 445       size += ((align/BITS_PER_UNIT) - 1) & -(STACK_BOUNDARY/BITS_PER_UNIT);
 446       align = STACK_BOUNDARY;
 447     }
 448
 449   t = build_index_type (build_int_cst (NULL_TREE, size - 1));
 450   t = build_array_type (char_type_node, t);
 451   t = build_decl (FIELD_DECL, get_identifier ("__data"), t);
 452   DECL_ALIGN (t) = align;
 453   DECL_USER_ALIGN (t) = 1;
 454
 455   record = make_node (RECORD_TYPE);
 456   TYPE_NAME (record) = get_identifier ("__builtin_trampoline");
 457   TYPE_FIELDS (record) = t;
 458   layout_type (record);
 459
 460   return record;
 461 }
 462
 463 /* Given DECL, a nested function, find or create a field in the non-local
 464    frame structure for a trampoline for this function.  */
 465
 466 static tree
 467 lookup_tramp_for_decl (struct nesting_info *info, tree decl,
 468                        enum insert_option insert)
 469 {
 470   struct var_map_elt *elt, dummy;
 471   void **slot;
 472   tree field;
 473
 474   dummy.old = decl;
 475   slot = htab_find_slot (info->var_map, &dummy, insert);
 476   if (!slot)
 477     {
 478       gcc_assert (insert != INSERT);
 479       return NULL;
 480     }
 481   elt = (struct var_map_elt *) *slot;
 482
 483   if (!elt && insert == INSERT)
 484     {
 485       field = make_node (FIELD_DECL);
 486       DECL_NAME (field) = DECL_NAME (decl);
 487       TREE_TYPE (field) = get_trampoline_type ();
 488       TREE_ADDRESSABLE (field) = 1;
 489
 490       insert_field_into_struct (get_frame_type (info), field);
 491
 492       elt = GGC_NEW (struct var_map_elt);
 493       elt->old = decl;
 494       elt->new = field;
 495       *slot = elt;
 496
 497       info->any_tramp_created = true;
 498     }
 499   else
 500     field = elt ? elt->new : NULL;
 501
 502   return field;
 503 }
 504
 505 /* Build or return the field within the non-local frame state that holds
 506    the non-local goto "jmp_buf".  The buffer itself is maintained by the
 507    rtl middle-end as dynamic stack space is allocated.  */
 508
 509 static tree
 510 get_nl_goto_field (struct nesting_info *info)
 511 {
 512   tree field = info->nl_goto_field;
 513   if (!field)
 514     {
 515       unsigned size;
 516       tree type;
 517
 518       /* For __builtin_nonlocal_goto, we need N words.  The first is the
 519          frame pointer, the rest is for the target's stack pointer save
 520          area.  The number of words is controlled by STACK_SAVEAREA_MODE;
 521          not the best interface, but it'll do for now.  */
 522       if (Pmode == ptr_mode)
 523         type = ptr_type_node;
 524       else
 525         type = lang_hooks.types.type_for_mode (Pmode, 1);
 526
 527       size = GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL));
 528       size = size / GET_MODE_SIZE (Pmode);
 529       size = size + 1;
 530
 531       type = build_array_type
 532         (type, build_index_type (build_int_cst (NULL_TREE, size)));
 533
 534       field = make_node (FIELD_DECL);
 535       DECL_NAME (field) = get_identifier ("__nl_goto_buf");
 536       TREE_TYPE (field) = type;
 537       DECL_ALIGN (field) = TYPE_ALIGN (type);
 538       TREE_ADDRESSABLE (field) = 1;
 539
 540       insert_field_into_struct (get_frame_type (info), field);
 541
 542       info->nl_goto_field = field;
 543     }
 544
 545   return field;
 546 }
 547 \f
 548 /* Helper function for walk_stmts.  Walk output operands of an ASM_EXPR.  */
 549
 550 static void
 551 walk_asm_expr (struct walk_stmt_info *wi, tree stmt)
 552 {
 553   int noutputs = list_length (ASM_OUTPUTS (stmt));
 554   const char **oconstraints
 555     = (const char **) alloca ((noutputs) * sizeof (const char *));
 556   int i;
 557   tree link;
 558   const char *constraint;
 559   bool allows_mem, allows_reg, is_inout;
 560
 561   wi->is_lhs = true;
 562   for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
 563     {
 564       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 565       oconstraints[i] = constraint;
 566       parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
 567                                &allows_reg, &is_inout);
 568
 569       wi->val_only = (allows_reg || !allows_mem);
 570       walk_tree (&TREE_VALUE (link), wi->callback, wi, NULL);
 571     }
 572
 573   for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
 574     {
 575       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 576       parse_input_constraint (&constraint, 0, 0, noutputs, 0,
 577                               oconstraints, &allows_mem, &allows_reg);
 578
 579       wi->val_only = (allows_reg || !allows_mem);
 580       /* Although input "m" is not really a LHS, we need a lvalue.  */
 581       wi->is_lhs = !wi->val_only;
 582       walk_tree (&TREE_VALUE (link), wi->callback, wi, NULL);
 583     }
 584
 585   wi->is_lhs = false;
 586   wi->val_only = true;
 587 }
 588
 589 /* Iterate over all sub-statements of *TP calling walk_tree with
 590    WI->CALLBACK for every sub-expression in each statement found.  */
 591
 592 void
 593 walk_stmts (struct walk_stmt_info *wi, tree *tp)
 594 {
 595   tree t = *tp;
 596   int walk_subtrees;
 597
 598   if (!t)
 599     return;
 600
 601   if (wi->want_locations && EXPR_HAS_LOCATION (t))
 602     input_location = EXPR_LOCATION (t);
 603
 604   switch (TREE_CODE (t))
 605     {
 606     case STATEMENT_LIST:
 607       {
 608         tree_stmt_iterator i;
 609         for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
 610           {
 611             wi->tsi = i;
 612             walk_stmts (wi, tsi_stmt_ptr (i));
 613           }
 614       }
 615       break;
 616
 617     case COND_EXPR:
 618       walk_tree (&COND_EXPR_COND (t), wi->callback, wi, NULL);
 619       walk_stmts (wi, &COND_EXPR_THEN (t));
 620       walk_stmts (wi, &COND_EXPR_ELSE (t));
 621       break;
 622     case CATCH_EXPR:
 623       walk_stmts (wi, &CATCH_BODY (t));
 624       break;
 625     case EH_FILTER_EXPR:
 626       walk_stmts (wi, &EH_FILTER_FAILURE (t));
 627       break;
 628     case TRY_CATCH_EXPR:
 629     case TRY_FINALLY_EXPR:
 630       walk_stmts (wi, &TREE_OPERAND (t, 0));
 631       walk_stmts (wi, &TREE_OPERAND (t, 1));
 632       break;
 633
 634     case BIND_EXPR:
 635       if (wi->want_bind_expr)
 636         {
 637           walk_subtrees = 1;
 638           wi->callback (tp, &walk_subtrees, wi);
 639           if (!walk_subtrees)
 640             break;
 641         }
 642       walk_stmts (wi, &BIND_EXPR_BODY (t));
 643       break;
 644
 645     case RETURN_EXPR:
 646       if (wi->want_return_expr)
 647         {
 648           walk_subtrees = 1;
 649           wi->callback (tp, &walk_subtrees, wi);
 650           if (!walk_subtrees)
 651             break;
 652         }
 653       walk_stmts (wi, &TREE_OPERAND (t, 0));
 654       break;
 655
 656     case MODIFY_EXPR:
 657       /* A formal temporary lhs may use a COMPONENT_REF rhs.  */
 658       wi->val_only = !is_gimple_formal_tmp_var (TREE_OPERAND (t, 0));
 659       walk_tree (&TREE_OPERAND (t, 1), wi->callback, wi, NULL);
 660
 661       /* If the rhs is appropriate for a memory, we may use a
 662          COMPONENT_REF on the lhs.  */
 663       wi->val_only = !is_gimple_mem_rhs (TREE_OPERAND (t, 1));
 664       wi->is_lhs = true;
 665       walk_tree (&TREE_OPERAND (t, 0), wi->callback, wi, NULL);
 666
 667       wi->val_only = true;
 668       wi->is_lhs = false;
 669       break;
 670
 671     case ASM_EXPR:
 672       walk_asm_expr (wi, *tp);
 673       break;
 674
 675     default:
 676       wi->val_only = true;
 677       walk_tree (tp, wi->callback, wi, NULL);
 678       break;
 679     }
 680 }
 681
 682 /* Invoke CALLBACK on all statements of *STMT_P.  */
 683
 684 static void
 685 walk_body (walk_tree_fn callback, struct nesting_info *info, tree *stmt_p)
 686 {
 687   struct walk_stmt_info wi;
 688
 689   memset (&wi, 0, sizeof (wi));
 690   wi.callback = callback;
 691   wi.info = info;
 692   wi.val_only = true;
 693
 694   walk_stmts (&wi, stmt_p);
 695 }
 696
 697 /* Invoke CALLBACK on all statements of INFO->CONTEXT.  */
 698
 699 static inline void
 700 walk_function (walk_tree_fn callback, struct nesting_info *info)
 701 {
 702   walk_body (callback, info, &DECL_SAVED_TREE (info->context));
 703 }
 704
 705 /* Similarly for ROOT and all functions nested underneath, depth first.  */
 706
 707 static void
 708 walk_all_functions (walk_tree_fn callback, struct nesting_info *root)
 709 {
 710   do
 711     {
 712       if (root->inner)
 713         walk_all_functions (callback, root->inner);
 714       walk_function (callback, root);
 715       root = root->next;
 716     }
 717   while (root);
 718 }
 719 \f
 720 /* We have to check for a fairly pathological case.  The operands of function
 721    nested function are to be interpreted in the context of the enclosing
 722    function.  So if any are variably-sized, they will get remapped when the
 723    enclosing function is inlined.  But that remapping would also have to be
 724    done in the types of the PARM_DECLs of the nested function, meaning the
 725    argument types of that function will disagree with the arguments in the
 726    calls to that function.  So we'd either have to make a copy of the nested
 727    function corresponding to each time the enclosing function was inlined or
 728    add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
 729    function.  The former is not practical.  The latter would still require
 730    detecting this case to know when to add the conversions.  So, for now at
 731    least, we don't inline such an enclosing function.
 732
 733    We have to do that check recursively, so here return indicating whether
 734    FNDECL has such a nested function.  ORIG_FN is the function we were
 735    trying to inline to use for checking whether any argument is variably
 736    modified by anything in it.
 737
 738    It would be better to do this in tree-inline.c so that we could give
 739    the appropriate warning for why a function can't be inlined, but that's
 740    too late since the nesting structure has already been flattened and
 741    adding a flag just to record this fact seems a waste of a flag.  */
 742
 743 static bool
 744 check_for_nested_with_variably_modified (tree fndecl, tree orig_fndecl)
 745 {
 746   struct cgraph_node *cgn = cgraph_node (fndecl);
 747   tree arg;
 748
 749   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 750     {
 751       for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = TREE_CHAIN (arg))
 752         if (variably_modified_type_p (TREE_TYPE (arg), 0), orig_fndecl)
 753           return true;
 754
 755       if (check_for_nested_with_variably_modified (cgn->decl, orig_fndecl))
 756         return true;
 757     }
 758
 759   return false;
 760 }
 761
 762 /* Construct our local datastructure describing the function nesting
 763    tree rooted by CGN.  */
 764
 765 static struct nesting_info *
 766 create_nesting_tree (struct cgraph_node *cgn)
 767 {
 768   struct nesting_info *info = GGC_CNEW (struct nesting_info);
 769   info->field_map = htab_create_ggc (7, var_map_hash, var_map_eq, ggc_free);
 770   info->var_map = htab_create_ggc (7, var_map_hash, var_map_eq, ggc_free);
 771   info->suppress_expansion = BITMAP_GGC_ALLOC ();
 772   info->context = cgn->decl;
 773
 774   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 775     {
 776       struct nesting_info *sub = create_nesting_tree (cgn);
 777       sub->outer = info;
 778       sub->next = info->inner;
 779       info->inner = sub;
 780     }
 781
 782   /* See discussion at check_for_nested_with_variably_modified for a
 783      discussion of why this has to be here.  */
 784   if (check_for_nested_with_variably_modified (info->context, info->context))
 785     DECL_UNINLINABLE (info->context) = true;
 786
 787   return info;
 788 }
 789
 790 /* Return an expression computing the static chain for TARGET_CONTEXT
 791    from INFO->CONTEXT.  Insert any necessary computations before TSI.  */
 792
 793 static tree
 794 get_static_chain (struct nesting_info *info, tree target_context,
 795                   tree_stmt_iterator *tsi)
 796 {
 797   struct nesting_info *i;
 798   tree x;
 799
 800   if (info->context == target_context)
 801     {
 802       x = build_addr (info->frame_decl, target_context);
 803     }
 804   else
 805     {
 806       x = get_chain_decl (info);
 807
 808       for (i = info->outer; i->context != target_context; i = i->outer)
 809         {
 810           tree field = get_chain_field (i);
 811
 812           x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 813           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 814           x = init_tmp_var (info, x, tsi);
 815         }
 816     }
 817
 818   return x;
 819 }
 820
 821 /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
 822    frame as seen from INFO->CONTEXT.  Insert any necessary computations
 823    before TSI.  */
 824
 825 static tree
 826 get_frame_field (struct nesting_info *info, tree target_context,
 827                  tree field, tree_stmt_iterator *tsi)
 828 {
 829   struct nesting_info *i;
 830   tree x;
 831
 832   if (info->context == target_context)
 833     {
 834       /* Make sure frame_decl gets created.  */
 835       (void) get_frame_type (info);
 836       x = info->frame_decl;
 837     }
 838   else
 839     {
 840       x = get_chain_decl (info);
 841
 842       for (i = info->outer; i->context != target_context; i = i->outer)
 843         {
 844           tree field = get_chain_field (i);
 845
 846           x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 847           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 848           x = init_tmp_var (info, x, tsi);
 849         }
 850
 851       x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 852     }
 853
 854   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 855   return x;
 856 }
 857
 858 /* A subroutine of convert_nonlocal_reference.  Create a local variable
 859    in the nested function with DECL_VALUE_EXPR set to reference the true
 860    variable in the parent function.  This is used both for debug info
 861    and in OpenMP lowering.  */
 862
 863 static tree
 864 get_nonlocal_debug_decl (struct nesting_info *info, tree decl)
 865 {
 866   struct var_map_elt *elt, dummy;
 867   tree target_context;
 868   struct nesting_info *i;
 869   tree x, field, new_decl;
 870   void **slot;
 871
 872   dummy.old = decl;
 873   slot = htab_find_slot (info->var_map, &dummy, INSERT);
 874   elt = *slot;
 875
 876   if (elt)
 877     return elt->new;
 878
 879   target_context = decl_function_context (decl);
 880
 881   /* A copy of the code in get_frame_field, but without the temporaries.  */
 882   if (info->context == target_context)
 883     {
 884       /* Make sure frame_decl gets created.  */
 885       (void) get_frame_type (info);
 886       x = info->frame_decl;
 887       i = info;
 888     }
 889   else
 890     {
 891       x = get_chain_decl (info);
 892       for (i = info->outer; i->context != target_context; i = i->outer)
 893         {
 894           field = get_chain_field (i);
 895           x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 896           x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 897         }
 898       x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 899     }
 900
 901   field = lookup_field_for_decl (i, decl, INSERT);
 902   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 903   if (use_pointer_in_frame (decl))
 904     x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 905
 906   /* ??? We should be remapping types as well, surely.  */
 907   new_decl = build_decl (VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
 908   DECL_CONTEXT (new_decl) = info->context;
 909   DECL_SOURCE_LOCATION (new_decl) = DECL_SOURCE_LOCATION (decl);
 910   DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
 911   DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
 912   TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
 913   TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
 914   TREE_READONLY (new_decl) = TREE_READONLY (decl);
 915   TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
 916   DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
 917
 918   SET_DECL_VALUE_EXPR (new_decl, x);
 919   DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
 920
 921   elt = ggc_alloc (sizeof (*elt));
 922   elt->old = decl;
 923   elt->new = new_decl;
 924   *slot = elt;
 925
 926   TREE_CHAIN (new_decl) = info->debug_var_chain;
 927   info->debug_var_chain = new_decl;
 928
 929   return new_decl;
 930 }
 931
 932 /* Called via walk_function+walk_tree, rewrite all references to VAR
 933    and PARM_DECLs that belong to outer functions.
 934
 935    The rewrite will involve some number of structure accesses back up
 936    the static chain.  E.g. for a variable FOO up one nesting level it'll
 937    be CHAIN->FOO.  For two levels it'll be CHAIN->__chain->FOO.  Further
 938    indirections apply to decls for which use_pointer_in_frame is true.  */
 939
 940 static bool convert_nonlocal_omp_clauses (tree *, struct walk_stmt_info *);
 941
 942 static tree
 943 convert_nonlocal_reference (tree *tp, int *walk_subtrees, void *data)
 944 {
 945   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
 946   struct nesting_info *info = wi->info;
 947   tree t = *tp;
 948   tree save_local_var_chain;
 949   bitmap save_suppress;
 950
 951   *walk_subtrees = 0;
 952   switch (TREE_CODE (t))
 953     {
 954     case VAR_DECL:
 955       /* Non-automatic variables are never processed.  */
 956       if (TREE_STATIC (t) || DECL_EXTERNAL (t))
 957         break;
 958       /* FALLTHRU */
 959
 960     case PARM_DECL:
 961       if (decl_function_context (t) != info->context)
 962         {
 963           tree x;
 964           wi->changed = true;
 965
 966           x = get_nonlocal_debug_decl (info, t);
 967           if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
 968             {
 969               tree target_context = decl_function_context (t);
 970               struct nesting_info *i;
 971               for (i = info->outer; i->context != target_context; i = i->outer)
 972                 continue;
 973               x = lookup_field_for_decl (i, t, INSERT);
 974               x = get_frame_field (info, target_context, x, &wi->tsi);
 975               if (use_pointer_in_frame (t))
 976                 {
 977                   x = init_tmp_var (info, x, &wi->tsi);
 978                   x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 979                 }
 980             }
 981
 982           if (wi->val_only)
 983             {
 984               if (wi->is_lhs)
 985                 x = save_tmp_var (info, x, &wi->tsi);
 986               else
 987                 x = init_tmp_var (info, x, &wi->tsi);
 988             }
 989
 990           *tp = x;
 991         }
 992       break;
 993
 994     case GOTO_EXPR:
 995       /* Don't walk non-local gotos for now.  */
 996       if (TREE_CODE (GOTO_DESTINATION (t)) != LABEL_DECL)
 997         {
 998           *walk_subtrees = 1;
 999           wi->val_only = true;
1000           wi->is_lhs = false;
1001         }
1002       break;
1003
1004     case LABEL_DECL:
1005       /* We're taking the address of a label from a parent function, but
1006          this is not itself a non-local goto.  Mark the label such that it
1007          will not be deleted, much as we would with a label address in
1008          static storage.  */
1009       if (decl_function_context (t) != info->context)
1010         FORCED_LABEL (t) = 1;
1011       break;
1012
1013     case ADDR_EXPR:
1014       {
1015         bool save_val_only = wi->val_only;
1016
1017         wi->val_only = false;
1018         wi->is_lhs = false;
1019         wi->changed = false;
1020         walk_tree (&TREE_OPERAND (t, 0), convert_nonlocal_reference, wi, NULL);
1021         wi->val_only = true;
1022
1023         if (wi->changed)
1024           {
1025             tree save_context;
1026
1027             /* If we changed anything, then TREE_INVARIANT is be wrong,
1028                since we're no longer directly referencing a decl.  */
1029             save_context = current_function_decl;
1030             current_function_decl = info->context;
1031             recompute_tree_invariant_for_addr_expr (t);
1032             current_function_decl = save_context;
1033
1034             /* If the callback converted the address argument in a context
1035                where we only accept variables (and min_invariant, presumably),
1036                then compute the address into a temporary.  */
1037             if (save_val_only)
1038               *tp = tsi_gimplify_val (wi->info, t, &wi->tsi);
1039           }
1040       }
1041       break;
1042
1043     case REALPART_EXPR:
1044     case IMAGPART_EXPR:
1045     case COMPONENT_REF:
1046     case ARRAY_REF:
1047     case ARRAY_RANGE_REF:
1048     case BIT_FIELD_REF:
1049       /* Go down this entire nest and just look at the final prefix and
1050          anything that describes the references.  Otherwise, we lose track
1051          of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
1052       wi->val_only = true;
1053       wi->is_lhs = false;
1054       for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1055         {
1056           if (TREE_CODE (t) == COMPONENT_REF)
1057             walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
1058                        NULL);
1059           else if (TREE_CODE (t) == ARRAY_REF
1060                    || TREE_CODE (t) == ARRAY_RANGE_REF)
1061             {
1062               walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference, wi,
1063                          NULL);
1064               walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
1065                          NULL);
1066               walk_tree (&TREE_OPERAND (t, 3), convert_nonlocal_reference, wi,
1067                          NULL);
1068             }
1069           else if (TREE_CODE (t) == BIT_FIELD_REF)
1070             {
1071               walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference, wi,
1072                          NULL);
1073               walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
1074                          NULL);
1075             }
1076         }
1077       wi->val_only = false;
1078       walk_tree (tp, convert_nonlocal_reference, wi, NULL);
1079       break;
1080
1081     case OMP_PARALLEL:
1082       save_suppress = info->suppress_expansion;
1083       if (convert_nonlocal_omp_clauses (&OMP_PARALLEL_CLAUSES (t), wi))
1084         {
1085           tree c, decl;
1086           decl = get_chain_decl (info);
1087           c = build_omp_clause (OMP_CLAUSE_FIRSTPRIVATE);
1088           OMP_CLAUSE_DECL (c) = decl;
1089           OMP_CLAUSE_CHAIN (c) = OMP_PARALLEL_CLAUSES (t);
1090           OMP_PARALLEL_CLAUSES (t) = c;
1091         }
1092
1093       save_local_var_chain = info->new_local_var_chain;
1094       info->new_local_var_chain = NULL;
1095
1096       walk_body (convert_nonlocal_reference, info, &OMP_PARALLEL_BODY (t));
1097
1098       if (info->new_local_var_chain)
1099         declare_vars (info->new_local_var_chain, OMP_PARALLEL_BODY (t), false);
1100       info->new_local_var_chain = save_local_var_chain;
1101       info->suppress_expansion = save_suppress;
1102       break;
1103
1104     case OMP_FOR:
1105     case OMP_SECTIONS:
1106     case OMP_SINGLE:
1107       save_suppress = info->suppress_expansion;
1108       convert_nonlocal_omp_clauses (&OMP_CLAUSES (t), wi);
1109       walk_body (convert_nonlocal_reference, info, &OMP_BODY (t));
1110       info->suppress_expansion = save_suppress;
1111       break;
1112
1113     case OMP_SECTION:
1114     case OMP_MASTER:
1115     case OMP_ORDERED:
1116       walk_body (convert_nonlocal_reference, info, &OMP_BODY (t));
1117       break;
1118
1119     default:
1120       if (!IS_TYPE_OR_DECL_P (t))
1121         {
1122           *walk_subtrees = 1;
1123           wi->val_only = true;
1124           wi->is_lhs = false;
1125         }
1126       break;
1127     }
1128
1129   return NULL_TREE;
1130 }
1131
1132 static bool
1133 convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1134 {
1135   struct nesting_info *info = wi->info;
1136   bool need_chain = false;
1137   tree clause, decl;
1138   int dummy;
1139   bitmap new_suppress;
1140
1141   new_suppress = BITMAP_GGC_ALLOC ();
1142   bitmap_copy (new_suppress, info->suppress_expansion);
1143
1144   for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1145     {
1146       switch (OMP_CLAUSE_CODE (clause))
1147         {
1148         case OMP_CLAUSE_PRIVATE:
1149         case OMP_CLAUSE_FIRSTPRIVATE:
1150         case OMP_CLAUSE_LASTPRIVATE:
1151         case OMP_CLAUSE_REDUCTION:
1152         case OMP_CLAUSE_COPYPRIVATE:
1153         case OMP_CLAUSE_SHARED:
1154           decl = OMP_CLAUSE_DECL (clause);
1155           if (decl_function_context (decl) != info->context)
1156             {
1157               bitmap_set_bit (new_suppress, DECL_UID (decl));
1158               OMP_CLAUSE_DECL (clause) = get_nonlocal_debug_decl (info, decl);
1159               need_chain = true;
1160             }
1161           break;
1162
1163         case OMP_CLAUSE_SCHEDULE:
1164           if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1165             break;
1166           /* FALLTHRU */
1167         case OMP_CLAUSE_IF:
1168         case OMP_CLAUSE_NUM_THREADS:
1169           wi->val_only = true;
1170           wi->is_lhs = false;
1171           convert_nonlocal_reference (&OMP_CLAUSE_OPERAND (clause, 0), &dummy,
1172                                       wi);
1173           break;
1174
1175         case OMP_CLAUSE_NOWAIT:
1176         case OMP_CLAUSE_ORDERED:
1177         case OMP_CLAUSE_DEFAULT:
1178         case OMP_CLAUSE_COPYIN:
1179           break;
1180
1181         default:
1182           gcc_unreachable ();
1183         }
1184     }
1185
1186   info->suppress_expansion = new_suppress;
1187
1188   return need_chain;
1189 }
1190
1191 /* A subroutine of convert_local_reference.  Create a local variable
1192    in the parent function with DECL_VALUE_EXPR set to reference the
1193    field in FRAME.  This is used both for debug info and in OpenMP
1194    lowering.  */
1195
1196 static tree
1197 get_local_debug_decl (struct nesting_info *info, tree decl, tree field)
1198 {
1199   struct var_map_elt *elt, dummy;
1200   tree x, new_decl;
1201   void **slot;
1202
1203   dummy.old = decl;
1204   slot = htab_find_slot (info->var_map, &dummy, INSERT);
1205   elt = *slot;
1206
1207   if (elt)
1208     return elt->new;
1209
1210   /* Make sure frame_decl gets created.  */
1211   (void) get_frame_type (info);
1212   x = info->frame_decl;
1213   x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1214
1215   new_decl = build_decl (VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
1216   DECL_CONTEXT (new_decl) = info->context;
1217   DECL_SOURCE_LOCATION (new_decl) = DECL_SOURCE_LOCATION (decl);
1218   DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
1219   DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
1220   TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
1221   TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
1222   TREE_READONLY (new_decl) = TREE_READONLY (decl);
1223   TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
1224   DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
1225
1226   SET_DECL_VALUE_EXPR (new_decl, x);
1227   DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
1228
1229   elt = ggc_alloc (sizeof (*elt));
1230   elt->old = decl;
1231   elt->new = new_decl;
1232   *slot = elt;
1233
1234   TREE_CHAIN (new_decl) = info->debug_var_chain;
1235   info->debug_var_chain = new_decl;
1236
1237   /* Do not emit debug info twice.  */
1238   DECL_IGNORED_P (decl) = 1;
1239
1240   return new_decl;
1241 }
1242
1243 /* Called via walk_function+walk_tree, rewrite all references to VAR
1244    and PARM_DECLs that were referenced by inner nested functions.
1245    The rewrite will be a structure reference to the local frame variable.  */
1246
1247 static bool convert_local_omp_clauses (tree *, struct walk_stmt_info *);
1248
1249 static tree
1250 convert_local_reference (tree *tp, int *walk_subtrees, void *data)
1251 {
1252   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1253   struct nesting_info *info = wi->info;
1254   tree t = *tp, field, x;
1255   bool save_val_only;
1256   tree save_local_var_chain;
1257   bitmap save_suppress;
1258
1259   *walk_subtrees = 0;
1260   switch (TREE_CODE (t))
1261     {
1262     case VAR_DECL:
1263       /* Non-automatic variables are never processed.  */
1264       if (TREE_STATIC (t) || DECL_EXTERNAL (t))
1265         break;
1266       /* FALLTHRU */
1267
1268     case PARM_DECL:
1269       if (decl_function_context (t) == info->context)
1270         {
1271           /* If we copied a pointer to the frame, then the original decl
1272              is used unchanged in the parent function.  */
1273           if (use_pointer_in_frame (t))
1274             break;
1275
1276           /* No need to transform anything if no child references the
1277              variable.  */
1278           field = lookup_field_for_decl (info, t, NO_INSERT);
1279           if (!field)
1280             break;
1281           wi->changed = true;
1282
1283           x = get_local_debug_decl (info, t, field);
1284           if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
1285             x = get_frame_field (info, info->context, field, &wi->tsi);
1286
1287           if (wi->val_only)
1288             {
1289               if (wi->is_lhs)
1290                 x = save_tmp_var (info, x, &wi->tsi);
1291               else
1292                 x = init_tmp_var (info, x, &wi->tsi);
1293             }
1294
1295           *tp = x;
1296         }
1297       break;
1298
1299     case ADDR_EXPR:
1300       save_val_only = wi->val_only;
1301       wi->val_only = false;
1302       wi->is_lhs = false;
1303       wi->changed = false;
1304       walk_tree (&TREE_OPERAND (t, 0), convert_local_reference, wi, NULL);
1305       wi->val_only = save_val_only;
1306
1307       /* If we converted anything ... */
1308       if (wi->changed)
1309         {
1310           tree save_context;
1311
1312           /* Then the frame decl is now addressable.  */
1313           TREE_ADDRESSABLE (info->frame_decl) = 1;
1314
1315           save_context = current_function_decl;
1316           current_function_decl = info->context;
1317           recompute_tree_invariant_for_addr_expr (t);
1318           current_function_decl = save_context;
1319
1320           /* If we are in a context where we only accept values, then
1321              compute the address into a temporary.  */
1322           if (save_val_only)
1323             *tp = tsi_gimplify_val (wi->info, t, &wi->tsi);
1324         }
1325       break;
1326
1327     case REALPART_EXPR:
1328     case IMAGPART_EXPR:
1329     case COMPONENT_REF:
1330     case ARRAY_REF:
1331     case ARRAY_RANGE_REF:
1332     case BIT_FIELD_REF:
1333       /* Go down this entire nest and just look at the final prefix and
1334          anything that describes the references.  Otherwise, we lose track
1335          of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
1336       save_val_only = wi->val_only;
1337       wi->val_only = true;
1338       wi->is_lhs = false;
1339       for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1340         {
1341           if (TREE_CODE (t) == COMPONENT_REF)
1342             walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
1343                        NULL);
1344           else if (TREE_CODE (t) == ARRAY_REF
1345                    || TREE_CODE (t) == ARRAY_RANGE_REF)
1346             {
1347               walk_tree (&TREE_OPERAND (t, 1), convert_local_reference, wi,
1348                          NULL);
1349               walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
1350                          NULL);
1351               walk_tree (&TREE_OPERAND (t, 3), convert_local_reference, wi,
1352                          NULL);
1353             }
1354           else if (TREE_CODE (t) == BIT_FIELD_REF)
1355             {
1356               walk_tree (&TREE_OPERAND (t, 1), convert_local_reference, wi,
1357                          NULL);
1358               walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
1359                          NULL);
1360             }
1361         }
1362       wi->val_only = false;
1363       walk_tree (tp, convert_local_reference, wi, NULL);
1364       wi->val_only = save_val_only;
1365       break;
1366
1367     case OMP_PARALLEL:
1368       save_suppress = info->suppress_expansion;
1369       if (convert_local_omp_clauses (&OMP_PARALLEL_CLAUSES (t), wi))
1370         {
1371           tree c;
1372           (void) get_frame_type (info);
1373           c = build_omp_clause (OMP_CLAUSE_SHARED);
1374           OMP_CLAUSE_DECL (c) = info->frame_decl;
1375           OMP_CLAUSE_CHAIN (c) = OMP_PARALLEL_CLAUSES (t);
1376           OMP_PARALLEL_CLAUSES (t) = c;
1377         }
1378
1379       save_local_var_chain = info->new_local_var_chain;
1380       info->new_local_var_chain = NULL;
1381
1382       walk_body (convert_local_reference, info, &OMP_PARALLEL_BODY (t));
1383
1384       if (info->new_local_var_chain)
1385         declare_vars (info->new_local_var_chain, OMP_PARALLEL_BODY (t), false);
1386       info->new_local_var_chain = save_local_var_chain;
1387       info->suppress_expansion = save_suppress;
1388       break;
1389
1390     case OMP_FOR:
1391     case OMP_SECTIONS:
1392     case OMP_SINGLE:
1393       save_suppress = info->suppress_expansion;
1394       convert_local_omp_clauses (&OMP_CLAUSES (t), wi);
1395       walk_body (convert_local_reference, info, &OMP_BODY (t));
1396       info->suppress_expansion = save_suppress;
1397       break;
1398
1399     case OMP_SECTION:
1400     case OMP_MASTER:
1401     case OMP_ORDERED:
1402       walk_body (convert_local_reference, info, &OMP_BODY (t));
1403       break;
1404
1405     default:
1406       if (!IS_TYPE_OR_DECL_P (t))
1407         {
1408           *walk_subtrees = 1;
1409           wi->val_only = true;
1410           wi->is_lhs = false;
1411         }
1412       break;
1413     }
1414
1415   return NULL_TREE;
1416 }
1417
1418 static bool
1419 convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1420 {
1421   struct nesting_info *info = wi->info;
1422   bool need_frame = false;
1423   tree clause, decl;
1424   int dummy;
1425   bitmap new_suppress;
1426
1427   new_suppress = BITMAP_GGC_ALLOC ();
1428   bitmap_copy (new_suppress, info->suppress_expansion);
1429
1430   for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1431     {
1432       switch (OMP_CLAUSE_CODE (clause))
1433         {
1434         case OMP_CLAUSE_PRIVATE:
1435         case OMP_CLAUSE_FIRSTPRIVATE:
1436         case OMP_CLAUSE_LASTPRIVATE:
1437         case OMP_CLAUSE_REDUCTION:
1438         case OMP_CLAUSE_COPYPRIVATE:
1439         case OMP_CLAUSE_SHARED:
1440           decl = OMP_CLAUSE_DECL (clause);
1441           if (decl_function_context (decl) == info->context
1442               && !use_pointer_in_frame (decl))
1443             {
1444               tree field = lookup_field_for_decl (info, decl, NO_INSERT);
1445               if (field)
1446                 {
1447                   bitmap_set_bit (new_suppress, DECL_UID (decl));
1448                   OMP_CLAUSE_DECL (clause)
1449                     = get_local_debug_decl (info, decl, field);
1450                   need_frame = true;
1451                 }
1452             }
1453           break;
1454
1455         case OMP_CLAUSE_SCHEDULE:
1456           if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1457             break;
1458           /* FALLTHRU */
1459         case OMP_CLAUSE_IF:
1460         case OMP_CLAUSE_NUM_THREADS:
1461           wi->val_only = true;
1462           wi->is_lhs = false;
1463           convert_local_reference (&OMP_CLAUSE_OPERAND (clause, 0), &dummy, wi);
1464           break;
1465
1466         case OMP_CLAUSE_NOWAIT:
1467         case OMP_CLAUSE_ORDERED:
1468         case OMP_CLAUSE_DEFAULT:
1469         case OMP_CLAUSE_COPYIN:
1470           break;
1471
1472         default:
1473           gcc_unreachable ();
1474         }
1475     }
1476
1477   info->suppress_expansion = new_suppress;
1478
1479   return need_frame;
1480 }
1481
1482 /* Called via walk_function+walk_tree, rewrite all GOTO_EXPRs that
1483    reference labels from outer functions.  The rewrite will be a
1484    call to __builtin_nonlocal_goto.  */
1485
1486 static tree
1487 convert_nl_goto_reference (tree *tp, int *walk_subtrees, void *data)
1488 {
1489   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1490   struct nesting_info *info = wi->info, *i;
1491   tree t = *tp, label, new_label, target_context, x, arg, field;
1492   struct var_map_elt *elt, dummy;
1493   void **slot;
1494
1495   *walk_subtrees = 0;
1496   if (TREE_CODE (t) != GOTO_EXPR)
1497     return NULL_TREE;
1498   label = GOTO_DESTINATION (t);
1499   if (TREE_CODE (label) != LABEL_DECL)
1500     return NULL_TREE;
1501   target_context = decl_function_context (label);
1502   if (target_context == info->context)
1503     return NULL_TREE;
1504
1505   for (i = info->outer; target_context != i->context; i = i->outer)
1506     continue;
1507
1508   /* The original user label may also be use for a normal goto, therefore
1509      we must create a new label that will actually receive the abnormal
1510      control transfer.  This new label will be marked LABEL_NONLOCAL; this
1511      mark will trigger proper behavior in the cfg, as well as cause the
1512      (hairy target-specific) non-local goto receiver code to be generated
1513      when we expand rtl.  Enter this association into var_map so that we
1514      can insert the new label into the IL during a second pass.  */
1515   dummy.old = label;
1516   slot = htab_find_slot (i->var_map, &dummy, INSERT);
1517   elt = (struct var_map_elt *) *slot;
1518   if (elt == NULL)
1519     {
1520       new_label = create_artificial_label ();
1521       DECL_NONLOCAL (new_label) = 1;
1522
1523       elt = GGC_NEW (struct var_map_elt);
1524       elt->old = label;
1525       elt->new = new_label;
1526       *slot = elt;
1527     }
1528   else
1529     new_label = elt->new;
1530
1531   /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field).  */
1532   field = get_nl_goto_field (i);
1533   x = get_frame_field (info, target_context, field, &wi->tsi);
1534   x = build_addr (x, target_context);
1535   x = tsi_gimplify_val (info, x, &wi->tsi);
1536   arg = tree_cons (NULL, x, NULL);
1537   x = build_addr (new_label, target_context);
1538   arg = tree_cons (NULL, x, arg);
1539   x = implicit_built_in_decls[BUILT_IN_NONLOCAL_GOTO];
1540   x = build_function_call_expr (x, arg);
1541
1542   SET_EXPR_LOCUS (x, EXPR_LOCUS (tsi_stmt (wi->tsi)));
1543   *tsi_stmt_ptr (wi->tsi) = x;
1544
1545   return NULL_TREE;
1546 }
1547
1548 /* Called via walk_function+walk_tree, rewrite all LABEL_EXPRs that
1549    are referenced via nonlocal goto from a nested function.  The rewrite
1550    will involve installing a newly generated DECL_NONLOCAL label, and
1551    (potentially) a branch around the rtl gunk that is assumed to be
1552    attached to such a label.  */
1553
1554 static tree
1555 convert_nl_goto_receiver (tree *tp, int *walk_subtrees, void *data)
1556 {
1557   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1558   struct nesting_info *info = wi->info;
1559   tree t = *tp, label, new_label, x;
1560   struct var_map_elt *elt, dummy;
1561   tree_stmt_iterator tmp_tsi;
1562
1563   *walk_subtrees = 0;
1564   if (TREE_CODE (t) != LABEL_EXPR)
1565     return NULL_TREE;
1566   label = LABEL_EXPR_LABEL (t);
1567
1568   dummy.old = label;
1569   elt = (struct var_map_elt *) htab_find (info->var_map, &dummy);
1570   if (!elt)
1571     return NULL_TREE;
1572   new_label = elt->new;
1573
1574   /* If there's any possibility that the previous statement falls through,
1575      then we must branch around the new non-local label.  */
1576   tmp_tsi = wi->tsi;
1577   tsi_prev (&tmp_tsi);
1578   if (tsi_end_p (tmp_tsi) || block_may_fallthru (tsi_stmt (tmp_tsi)))
1579     {
1580       x = build1 (GOTO_EXPR, void_type_node, label);
1581       tsi_link_before (&wi->tsi, x, TSI_SAME_STMT);
1582     }
1583   x = build1 (LABEL_EXPR, void_type_node, new_label);
1584   tsi_link_before (&wi->tsi, x, TSI_SAME_STMT);
1585
1586   return NULL_TREE;
1587 }
1588
1589 /* Called via walk_function+walk_tree, rewrite all references to addresses
1590    of nested functions that require the use of trampolines.  The rewrite
1591    will involve a reference a trampoline generated for the occasion.  */
1592
1593 static tree
1594 convert_tramp_reference (tree *tp, int *walk_subtrees, void *data)
1595 {
1596   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1597   struct nesting_info *info = wi->info, *i;
1598   tree t = *tp, decl, target_context, x, arg;
1599
1600   *walk_subtrees = 0;
1601   switch (TREE_CODE (t))
1602     {
1603     case ADDR_EXPR:
1604       /* Build
1605            T.1 = &CHAIN->tramp;
1606            T.2 = __builtin_adjust_trampoline (T.1);
1607            T.3 = (func_type)T.2;
1608       */
1609
1610       decl = TREE_OPERAND (t, 0);
1611       if (TREE_CODE (decl) != FUNCTION_DECL)
1612         break;
1613
1614       /* Only need to process nested functions.  */
1615       target_context = decl_function_context (decl);
1616       if (!target_context)
1617         break;
1618
1619       /* If the nested function doesn't use a static chain, then
1620          it doesn't need a trampoline.  */
1621       if (DECL_NO_STATIC_CHAIN (decl))
1622         break;
1623
1624       /* Lookup the immediate parent of the callee, as that's where
1625          we need to insert the trampoline.  */
1626       for (i = info; i->context != target_context; i = i->outer)
1627         continue;
1628       x = lookup_tramp_for_decl (i, decl, INSERT);
1629
1630       /* Compute the address of the field holding the trampoline.  */
1631       x = get_frame_field (info, target_context, x, &wi->tsi);
1632       x = build_addr (x, target_context);
1633       x = tsi_gimplify_val (info, x, &wi->tsi);
1634       arg = tree_cons (NULL, x, NULL);
1635
1636       /* Do machine-specific ugliness.  Normally this will involve
1637          computing extra alignment, but it can really be anything.  */
1638       x = implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE];
1639       x = build_function_call_expr (x, arg);
1640       x = init_tmp_var (info, x, &wi->tsi);
1641
1642       /* Cast back to the proper function type.  */
1643       x = build1 (NOP_EXPR, TREE_TYPE (t), x);
1644       x = init_tmp_var (info, x, &wi->tsi);
1645
1646       *tp = x;
1647       break;
1648
1649     case CALL_EXPR:
1650       /* Only walk call arguments, lest we generate trampolines for
1651          direct calls.  */
1652       walk_tree (&TREE_OPERAND (t, 1), convert_tramp_reference, wi, NULL);
1653       break;
1654
1655     default:
1656       if (!IS_TYPE_OR_DECL_P (t))
1657         *walk_subtrees = 1;
1658       break;
1659     }
1660
1661   return NULL_TREE;
1662 }
1663
1664 /* Called via walk_function+walk_tree, rewrite all CALL_EXPRs that
1665    reference nested functions to make sure that the static chain is
1666    set up properly for the call.  */
1667
1668 static tree
1669 convert_call_expr (tree *tp, int *walk_subtrees, void *data)
1670 {
1671   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1672   struct nesting_info *info = wi->info;
1673   tree t = *tp, decl, target_context;
1674   char save_static_chain_added;
1675   int i;
1676
1677   *walk_subtrees = 0;
1678   switch (TREE_CODE (t))
1679     {
1680     case CALL_EXPR:
1681       decl = get_callee_fndecl (t);
1682       if (!decl)
1683         break;
1684       target_context = decl_function_context (decl);
1685       if (target_context && !DECL_NO_STATIC_CHAIN (decl))
1686         {
1687           TREE_OPERAND (t, 2)
1688             = get_static_chain (info, target_context, &wi->tsi);
1689           info->static_chain_added
1690             |= (1 << (info->context != target_context));
1691         }
1692       break;
1693
1694     case RETURN_EXPR:
1695     case MODIFY_EXPR:
1696     case WITH_SIZE_EXPR:
1697       /* Only return modify and with_size_expr may contain calls.  */
1698       *walk_subtrees = 1;
1699       break;
1700
1701     case OMP_PARALLEL:
1702       save_static_chain_added = info->static_chain_added;
1703       info->static_chain_added = 0;
1704       walk_body (convert_call_expr, info, &OMP_PARALLEL_BODY (t));
1705       for (i = 0; i < 2; i++)
1706         {
1707           tree c, decl;
1708           if ((info->static_chain_added & (1 << i)) == 0)
1709             continue;
1710           decl = i ? get_chain_decl (info) : info->frame_decl;
1711           /* Don't add CHAIN.* or FRAME.* twice.  */
1712           for (c = OMP_PARALLEL_CLAUSES (t); c; c = OMP_CLAUSE_CHAIN (c))
1713             if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
1714                  || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
1715                 && OMP_CLAUSE_DECL (c) == decl)
1716               break;
1717           if (c == NULL)
1718             {
1719               c = build_omp_clause (OMP_CLAUSE_FIRSTPRIVATE);
1720               OMP_CLAUSE_DECL (c) = decl;
1721               OMP_CLAUSE_CHAIN (c) = OMP_PARALLEL_CLAUSES (t);
1722               OMP_PARALLEL_CLAUSES (t) = c;
1723             }
1724         }
1725       info->static_chain_added |= save_static_chain_added;
1726       break;
1727
1728     case OMP_FOR:
1729     case OMP_SECTIONS:
1730     case OMP_SECTION:
1731     case OMP_SINGLE:
1732     case OMP_MASTER:
1733     case OMP_ORDERED:
1734     case OMP_CRITICAL:
1735       walk_body (convert_call_expr, info, &OMP_BODY (t));
1736       break;
1737
1738     default:
1739       break;
1740     }
1741
1742   return NULL_TREE;
1743 }
1744
1745 /* Walk the nesting tree starting with ROOT, depth first.  Convert all
1746    trampolines and call expressions.  On the way back up, determine if
1747    a nested function actually uses its static chain; if not, remember that.  */
1748
1749 static void
1750 convert_all_function_calls (struct nesting_info *root)
1751 {
1752   do
1753     {
1754       if (root->inner)
1755         convert_all_function_calls (root->inner);
1756
1757       walk_function (convert_tramp_reference, root);
1758       walk_function (convert_call_expr, root);
1759
1760       /* If the function does not use a static chain, then remember that.  */
1761       if (root->outer && !root->chain_decl && !root->chain_field)
1762         DECL_NO_STATIC_CHAIN (root->context) = 1;
1763       else
1764         gcc_assert (!DECL_NO_STATIC_CHAIN (root->context));
1765
1766       root = root->next;
1767     }
1768   while (root);
1769 }
1770
1771 /* Do "everything else" to clean up or complete state collected by the
1772    various walking passes -- lay out the types and decls, generate code
1773    to initialize the frame decl, store critical expressions in the
1774    struct function for rtl to find.  */
1775
1776 static void
1777 finalize_nesting_tree_1 (struct nesting_info *root)
1778 {
1779   tree stmt_list = NULL;
1780   tree context = root->context;
1781   struct function *sf;
1782
1783   /* If we created a non-local frame type or decl, we need to lay them
1784      out at this time.  */
1785   if (root->frame_type)
1786     {
1787       /* In some cases the frame type will trigger the -Wpadded warning.
1788          This is not helpful; suppress it. */
1789       int save_warn_padded = warn_padded;
1790       warn_padded = 0;
1791       layout_type (root->frame_type);
1792       warn_padded = save_warn_padded;
1793       layout_decl (root->frame_decl, 0);
1794     }
1795
1796   /* If any parameters were referenced non-locally, then we need to
1797      insert a copy.  Likewise, if any variables were referenced by
1798      pointer, we need to initialize the address.  */
1799   if (root->any_parm_remapped)
1800     {
1801       tree p;
1802       for (p = DECL_ARGUMENTS (context); p ; p = TREE_CHAIN (p))
1803         {
1804           tree field, x, y;
1805
1806           field = lookup_field_for_decl (root, p, NO_INSERT);
1807           if (!field)
1808             continue;
1809
1810           if (use_pointer_in_frame (p))
1811             x = build_addr (p, context);
1812           else
1813             x = p;
1814
1815           y = build3 (COMPONENT_REF, TREE_TYPE (field),
1816                       root->frame_decl, field, NULL_TREE);
1817           x = build2 (MODIFY_EXPR, TREE_TYPE (field), y, x);
1818           append_to_statement_list (x, &stmt_list);
1819         }
1820     }
1821
1822   /* If a chain_field was created, then it needs to be initialized
1823      from chain_decl.  */
1824   if (root->chain_field)
1825     {
1826       tree x = build3 (COMPONENT_REF, TREE_TYPE (root->chain_field),
1827                        root->frame_decl, root->chain_field, NULL_TREE);
1828       x = build2 (MODIFY_EXPR, TREE_TYPE (x), x, get_chain_decl (root));
1829       append_to_statement_list (x, &stmt_list);
1830     }
1831
1832   /* If trampolines were created, then we need to initialize them.  */
1833   if (root->any_tramp_created)
1834     {
1835       struct nesting_info *i;
1836       for (i = root->inner; i ; i = i->next)
1837         {
1838           tree arg, x, field;
1839
1840           field = lookup_tramp_for_decl (root, i->context, NO_INSERT);
1841           if (!field)
1842             continue;
1843
1844           if (DECL_NO_STATIC_CHAIN (i->context))
1845             x = null_pointer_node;
1846           else
1847             x = build_addr (root->frame_decl, context);
1848           arg = tree_cons (NULL, x, NULL);
1849
1850           x = build_addr (i->context, context);
1851           arg = tree_cons (NULL, x, arg);
1852
1853           x = build3 (COMPONENT_REF, TREE_TYPE (field),
1854                       root->frame_decl, field, NULL_TREE);
1855           x = build_addr (x, context);
1856           arg = tree_cons (NULL, x, arg);
1857
1858           x = implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE];
1859           x = build_function_call_expr (x, arg);
1860
1861           append_to_statement_list (x, &stmt_list);
1862         }
1863     }
1864
1865   /* If we created initialization statements, insert them.  */
1866   if (stmt_list)
1867     {
1868       annotate_all_with_locus (&stmt_list,
1869                                DECL_SOURCE_LOCATION (context));
1870       append_to_statement_list (BIND_EXPR_BODY (DECL_SAVED_TREE (context)),
1871                                 &stmt_list);
1872       BIND_EXPR_BODY (DECL_SAVED_TREE (context)) = stmt_list;
1873     }
1874
1875   /* If a chain_decl was created, then it needs to be registered with
1876      struct function so that it gets initialized from the static chain
1877      register at the beginning of the function.  */
1878   sf = DECL_STRUCT_FUNCTION (root->context);
1879   sf->static_chain_decl = root->chain_decl;
1880
1881   /* Similarly for the non-local goto save area.  */
1882   if (root->nl_goto_field)
1883     {
1884       sf->nonlocal_goto_save_area
1885         = get_frame_field (root, context, root->nl_goto_field, NULL);
1886       sf->has_nonlocal_label = 1;
1887     }
1888
1889   /* Make sure all new local variables get inserted into the
1890      proper BIND_EXPR.  */
1891   if (root->new_local_var_chain)
1892     declare_vars (root->new_local_var_chain, DECL_SAVED_TREE (root->context),
1893                   false);
1894   if (root->debug_var_chain)
1895     declare_vars (root->debug_var_chain, DECL_SAVED_TREE (root->context),
1896                   true);
1897
1898   /* Dump the translated tree function.  */
1899   dump_function (TDI_nested, root->context);
1900 }
1901
1902 static void
1903 finalize_nesting_tree (struct nesting_info *root)
1904 {
1905   do
1906     {
1907       if (root->inner)
1908         finalize_nesting_tree (root->inner);
1909       finalize_nesting_tree_1 (root);
1910       root = root->next;
1911     }
1912   while (root);
1913 }
1914
1915 /* Unnest the nodes and pass them to cgraph.  */
1916
1917 static void
1918 unnest_nesting_tree_1 (struct nesting_info *root)
1919 {
1920   struct cgraph_node *node = cgraph_node (root->context);
1921
1922   /* For nested functions update the cgraph to reflect unnesting.
1923      We also delay finalizing of these functions up to this point.  */
1924   if (node->origin)
1925     {
1926        cgraph_unnest_node (cgraph_node (root->context));
1927        cgraph_finalize_function (root->context, true);
1928     }
1929 }
1930
1931 static void
1932 unnest_nesting_tree (struct nesting_info *root)
1933 {
1934   do
1935     {
1936       if (root->inner)
1937         unnest_nesting_tree (root->inner);
1938       unnest_nesting_tree_1 (root);
1939       root = root->next;
1940     }
1941   while (root);
1942 }
1943
1944 /* Free the data structures allocated during this pass.  */
1945
1946 static void
1947 free_nesting_tree (struct nesting_info *root)
1948 {
1949   struct nesting_info *next;
1950   do
1951     {
1952       if (root->inner)
1953         free_nesting_tree (root->inner);
1954       htab_delete (root->var_map);
1955       next = root->next;
1956       ggc_free (root);
1957       root = next;
1958     }
1959   while (root);
1960 }
1961
1962 static GTY(()) struct nesting_info *root;
1963
1964 /* Main entry point for this pass.  Process FNDECL and all of its nested
1965    subroutines and turn them into something less tightly bound.  */
1966
1967 void
1968 lower_nested_functions (tree fndecl)
1969 {
1970   struct cgraph_node *cgn;
1971
1972   /* If there are no nested functions, there's nothing to do.  */
1973   cgn = cgraph_node (fndecl);
1974   if (!cgn->nested)
1975     return;
1976
1977   root = create_nesting_tree (cgn);
1978   walk_all_functions (convert_nonlocal_reference, root);
1979   walk_all_functions (convert_local_reference, root);
1980   walk_all_functions (convert_nl_goto_reference, root);
1981   walk_all_functions (convert_nl_goto_receiver, root);
1982   convert_all_function_calls (root);
1983   finalize_nesting_tree (root);
1984   unnest_nesting_tree (root);
1985   free_nesting_tree (root);
1986   root = NULL;
1987 }
1988
1989 #include "gt-tree-nested.h"