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