gcc/tree-nested.c

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