gcc/tree-nested.c

   1 /* Nested function decomposition for trees.
   2    Copyright (C) 2004 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 2, 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 COPYING.  If not, write to
  18    the Free Software Foundation, 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "rtl.h"
  27 #include "tm_p.h"
  28 #include "function.h"
  29 #include "tree-dump.h"
  30 #include "tree-inline.h"
  31 #include "tree-gimple.h"
  32 #include "tree-iterator.h"
  33 #include "tree-flow.h"
  34 #include "cgraph.h"
  35 #include "expr.h"
  36 #include "langhooks.h"
  37 #include "ggc.h"
  38
  39
  40 /* The object of this pass is to lower the representation of a set of nested
  41    functions in order to expose all of the gory details of the various
  42    nonlocal references.  We want to do this sooner rather than later, in
  43    order to give us more freedom in emitting all of the functions in question.
  44
  45    Back in olden times, when gcc was young, we developed an insanely
  46    complicated scheme whereby variables which were referenced nonlocally
  47    were forced to live in the stack of the declaring function, and then
  48    the nested functions magically discovered where these variables were
  49    placed.  In order for this scheme to function properly, it required
  50    that the outer function be partially expanded, then we switch to
  51    compiling the inner function, and once done with those we switch back
  52    to compiling the outer function.  Such delicate ordering requirements
  53    makes it difficult to do whole translation unit optimizations
  54    involving such functions.
  55
  56    The implementation here is much more direct.  Everything that can be
  57    referenced by an inner function is a member of an explicitly created
  58    structure herein called the "nonlocal frame struct".  The incoming
  59    static chain for a nested function is a pointer to this struct in
  60    the parent.  In this way, we settle on known offsets from a known
  61    base, and so are decoupled from the logic that places objects in the
  62    function's stack frame.  More importantly, we don't have to wait for
  63    that to happen -- since the compilation of the inner function is no
  64    longer tied to a real stack frame, the nonlocal frame struct can be
  65    allocated anywhere.  Which means that the outer function is now
  66    inlinable.
  67
  68    Theory of operation here is very simple.  Iterate over all the
  69    statements in all the functions (depth first) several times,
  70    allocating structures and fields on demand.  In general we want to
  71    examine inner functions first, so that we can avoid making changes
  72    to outer functions which are unnecessary.
  73
  74    The order of the passes matters a bit, in that later passes will be
  75    skipped if it is discovered that the functions don't actually interact
  76    at all.  That is, they're nested in the lexical sense but could have
  77    been written as independent functions without change.  */
  78
  79
  80 struct var_map_elt
  81 {
  82   tree old;
  83   tree new;
  84 };
  85
  86 struct nesting_info
  87 {
  88   struct nesting_info *outer;
  89   struct nesting_info *inner;
  90   struct nesting_info *next;
  91
  92   htab_t var_map;
  93   tree context;
  94   tree new_local_var_chain;
  95   tree frame_type;
  96   tree frame_decl;
  97   tree chain_field;
  98   tree chain_decl;
  99   tree nl_goto_field;
 100
 101   bool any_parm_remapped;
 102   bool any_tramp_created;
 103 };
 104
 105
 106 /* Hashing and equality functions for nesting_info->var_map.  */
 107
 108 static hashval_t
 109 var_map_hash (const void *x)
 110 {
 111   const struct var_map_elt *a = x;
 112   return htab_hash_pointer (a->old);
 113 }
 114
 115 static int
 116 var_map_eq (const void *x, const void *y)
 117 {
 118   const struct var_map_elt *a = x;
 119   const struct var_map_elt *b = y;
 120   return a->old == b->old;
 121 }
 122
 123 /* We're working in so many different function contexts simultaneously,
 124    that create_tmp_var is dangerous.  Prevent mishap.  */
 125 #define create_tmp_var cant_use_create_tmp_var_here_dummy
 126
 127 /* Like create_tmp_var, except record the variable for registration at
 128    the given nesting level.  */
 129
 130 static tree
 131 create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix)
 132 {
 133   tree tmp_var;
 134
 135   /* If the type is of variable size or a type which must be created by the
 136      frontend, something is wrong.  Note that we explicitly allow
 137      incomplete types here, since we create them ourselves here.  */
 138   gcc_assert (!TREE_ADDRESSABLE (type));
 139   gcc_assert (!TYPE_SIZE_UNIT (type)
 140               || TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
 141
 142   tmp_var = create_tmp_var_raw (type, prefix);
 143   DECL_CONTEXT (tmp_var) = info->context;
 144   TREE_CHAIN (tmp_var) = info->new_local_var_chain;
 145   DECL_SEEN_IN_BIND_EXPR_P (tmp_var) = 1;
 146   info->new_local_var_chain = tmp_var;
 147
 148   return tmp_var;
 149 }
 150
 151 /* Take the address of EXP.  Mark it for addressability as necessary.  */
 152
 153 tree
 154 build_addr (tree exp)
 155 {
 156   tree base = exp;
 157
 158   while (TREE_CODE (base) == REALPART_EXPR || TREE_CODE (base) == IMAGPART_EXPR
 159          || handled_component_p (base))
 160     base = TREE_OPERAND (base, 0);
 161
 162   if (DECL_P (base))
 163     TREE_ADDRESSABLE (base) = 1;
 164
 165   return build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
 166 }
 167
 168 /* Insert FIELD into TYPE, sorted by alignment requirements.  */
 169
 170 static void
 171 insert_field_into_struct (tree type, tree field)
 172 {
 173   tree *p;
 174
 175   DECL_CONTEXT (field) = type;
 176
 177   for (p = &TYPE_FIELDS (type); *p ; p = &TREE_CHAIN (*p))
 178     if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
 179       break;
 180
 181   TREE_CHAIN (field) = *p;
 182   *p = field;
 183 }
 184
 185 /* Build or return the RECORD_TYPE that describes the frame state that is
 186    shared between INFO->CONTEXT and its nested functions.  This record will
 187    not be complete until finalize_nesting_tree; up until that point we'll
 188    be adding fields as necessary.
 189
 190    We also build the DECL that represents this frame in the function.  */
 191
 192 static tree
 193 get_frame_type (struct nesting_info *info)
 194 {
 195   tree type = info->frame_type;
 196   if (!type)
 197     {
 198       char *name;
 199
 200       type = make_node (RECORD_TYPE);
 201
 202       name = concat ("FRAME.",
 203                      IDENTIFIER_POINTER (DECL_NAME (info->context)),
 204                      NULL);
 205       TYPE_NAME (type) = get_identifier (name);
 206       free (name);
 207
 208       info->frame_type = type;
 209       info->frame_decl = create_tmp_var_for (info, type, "FRAME");
 210     }
 211   return type;
 212 }
 213
 214 /* Return true if DECL should be referenced by pointer in the non-local
 215    frame structure.  */
 216
 217 static bool
 218 use_pointer_in_frame (tree decl)
 219 {
 220   if (TREE_CODE (decl) == PARM_DECL)
 221     {
 222       /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable
 223          sized decls, and inefficient to copy large aggregates.  Don't bother
 224          moving anything but scalar variables.  */
 225       return AGGREGATE_TYPE_P (TREE_TYPE (decl));
 226     }
 227   else
 228     {
 229       /* Variable sized types make things "interesting" in the frame.  */
 230       return DECL_SIZE (decl) == NULL || !TREE_CONSTANT (DECL_SIZE (decl));
 231     }
 232 }
 233
 234 /* Given DECL, a non-locally accessed variable, find or create a field
 235    in the non-local frame structure for the given nesting context.  */
 236
 237 static tree
 238 lookup_field_for_decl (struct nesting_info *info, tree decl,
 239                        enum insert_option insert)
 240 {
 241   struct var_map_elt *elt, dummy;
 242   void **slot;
 243   tree field;
 244
 245   dummy.old = decl;
 246   slot = htab_find_slot (info->var_map, &dummy, insert);
 247   if (!slot)
 248     {
 249       gcc_assert (insert != INSERT);
 250       return NULL;
 251     }
 252   elt = *slot;
 253
 254   if (!elt && insert == INSERT)
 255     {
 256       field = make_node (FIELD_DECL);
 257       DECL_NAME (field) = DECL_NAME (decl);
 258
 259       if (use_pointer_in_frame (decl))
 260         {
 261           TREE_TYPE (field) = build_pointer_type (TREE_TYPE (decl));
 262           DECL_ALIGN (field) = TYPE_ALIGN (TREE_TYPE (field));
 263           DECL_NONADDRESSABLE_P (field) = 1;
 264         }
 265       else
 266         {
 267           TREE_TYPE (field) = TREE_TYPE (decl);
 268           DECL_SOURCE_LOCATION (field) = DECL_SOURCE_LOCATION (decl);
 269           DECL_ALIGN (field) = DECL_ALIGN (decl);
 270           DECL_USER_ALIGN (field) = DECL_USER_ALIGN (decl);
 271           TREE_ADDRESSABLE (field) = TREE_ADDRESSABLE (decl);
 272           DECL_NONADDRESSABLE_P (field) = !TREE_ADDRESSABLE (decl);
 273           TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (decl);
 274         }
 275
 276       insert_field_into_struct (get_frame_type (info), field);
 277
 278       elt = xmalloc (sizeof (*elt));
 279       elt->old = decl;
 280       elt->new = field;
 281       *slot = elt;
 282
 283       if (TREE_CODE (decl) == PARM_DECL)
 284         info->any_parm_remapped = true;
 285     }
 286   else
 287     field = elt ? elt->new : NULL;
 288
 289   return field;
 290 }
 291
 292 /* Build or return the variable that holds the static chain within
 293    INFO->CONTEXT.  This variable may only be used within INFO->CONTEXT.  */
 294
 295 static tree
 296 get_chain_decl (struct nesting_info *info)
 297 {
 298   tree decl = info->chain_decl;
 299   if (!decl)
 300     {
 301       tree type;
 302
 303       type = get_frame_type (info->outer);
 304       type = build_pointer_type (type);
 305
 306       /* Note that this variable is *not* entered into any BIND_EXPR;
 307          the construction of this variable is handled specially in
 308          expand_function_start and initialize_inlined_parameters.
 309          Note also that it's represented as a parameter.  This is more
 310          close to the truth, since the initial value does come from
 311          the caller.  */
 312       decl = build_decl (PARM_DECL, create_tmp_var_name ("CHAIN"), type);
 313       DECL_ARTIFICIAL (decl) = 1;
 314       DECL_IGNORED_P (decl) = 1;
 315       TREE_USED (decl) = 1;
 316       DECL_CONTEXT (decl) = info->context;
 317       DECL_ARG_TYPE (decl) = type;
 318
 319       /* Tell tree-inline.c that we never write to this variable, so
 320          it can copy-prop the replacement value immediately.  */
 321       TREE_READONLY (decl) = 1;
 322
 323       info->chain_decl = decl;
 324     }
 325   return decl;
 326 }
 327
 328 /* Build or return the field within the non-local frame state that holds
 329    the static chain for INFO->CONTEXT.  This is the way to walk back up
 330    multiple nesting levels.  */
 331
 332 static tree
 333 get_chain_field (struct nesting_info *info)
 334 {
 335   tree field = info->chain_field;
 336   if (!field)
 337     {
 338       tree type = build_pointer_type (get_frame_type (info->outer));
 339
 340       field = make_node (FIELD_DECL);
 341       DECL_NAME (field) = get_identifier ("__chain");
 342       TREE_TYPE (field) = type;
 343       DECL_ALIGN (field) = TYPE_ALIGN (type);
 344       DECL_NONADDRESSABLE_P (field) = 1;
 345
 346       insert_field_into_struct (get_frame_type (info), field);
 347
 348       info->chain_field = field;
 349     }
 350   return field;
 351 }
 352
 353 /* Copy EXP into a temporary.  Allocate the temporary in the context of
 354    INFO and insert the initialization statement before TSI.  */
 355
 356 static tree
 357 init_tmp_var (struct nesting_info *info, tree exp, tree_stmt_iterator *tsi)
 358 {
 359   tree t, stmt;
 360
 361   t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
 362   stmt = build (MODIFY_EXPR, TREE_TYPE (t), t, exp);
 363   SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi)));
 364   tsi_link_before (tsi, stmt, TSI_SAME_STMT);
 365
 366   return t;
 367 }
 368
 369 /* Similarly, but only do so to force EXP to satisfy is_gimple_val.  */
 370
 371 static tree
 372 tsi_gimplify_val (struct nesting_info *info, tree exp, tree_stmt_iterator *tsi)
 373 {
 374   if (is_gimple_val (exp))
 375     return exp;
 376   else
 377     return init_tmp_var (info, exp, tsi);
 378 }
 379
 380 /* Build or return the type used to represent a nested function trampoline.  */
 381
 382 static GTY(()) tree trampoline_type;
 383
 384 static tree
 385 get_trampoline_type (void)
 386 {
 387   tree record, t;
 388   unsigned align, size;
 389
 390   if (trampoline_type)
 391     return trampoline_type;
 392
 393   align = TRAMPOLINE_ALIGNMENT;
 394   size = TRAMPOLINE_SIZE;
 395
 396   /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
 397      then allocate extra space so that we can do dynamic alignment.  */
 398   if (align > STACK_BOUNDARY)
 399     {
 400       size += ((align/BITS_PER_UNIT) - 1) & -(STACK_BOUNDARY/BITS_PER_UNIT);
 401       align = STACK_BOUNDARY;
 402     }
 403
 404   t = build_index_type (build_int_cst (NULL_TREE, size - 1));
 405   t = build_array_type (char_type_node, t);
 406   t = build_decl (FIELD_DECL, get_identifier ("__data"), t);
 407   DECL_ALIGN (t) = align;
 408   DECL_USER_ALIGN (t) = 1;
 409
 410   record = make_node (RECORD_TYPE);
 411   TYPE_NAME (record) = get_identifier ("__builtin_trampoline");
 412   TYPE_FIELDS (record) = t;
 413   layout_type (record);
 414
 415   return record;
 416 }
 417
 418 /* Given DECL, a nested function, find or create a field in the non-local
 419    frame structure for a trampoline for this function.  */
 420
 421 static tree
 422 lookup_tramp_for_decl (struct nesting_info *info, tree decl,
 423                        enum insert_option insert)
 424 {
 425   struct var_map_elt *elt, dummy;
 426   void **slot;
 427   tree field;
 428
 429   dummy.old = decl;
 430   slot = htab_find_slot (info->var_map, &dummy, insert);
 431   if (!slot)
 432     {
 433       gcc_assert (insert != INSERT);
 434       return NULL;
 435     }
 436   elt = *slot;
 437
 438   if (!elt && insert == INSERT)
 439     {
 440       field = make_node (FIELD_DECL);
 441       DECL_NAME (field) = DECL_NAME (decl);
 442       TREE_TYPE (field) = get_trampoline_type ();
 443       TREE_ADDRESSABLE (field) = 1;
 444
 445       insert_field_into_struct (get_frame_type (info), field);
 446
 447       elt = xmalloc (sizeof (*elt));
 448       elt->old = decl;
 449       elt->new = field;
 450       *slot = elt;
 451
 452       info->any_tramp_created = true;
 453     }
 454   else
 455     field = elt ? elt->new : NULL;
 456
 457   return field;
 458 }
 459
 460 /* Build or return the field within the non-local frame state that holds
 461    the non-local goto "jmp_buf".  The buffer itself is maintained by the
 462    rtl middle-end as dynamic stack space is allocated.  */
 463
 464 static tree
 465 get_nl_goto_field (struct nesting_info *info)
 466 {
 467   tree field = info->nl_goto_field;
 468   if (!field)
 469     {
 470       unsigned size;
 471       tree type;
 472
 473       /* For __builtin_nonlocal_goto, we need N words.  The first is the
 474          frame pointer, the rest is for the target's stack pointer save
 475          area.  The number of words is controlled by STACK_SAVEAREA_MODE;
 476          not the best interface, but it'll do for now.  */
 477       if (Pmode == ptr_mode)
 478         type = ptr_type_node;
 479       else
 480         type = lang_hooks.types.type_for_mode (Pmode, 1);
 481
 482       size = GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL));
 483       size = size / GET_MODE_SIZE (Pmode);
 484       size = size + 1;
 485
 486       type = build_array_type
 487         (type, build_index_type (build_int_cst (NULL_TREE, size)));
 488
 489       field = make_node (FIELD_DECL);
 490       DECL_NAME (field) = get_identifier ("__nl_goto_buf");
 491       TREE_TYPE (field) = type;
 492       DECL_ALIGN (field) = TYPE_ALIGN (type);
 493       TREE_ADDRESSABLE (field) = 1;
 494
 495       insert_field_into_struct (get_frame_type (info), field);
 496
 497       info->nl_goto_field = field;
 498     }
 499
 500   return field;
 501 }
 502 \f
 503 /* Convenience routines to walk all statements of a gimple function.
 504
 505    For each statement, we invoke CALLBACK via walk_tree.  The passed
 506    data is a walk_stmt_info structure.  Of note here is a TSI that
 507    points to the current statement being walked.  The VAL_ONLY flag
 508    that indicates whether the *TP being examined may be replaced
 509    with something that matches is_gimple_val (if true) or something
 510    slightly more complicated (if false).  "Something" technically
 511    means the common subset of is_gimple_lvalue and is_gimple_rhs,
 512    but we never try to form anything more complicated than that, so
 513    we don't bother checking.  */
 514
 515 struct walk_stmt_info
 516 {
 517   walk_tree_fn callback;
 518   tree_stmt_iterator tsi;
 519   struct nesting_info *info;
 520   bool val_only;
 521 };
 522
 523 /* A subroutine of walk_function.  Iterate over all sub-statements of *TP.  */
 524
 525 static void
 526 walk_stmts (struct walk_stmt_info *wi, tree *tp)
 527 {
 528   tree t = *tp;
 529   if (!t)
 530     return;
 531
 532   switch (TREE_CODE (t))
 533     {
 534     case STATEMENT_LIST:
 535       {
 536         tree_stmt_iterator i;
 537         for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
 538           {
 539             wi->tsi = i;
 540             walk_stmts (wi, tsi_stmt_ptr (i));
 541           }
 542       }
 543       break;
 544
 545     case COND_EXPR:
 546       walk_tree (&COND_EXPR_COND (t), wi->callback, wi, NULL);
 547       walk_stmts (wi, &COND_EXPR_THEN (t));
 548       walk_stmts (wi, &COND_EXPR_ELSE (t));
 549       break;
 550     case CATCH_EXPR:
 551       walk_stmts (wi, &CATCH_BODY (t));
 552       break;
 553     case EH_FILTER_EXPR:
 554       walk_stmts (wi, &EH_FILTER_FAILURE (t));
 555       break;
 556     case TRY_CATCH_EXPR:
 557     case TRY_FINALLY_EXPR:
 558       walk_stmts (wi, &TREE_OPERAND (t, 0));
 559       walk_stmts (wi, &TREE_OPERAND (t, 1));
 560       break;
 561     case BIND_EXPR:
 562       walk_stmts (wi, &BIND_EXPR_BODY (t));
 563       break;
 564
 565     case RETURN_EXPR:
 566       walk_stmts (wi, &TREE_OPERAND (t, 0));
 567       break;
 568
 569     case MODIFY_EXPR:
 570       /* The immediate arguments of a MODIFY_EXPR may use COMPONENT_REF.  */
 571       wi->val_only = false;
 572       walk_tree (&TREE_OPERAND (t, 0), wi->callback, wi, NULL);
 573       wi->val_only = false;
 574       walk_tree (&TREE_OPERAND (t, 1), wi->callback, wi, NULL);
 575       wi->val_only = true;
 576       break;
 577
 578     default:
 579       wi->val_only = true;
 580       walk_tree (tp, wi->callback, wi, NULL);
 581       break;
 582     }
 583 }
 584
 585 /* Invoke CALLBACK on all statements of INFO->CONTEXT.  */
 586
 587 static void
 588 walk_function (walk_tree_fn callback, struct nesting_info *info)
 589 {
 590   struct walk_stmt_info wi;
 591
 592   memset (&wi, 0, sizeof (wi));
 593   wi.callback = callback;
 594   wi.info = info;
 595   wi.val_only = true;
 596
 597   walk_stmts (&wi, &DECL_SAVED_TREE (info->context));
 598 }
 599
 600 /* Similarly for ROOT and all functions nested underneath, depth first.  */
 601
 602 static void
 603 walk_all_functions (walk_tree_fn callback, struct nesting_info *root)
 604 {
 605   do
 606     {
 607       if (root->inner)
 608         walk_all_functions (callback, root->inner);
 609       walk_function (callback, root);
 610       root = root->next;
 611     }
 612   while (root);
 613 }
 614
 615 \f
 616 /* Construct our local datastructure describing the function nesting
 617    tree rooted by CGN.  */
 618
 619 static struct nesting_info *
 620 create_nesting_tree (struct cgraph_node *cgn)
 621 {
 622   struct nesting_info *info = xcalloc (1, sizeof (*info));
 623   info->var_map = htab_create (7, var_map_hash, var_map_eq, free);
 624   info->context = cgn->decl;
 625
 626   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 627     {
 628       struct nesting_info *sub = create_nesting_tree (cgn);
 629       sub->outer = info;
 630       sub->next = info->inner;
 631       info->inner = sub;
 632     }
 633
 634   return info;
 635 }
 636
 637 /* Return an expression computing the static chain for TARGET_CONTEXT
 638    from INFO->CONTEXT.  Insert any necessary computations before TSI.  */
 639
 640 static tree
 641 get_static_chain (struct nesting_info *info, tree target_context,
 642                   tree_stmt_iterator *tsi)
 643 {
 644   struct nesting_info *i;
 645   tree x;
 646
 647   if (info->context == target_context)
 648     {
 649       x = build_addr (info->frame_decl);
 650     }
 651   else
 652     {
 653       x = get_chain_decl (info);
 654
 655       for (i = info->outer; i->context != target_context; i = i->outer)
 656         {
 657           tree field = get_chain_field (i);
 658
 659           x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 660           x = build (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 661           x = init_tmp_var (info, x, tsi);
 662         }
 663     }
 664
 665   return x;
 666 }
 667
 668 /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
 669    frame as seen from INFO->CONTEXT.  Insert any necessary computations
 670    before TSI.  */
 671
 672 static tree
 673 get_frame_field (struct nesting_info *info, tree target_context,
 674                  tree field, tree_stmt_iterator *tsi)
 675 {
 676   struct nesting_info *i;
 677   tree x;
 678
 679   if (info->context == target_context)
 680     {
 681       /* Make sure frame_decl gets created.  */
 682       (void) get_frame_type (info);
 683       x = info->frame_decl;
 684     }
 685   else
 686     {
 687       x = get_chain_decl (info);
 688
 689       for (i = info->outer; i->context != target_context; i = i->outer)
 690         {
 691           tree field = get_chain_field (i);
 692
 693           x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 694           x = build (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 695           x = init_tmp_var (info, x, tsi);
 696         }
 697
 698       x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 699     }
 700
 701   x = build (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 702   return x;
 703 }
 704
 705 /* Called via walk_function+walk_tree, rewrite all references to VAR
 706    and PARM_DECLs that belong to outer functions.
 707
 708    The rewrite will involve some number of structure accesses back up
 709    the static chain.  E.g. for a variable FOO up one nesting level it'll
 710    be CHAIN->FOO.  For two levels it'll be CHAIN->__chain->FOO.  Further
 711    indirections apply to decls for which use_pointer_in_frame is true.  */
 712
 713 static tree
 714 convert_nonlocal_reference (tree *tp, int *walk_subtrees, void *data)
 715 {
 716   struct walk_stmt_info *wi = data;
 717   struct nesting_info *info = wi->info;
 718   tree t = *tp;
 719
 720   *walk_subtrees = 0;
 721   switch (TREE_CODE (t))
 722     {
 723     case VAR_DECL:
 724       /* Non-automatic variables are never processed.  */
 725       if (TREE_STATIC (t) || DECL_EXTERNAL (t))
 726         break;
 727       /* FALLTHRU */
 728
 729     case PARM_DECL:
 730       if (decl_function_context (t) != info->context)
 731         {
 732           tree target_context = decl_function_context (t);
 733           struct nesting_info *i;
 734           tree x;
 735
 736           for (i = info->outer; i->context != target_context; i = i->outer)
 737             continue;
 738           x = lookup_field_for_decl (i, t, INSERT);
 739           x = get_frame_field (info, target_context, x, &wi->tsi);
 740           if (use_pointer_in_frame (t))
 741             {
 742               x = init_tmp_var (info, x, &wi->tsi);
 743               x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
 744             }
 745           if (wi->val_only)
 746             x = init_tmp_var (info, x, &wi->tsi);
 747
 748           *tp = x;
 749         }
 750       break;
 751
 752     case GOTO_EXPR:
 753       /* Don't walk non-local gotos for now.  */
 754       if (TREE_CODE (GOTO_DESTINATION (t)) != LABEL_DECL)
 755         {
 756           *walk_subtrees = 1;
 757           wi->val_only = true;
 758         }
 759       break;
 760
 761     case LABEL_DECL:
 762       /* We're taking the address of a label from a parent function, but
 763          this is not itself a non-local goto.  Mark the label such that it
 764          will not be deleted, much as we would with a label address in
 765          static storage.  */
 766       if (decl_function_context (t) != info->context)
 767         FORCED_LABEL (t) = 1;
 768       break;
 769
 770     case ADDR_EXPR:
 771       {
 772         bool save_val_only = wi->val_only;
 773         tree save_sub = TREE_OPERAND (t, 0);
 774
 775         wi->val_only = false;
 776         walk_tree (&TREE_OPERAND (t, 0), convert_nonlocal_reference, wi, NULL);
 777         wi->val_only = true;
 778
 779         if (save_sub != TREE_OPERAND (t, 0))
 780           {
 781             /* If we changed anything, then TREE_INVARIANT is be wrong,
 782                since we're no longer directly referencing a decl.  */
 783             TREE_INVARIANT (t) = 0;
 784
 785             /* If the callback converted the address argument in a context
 786                where we only accept variables (and min_invariant, presumably),
 787                then compute the address into a temporary.  */
 788             if (save_val_only)
 789               *tp = tsi_gimplify_val (wi->info, t, &wi->tsi);
 790           }
 791       }
 792       break;
 793
 794     case REALPART_EXPR:
 795     case IMAGPART_EXPR:
 796     case COMPONENT_REF:
 797     case ARRAY_REF:
 798     case ARRAY_RANGE_REF:
 799     case BIT_FIELD_REF:
 800       /* Go down this entire nest and just look at the final prefix and
 801          anything that describes the references.  Otherwise, we lose track
 802          of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
 803       wi->val_only = true;
 804       for (; handled_component_p (t)
 805            || TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR;
 806            tp = &TREE_OPERAND (t, 0), t = *tp)
 807         {
 808           if (TREE_CODE (t) == COMPONENT_REF)
 809             walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
 810                        NULL);
 811           else if (TREE_CODE (t) == ARRAY_REF
 812                    || TREE_CODE (t) == ARRAY_RANGE_REF)
 813             {
 814               walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference, wi,
 815                          NULL);
 816               walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
 817                          NULL);
 818               walk_tree (&TREE_OPERAND (t, 3), convert_nonlocal_reference, wi,
 819                          NULL);
 820             }
 821           else if (TREE_CODE (t) == BIT_FIELD_REF)
 822             {
 823               walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference, wi,
 824                          NULL);
 825               walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
 826                          NULL);
 827             }
 828         }
 829       wi->val_only = false;
 830       walk_tree (tp, convert_nonlocal_reference, wi, NULL);
 831       break;
 832
 833     default:
 834       if (!DECL_P (t) && !TYPE_P (t))
 835         {
 836           *walk_subtrees = 1;
 837           wi->val_only = true;
 838         }
 839       break;
 840     }
 841
 842   return NULL_TREE;
 843 }
 844
 845 /* Called via walk_function+walk_tree, rewrite all references to VAR
 846    and PARM_DECLs that were referenced by inner nested functions.
 847    The rewrite will be a structure reference to the local frame variable.  */
 848
 849 static tree
 850 convert_local_reference (tree *tp, int *walk_subtrees, void *data)
 851 {
 852   struct walk_stmt_info *wi = data;
 853   struct nesting_info *info = wi->info;
 854   tree t = *tp, field, x;
 855
 856   switch (TREE_CODE (t))
 857     {
 858     case VAR_DECL:
 859       /* Non-automatic variables are never processed.  */
 860       if (TREE_STATIC (t) || DECL_EXTERNAL (t))
 861         break;
 862       /* FALLTHRU */
 863
 864     case PARM_DECL:
 865       if (decl_function_context (t) == info->context)
 866         {
 867           /* If we copied a pointer to the frame, then the original decl
 868              is used unchanged in the parent function.  */
 869           if (use_pointer_in_frame (t))
 870             break;
 871
 872           /* No need to transform anything if no child references the
 873              variable.  */
 874           field = lookup_field_for_decl (info, t, NO_INSERT);
 875           if (!field)
 876             break;
 877
 878           x = get_frame_field (info, info->context, field, &wi->tsi);
 879           if (wi->val_only)
 880             x = init_tmp_var (info, x, &wi->tsi);
 881           *tp = x;
 882         }
 883       break;
 884
 885     case ADDR_EXPR:
 886       {
 887         bool save_val_only = wi->val_only;
 888         tree save_sub = TREE_OPERAND (t, 0);
 889
 890         wi->val_only = false;
 891         walk_tree (&TREE_OPERAND (t, 0), convert_local_reference, wi, NULL);
 892         wi->val_only = save_val_only;
 893
 894         /* If we converted anything ... */
 895         if (TREE_OPERAND (t, 0) != save_sub)
 896           {
 897             /* Then the frame decl is now addressable.  */
 898             TREE_ADDRESSABLE (info->frame_decl) = 1;
 899
 900             /* If we are in a context where we only accept values, then
 901                compute the address into a temporary.  */
 902             if (save_val_only)
 903               *tp = tsi_gimplify_val (wi->info, t, &wi->tsi);
 904           }
 905       }
 906       break;
 907
 908     case REALPART_EXPR:
 909     case IMAGPART_EXPR:
 910     case COMPONENT_REF:
 911     case ARRAY_REF:
 912     case ARRAY_RANGE_REF:
 913     case BIT_FIELD_REF:
 914       /* Go down this entire nest and just look at the final prefix and
 915          anything that describes the references.  Otherwise, we lose track
 916          of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
 917       wi->val_only = true;
 918       for (; handled_component_p (t)
 919            || TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR;
 920            tp = &TREE_OPERAND (t, 0), t = *tp)
 921         {
 922           if (TREE_CODE (t) == COMPONENT_REF)
 923             walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
 924                        NULL);
 925           else if (TREE_CODE (t) == ARRAY_REF
 926                    || TREE_CODE (t) == ARRAY_RANGE_REF)
 927             {
 928               walk_tree (&TREE_OPERAND (t, 1), convert_local_reference, wi,
 929                          NULL);
 930               walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
 931                          NULL);
 932               walk_tree (&TREE_OPERAND (t, 3), convert_local_reference, wi,
 933                          NULL);
 934             }
 935           else if (TREE_CODE (t) == BIT_FIELD_REF)
 936             {
 937               walk_tree (&TREE_OPERAND (t, 1), convert_local_reference, wi,
 938                          NULL);
 939               walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
 940                          NULL);
 941             }
 942         }
 943       wi->val_only = false;
 944       walk_tree (tp, convert_local_reference, wi, NULL);
 945       break;
 946
 947     default:
 948       if (!DECL_P (t) && !TYPE_P (t))
 949         {
 950           *walk_subtrees = 1;
 951           wi->val_only = true;
 952         }
 953       break;
 954     }
 955
 956   return NULL_TREE;
 957 }
 958
 959 /* Called via walk_function+walk_tree, rewrite all GOTO_EXPRs that
 960    reference labels from outer functions.  The rewrite will be a
 961    call to __builtin_nonlocal_goto.  */
 962
 963 static tree
 964 convert_nl_goto_reference (tree *tp, int *walk_subtrees, void *data)
 965 {
 966   struct walk_stmt_info *wi = data;
 967   struct nesting_info *info = wi->info, *i;
 968   tree t = *tp, label, new_label, target_context, x, arg, field;
 969   struct var_map_elt *elt;
 970   void **slot;
 971
 972   *walk_subtrees = 0;
 973   if (TREE_CODE (t) != GOTO_EXPR)
 974     return NULL_TREE;
 975   label = GOTO_DESTINATION (t);
 976   if (TREE_CODE (label) != LABEL_DECL)
 977     return NULL_TREE;
 978   target_context = decl_function_context (label);
 979   if (target_context == info->context)
 980     return NULL_TREE;
 981
 982   for (i = info->outer; target_context != i->context; i = i->outer)
 983     continue;
 984
 985   /* The original user label may also be use for a normal goto, therefore
 986      we must create a new label that will actually receive the abnormal
 987      control transfer.  This new label will be marked LABEL_NONLOCAL; this
 988      mark will trigger proper behavior in the cfg, as well as cause the
 989      (hairy target-specific) non-local goto receiver code to be generated
 990      when we expand rtl.  */
 991   new_label = create_artificial_label ();
 992   DECL_NONLOCAL (new_label) = 1;
 993
 994   /* Enter this association into var_map so that we can insert the new
 995      label into the IL during a second pass.  */
 996   elt = xmalloc (sizeof (*elt));
 997   elt->old = label;
 998   elt->new = new_label;
 999   slot = htab_find_slot (i->var_map, elt, INSERT);
1000   *slot = elt;
1001
1002   /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field).  */
1003   field = get_nl_goto_field (i);
1004   x = get_frame_field (info, target_context, field, &wi->tsi);
1005   x = build_addr (x);
1006   x = tsi_gimplify_val (info, x, &wi->tsi);
1007   arg = tree_cons (NULL, x, NULL);
1008   x = build_addr (new_label);
1009   arg = tree_cons (NULL, x, arg);
1010   x = implicit_built_in_decls[BUILT_IN_NONLOCAL_GOTO];
1011   x = build_function_call_expr (x, arg);
1012
1013   SET_EXPR_LOCUS (x, EXPR_LOCUS (tsi_stmt (wi->tsi)));
1014   *tsi_stmt_ptr (wi->tsi) = x;
1015
1016   return NULL_TREE;
1017 }
1018
1019 /* Called via walk_function+walk_tree, rewrite all LABEL_EXPRs that
1020    are referenced via nonlocal goto from a nested function.  The rewrite
1021    will involve installing a newly generated DECL_NONLOCAL label, and
1022    (potentially) a branch around the rtl gunk that is assumed to be
1023    attached to such a label.  */
1024
1025 static tree
1026 convert_nl_goto_receiver (tree *tp, int *walk_subtrees, void *data)
1027 {
1028   struct walk_stmt_info *wi = data;
1029   struct nesting_info *info = wi->info;
1030   tree t = *tp, label, new_label, x;
1031   struct var_map_elt *elt, dummy;
1032   tree_stmt_iterator tmp_tsi;
1033
1034   *walk_subtrees = 0;
1035   if (TREE_CODE (t) != LABEL_EXPR)
1036     return NULL_TREE;
1037   label = LABEL_EXPR_LABEL (t);
1038
1039   dummy.old = label;
1040   elt = htab_find (info->var_map, &dummy);
1041   if (!elt)
1042     return NULL_TREE;
1043   new_label = elt->new;
1044
1045   /* If there's any possibility that the previous statement falls through,
1046      then we must branch around the new non-local label.  */
1047   tmp_tsi = wi->tsi;
1048   tsi_prev (&tmp_tsi);
1049   if (tsi_end_p (tmp_tsi) || block_may_fallthru (tsi_stmt (tmp_tsi)))
1050     {
1051       x = build1 (GOTO_EXPR, void_type_node, label);
1052       tsi_link_before (&wi->tsi, x, TSI_SAME_STMT);
1053     }
1054   x = build1 (LABEL_EXPR, void_type_node, new_label);
1055   tsi_link_before (&wi->tsi, x, TSI_SAME_STMT);
1056
1057   return NULL_TREE;
1058 }
1059
1060 /* Called via walk_function+walk_tree, rewrite all references to addresses
1061    of nested functions that require the use of trampolines.  The rewrite
1062    will involve a reference a trampoline generated for the occasion.  */
1063
1064 static tree
1065 convert_tramp_reference (tree *tp, int *walk_subtrees, void *data)
1066 {
1067   struct walk_stmt_info *wi = data;
1068   struct nesting_info *info = wi->info, *i;
1069   tree t = *tp, decl, target_context, x, arg;
1070
1071   *walk_subtrees = 0;
1072   switch (TREE_CODE (t))
1073     {
1074     case ADDR_EXPR:
1075       /* Build
1076            T.1 = &CHAIN->tramp;
1077            T.2 = __builtin_adjust_trampoline (T.1);
1078            T.3 = (func_type)T.2;
1079       */
1080
1081       decl = TREE_OPERAND (t, 0);
1082       if (TREE_CODE (decl) != FUNCTION_DECL)
1083         break;
1084
1085       /* Only need to process nested functions.  */
1086       target_context = decl_function_context (decl);
1087       if (!target_context)
1088         break;
1089
1090       /* If the nested function doesn't use a static chain, then
1091          it doesn't need a trampoline.  */
1092       if (DECL_NO_STATIC_CHAIN (decl))
1093         break;
1094
1095       /* Lookup the immediate parent of the callee, as that's where
1096          we need to insert the trampoline.  */
1097       for (i = info; i->context != target_context; i = i->outer)
1098         continue;
1099       x = lookup_tramp_for_decl (i, decl, INSERT);
1100
1101       /* Compute the address of the field holding the trampoline.  */
1102       x = get_frame_field (info, target_context, x, &wi->tsi);
1103       x = build_addr (x);
1104       x = tsi_gimplify_val (info, x, &wi->tsi);
1105       arg = tree_cons (NULL, x, NULL);
1106
1107       /* Do machine-specific ugliness.  Normally this will involve
1108          computing extra alignment, but it can really be anything.  */
1109       x = implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE];
1110       x = build_function_call_expr (x, arg);
1111       x = init_tmp_var (info, x, &wi->tsi);
1112
1113       /* Cast back to the proper function type.  */
1114       x = build1 (NOP_EXPR, TREE_TYPE (t), x);
1115       x = init_tmp_var (info, x, &wi->tsi);
1116
1117       *tp = x;
1118       break;
1119
1120     case CALL_EXPR:
1121       /* Only walk call arguments, lest we generate trampolines for
1122          direct calls.  */
1123       walk_tree (&TREE_OPERAND (t, 1), convert_tramp_reference, wi, NULL);
1124       break;
1125
1126     default:
1127       if (!DECL_P (t) && !TYPE_P (t))
1128         *walk_subtrees = 1;
1129       break;
1130     }
1131
1132   return NULL_TREE;
1133 }
1134
1135 /* Called via walk_function+walk_tree, rewrite all CALL_EXPRs that
1136    reference nested functions to make sure that the static chain is
1137    set up properly for the call.  */
1138
1139 static tree
1140 convert_call_expr (tree *tp, int *walk_subtrees, void *data)
1141 {
1142   struct walk_stmt_info *wi = data;
1143   struct nesting_info *info = wi->info;
1144   tree t = *tp, decl, target_context;
1145
1146   *walk_subtrees = 0;
1147   switch (TREE_CODE (t))
1148     {
1149     case CALL_EXPR:
1150       decl = get_callee_fndecl (t);
1151       if (!decl)
1152         break;
1153       target_context = decl_function_context (decl);
1154       if (target_context && !DECL_NO_STATIC_CHAIN (decl))
1155         TREE_OPERAND (t, 2)
1156           = get_static_chain (info, target_context, &wi->tsi);
1157       break;
1158
1159     case RETURN_EXPR:
1160     case MODIFY_EXPR:
1161     case WITH_SIZE_EXPR:
1162       /* Only return modify and with_size_expr may contain calls.  */
1163       *walk_subtrees = 1;
1164       break;
1165
1166     default:
1167       break;
1168     }
1169
1170   return NULL_TREE;
1171 }
1172
1173 /* Walk the nesting tree starting with ROOT, depth first.  Convert all
1174    trampolines and call expressions.  On the way back up, determine if
1175    a nested function actually uses its static chain; if not, remember that.  */
1176
1177 static void
1178 convert_all_function_calls (struct nesting_info *root)
1179 {
1180   do
1181     {
1182       if (root->inner)
1183         convert_all_function_calls (root->inner);
1184
1185       walk_function (convert_tramp_reference, root);
1186       walk_function (convert_call_expr, root);
1187
1188       /* If the function does not use a static chain, then remember that.  */
1189       if (root->outer && !root->chain_decl && !root->chain_field)
1190         DECL_NO_STATIC_CHAIN (root->context) = 1;
1191       else
1192         gcc_assert (!DECL_NO_STATIC_CHAIN (root->context));
1193
1194       root = root->next;
1195     }
1196   while (root);
1197 }
1198
1199 /* Do "everything else" to clean up or complete state collected by the
1200    various walking passes -- lay out the types and decls, generate code
1201    to initialize the frame decl, store critical expressions in the
1202    struct function for rtl to find.  */
1203
1204 static void
1205 finalize_nesting_tree_1 (struct nesting_info *root)
1206 {
1207   tree stmt_list = NULL;
1208   tree context = root->context;
1209   struct function *sf;
1210
1211   /* If we created a non-local frame type or decl, we need to lay them
1212      out at this time.  */
1213   if (root->frame_type)
1214     {
1215       layout_type (root->frame_type);
1216       layout_decl (root->frame_decl, 0);
1217     }
1218
1219   /* If any parameters were referenced non-locally, then we need to
1220      insert a copy.  Likewise, if any variables were referenced by
1221      pointer, we need to initialize the address.  */
1222   if (root->any_parm_remapped)
1223     {
1224       tree p;
1225       for (p = DECL_ARGUMENTS (context); p ; p = TREE_CHAIN (p))
1226         {
1227           tree field, x, y;
1228
1229           field = lookup_field_for_decl (root, p, NO_INSERT);
1230           if (!field)
1231             continue;
1232
1233           if (use_pointer_in_frame (p))
1234             x = build_addr (p);
1235           else
1236             x = p;
1237
1238           y = build (COMPONENT_REF, TREE_TYPE (field),
1239                      root->frame_decl, field, NULL_TREE);
1240           x = build (MODIFY_EXPR, TREE_TYPE (field), y, x);
1241           append_to_statement_list (x, &stmt_list);
1242         }
1243     }
1244
1245   /* If a chain_field was created, then it needs to be initialized
1246      from chain_decl.  */
1247   if (root->chain_field)
1248     {
1249       tree x = build (COMPONENT_REF, TREE_TYPE (root->chain_field),
1250                       root->frame_decl, root->chain_field, NULL_TREE);
1251       x = build (MODIFY_EXPR, TREE_TYPE (x), x, get_chain_decl (root));
1252       append_to_statement_list (x, &stmt_list);
1253     }
1254
1255   /* If trampolines were created, then we need to initialize them.  */
1256   if (root->any_tramp_created)
1257     {
1258       struct nesting_info *i;
1259       for (i = root->inner; i ; i = i->next)
1260         {
1261           tree arg, x, field;
1262
1263           field = lookup_tramp_for_decl (root, i->context, NO_INSERT);
1264           if (!field)
1265             continue;
1266
1267           if (DECL_NO_STATIC_CHAIN (i->context))
1268             x = null_pointer_node;
1269           else
1270             x = build_addr (root->frame_decl);
1271           arg = tree_cons (NULL, x, NULL);
1272
1273           x = build_addr (i->context);
1274           arg = tree_cons (NULL, x, arg);
1275
1276           x = build (COMPONENT_REF, TREE_TYPE (field),
1277                      root->frame_decl, field, NULL_TREE);
1278           x = build_addr (x);
1279           arg = tree_cons (NULL, x, arg);
1280
1281           x = implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE];
1282           x = build_function_call_expr (x, arg);
1283
1284           append_to_statement_list (x, &stmt_list);
1285         }
1286     }
1287
1288   /* If we created initialization statements, insert them.  */
1289   if (stmt_list)
1290     {
1291       annotate_all_with_locus (&stmt_list,
1292                                DECL_SOURCE_LOCATION (context));
1293       append_to_statement_list (BIND_EXPR_BODY (DECL_SAVED_TREE (context)),
1294                                 &stmt_list);
1295       BIND_EXPR_BODY (DECL_SAVED_TREE (context)) = stmt_list;
1296     }
1297
1298   /* If a chain_decl was created, then it needs to be registered with
1299      struct function so that it gets initialized from the static chain
1300      register at the beginning of the function.  */
1301   sf = DECL_STRUCT_FUNCTION (root->context);
1302   sf->static_chain_decl = root->chain_decl;
1303
1304   /* Similarly for the non-local goto save area.  */
1305   if (root->nl_goto_field)
1306     {
1307       sf->nonlocal_goto_save_area
1308         = get_frame_field (root, context, root->nl_goto_field, NULL);
1309       sf->has_nonlocal_label = 1;
1310     }
1311
1312   /* Make sure all new local variables get inserted into the
1313      proper BIND_EXPR.  */
1314   if (root->new_local_var_chain)
1315     declare_tmp_vars (root->new_local_var_chain,
1316                       DECL_SAVED_TREE (root->context));
1317
1318   /* Dump the translated tree function.  */
1319   dump_function (TDI_nested, root->context);
1320 }
1321
1322 static void
1323 finalize_nesting_tree (struct nesting_info *root)
1324 {
1325   do
1326     {
1327       if (root->inner)
1328         finalize_nesting_tree (root->inner);
1329       finalize_nesting_tree_1 (root);
1330       root = root->next;
1331     }
1332   while (root);
1333 }
1334
1335 /* Free the data structures allocated during this pass.  */
1336
1337 static void
1338 free_nesting_tree (struct nesting_info *root)
1339 {
1340   struct nesting_info *next;
1341   do
1342     {
1343       if (root->inner)
1344         free_nesting_tree (root->inner);
1345       htab_delete (root->var_map);
1346       next = root->next;
1347       free (root);
1348       root = next;
1349     }
1350   while (root);
1351 }
1352
1353 /* Main entry point for this pass.  Process FNDECL and all of its nested
1354    subroutines and turn them into something less tightly bound.  */
1355
1356 void
1357 lower_nested_functions (tree fndecl)
1358 {
1359   struct nesting_info *root;
1360   struct cgraph_node *cgn;
1361
1362   /* If there are no nested functions, there's nothing to do.  */
1363   cgn = cgraph_node (fndecl);
1364   if (!cgn->nested)
1365     return;
1366
1367   root = create_nesting_tree (cgn);
1368   walk_all_functions (convert_nonlocal_reference, root);
1369   walk_all_functions (convert_local_reference, root);
1370   walk_all_functions (convert_nl_goto_reference, root);
1371   walk_all_functions (convert_nl_goto_receiver, root);
1372   convert_all_function_calls (root);
1373   finalize_nesting_tree (root);
1374   free_nesting_tree (root);
1375 }
1376
1377 #include "gt-tree-nested.h"