1 /* Nested function decomposition for GIMPLE.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 This file is part of GCC.
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)
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.
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/>. */
22 #include "coretypes.h"
28 #include "tree-dump.h"
29 #include "tree-inline.h"
31 #include "tree-iterator.h"
32 #include "tree-flow.h"
35 #include "langhooks.h"
36 #include "pointer-set.h"
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.
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.
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
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.
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. */
82 struct nesting_info *outer;
83 struct nesting_info *inner;
84 struct nesting_info *next;
86 struct pointer_map_t *field_map;
87 struct pointer_map_t *var_map;
88 bitmap suppress_expansion;
91 tree new_local_var_chain;
99 bool any_parm_remapped;
100 bool any_tramp_created;
101 char static_chain_added;
105 /* Obstack used for the bitmaps in the struct above. */
106 static struct bitmap_obstack nesting_info_bitmap_obstack;
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
113 /* Like create_tmp_var, except record the variable for registration at
114 the given nesting level. */
117 create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix)
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);
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;
136 info->new_local_var_chain = tmp_var;
141 /* Take the address of EXP to be used within function CONTEXT.
142 Mark it for addressability as necessary. */
145 build_addr (tree exp, tree context)
151 while (handled_component_p (base))
152 base = TREE_OPERAND (base, 0);
155 TREE_ADDRESSABLE (base) = 1;
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.
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;
171 /* Insert FIELD into TYPE, sorted by alignment requirements. */
174 insert_field_into_struct (tree type, tree field)
178 DECL_CONTEXT (field) = type;
180 for (p = &TYPE_FIELDS (type); *p ; p = &TREE_CHAIN (*p))
181 if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
184 TREE_CHAIN (field) = *p;
187 /* Set correct alignment for frame struct type. */
188 if (TYPE_ALIGN (type) < DECL_ALIGN (field))
189 TYPE_ALIGN (type) = DECL_ALIGN (field);
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.
197 We also build the DECL that represents this frame in the function. */
200 get_frame_type (struct nesting_info *info)
202 tree type = info->frame_type;
207 type = make_node (RECORD_TYPE);
209 name = concat ("FRAME.",
210 IDENTIFIER_POINTER (DECL_NAME (info->context)),
212 TYPE_NAME (type) = get_identifier (name);
215 info->frame_type = type;
216 info->frame_decl = create_tmp_var_for (info, type, "FRAME");
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;
229 /* Return true if DECL should be referenced by pointer in the non-local
233 use_pointer_in_frame (tree decl)
235 if (TREE_CODE (decl) == PARM_DECL)
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));
244 /* Variable sized types make things "interesting" in the frame. */
245 return DECL_SIZE (decl) == NULL || !TREE_CONSTANT (DECL_SIZE (decl));
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. */
253 lookup_field_for_decl (struct nesting_info *info, tree decl,
254 enum insert_option insert)
258 if (insert == NO_INSERT)
260 slot = pointer_map_contains (info->field_map, decl);
261 return slot ? (tree) *slot : NULL_TREE;
264 slot = pointer_map_insert (info->field_map, decl);
267 tree field = make_node (FIELD_DECL);
268 DECL_NAME (field) = DECL_NAME (decl);
270 if (use_pointer_in_frame (decl))
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;
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);
287 insert_field_into_struct (get_frame_type (info), field);
290 if (TREE_CODE (decl) == PARM_DECL)
291 info->any_parm_remapped = true;
297 /* Build or return the variable that holds the static chain within
298 INFO->CONTEXT. This variable may only be used within INFO->CONTEXT. */
301 get_chain_decl (struct nesting_info *info)
303 tree decl = info->chain_decl;
308 type = get_frame_type (info->outer);
309 type = build_pointer_type (type);
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
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;
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;
328 info->chain_decl = decl;
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. */
338 get_chain_field (struct nesting_info *info)
340 tree field = info->chain_field;
343 tree type = build_pointer_type (get_frame_type (info->outer));
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;
351 insert_field_into_struct (get_frame_type (info), field);
353 info->chain_field = field;
358 /* Initialize a new temporary with the GIMPLE_CALL STMT. */
361 init_tmp_var_with_call (struct nesting_info *info, gimple_stmt_iterator *gsi,
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);
376 /* Copy EXP into a temporary. Allocate the temporary in the context of
377 INFO and insert the initialization statement before GSI. */
380 init_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
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);
395 /* Similarly, but only do so to force EXP to satisfy is_gimple_val. */
398 gsi_gimplify_val (struct nesting_info *info, tree exp,
399 gimple_stmt_iterator *gsi)
401 if (is_gimple_val (exp))
404 return init_tmp_var (info, exp, gsi);
407 /* Similarly, but copy from the temporary and insert the statement
408 after the iterator. */
411 save_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
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);
425 /* Build or return the type used to represent a nested function trampoline. */
427 static GTY(()) tree trampoline_type;
430 get_trampoline_type (void)
432 unsigned align, size;
436 return trampoline_type;
438 align = TRAMPOLINE_ALIGNMENT;
439 size = TRAMPOLINE_SIZE;
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)
445 size += ((align/BITS_PER_UNIT) - 1) & -(STACK_BOUNDARY/BITS_PER_UNIT);
446 align = STACK_BOUNDARY;
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;
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;
461 return trampoline_type;
464 /* Given DECL, a nested function, find or create a field in the non-local
465 frame structure for a trampoline for this function. */
468 lookup_tramp_for_decl (struct nesting_info *info, tree decl,
469 enum insert_option insert)
473 if (insert == NO_INSERT)
475 slot = pointer_map_contains (info->var_map, decl);
476 return slot ? (tree) *slot : NULL_TREE;
479 slot = pointer_map_insert (info->var_map, decl);
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;
487 insert_field_into_struct (get_frame_type (info), field);
490 info->any_tramp_created = true;
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. */
501 get_nl_goto_field (struct nesting_info *info)
503 tree field = info->nl_goto_field;
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;
516 type = lang_hooks.types.type_for_mode (Pmode, 1);
518 size = GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL));
519 size = size / GET_MODE_SIZE (Pmode);
522 type = build_array_type
523 (type, build_index_type (build_int_cst (NULL_TREE, size)));
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;
531 insert_field_into_struct (get_frame_type (info), field);
533 info->nl_goto_field = field;
539 /* Invoke CALLBACK on all statements of GIMPLE sequence SEQ. */
542 walk_body (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
543 struct nesting_info *info, gimple_seq seq)
545 struct walk_stmt_info wi;
547 memset (&wi, 0, sizeof (wi));
550 walk_gimple_seq (seq, callback_stmt, callback_op, &wi);
554 /* Invoke CALLBACK_STMT/CALLBACK_OP on all statements of INFO->CONTEXT. */
557 walk_function (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
558 struct nesting_info *info)
560 walk_body (callback_stmt, callback_op, info, gimple_body (info->context));
563 /* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body. */
566 walk_gimple_omp_for (gimple for_stmt,
567 walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
568 struct nesting_info *info)
570 struct walk_stmt_info wi;
575 walk_body (callback_stmt, callback_op, info, gimple_omp_for_pre_body (for_stmt));
577 seq = gimple_seq_alloc ();
578 memset (&wi, 0, sizeof (wi));
580 wi.gsi = gsi_last (seq);
582 for (i = 0; i < gimple_omp_for_collapse (for_stmt); i++)
585 walk_tree (gimple_omp_for_index_ptr (for_stmt, i), callback_op,
589 walk_tree (gimple_omp_for_initial_ptr (for_stmt, i), callback_op,
594 walk_tree (gimple_omp_for_final_ptr (for_stmt, i), callback_op,
597 t = gimple_omp_for_incr (for_stmt, i);
598 gcc_assert (BINARY_CLASS_P (t));
600 walk_tree (&TREE_OPERAND (t, 0), callback_op, &wi, NULL);
603 walk_tree (&TREE_OPERAND (t, 1), callback_op, &wi, NULL);
606 if (gimple_seq_empty_p (seq))
607 gimple_seq_free (seq);
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);
617 /* Similarly for ROOT and all functions nested underneath, depth first. */
620 walk_all_functions (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
621 struct nesting_info *root)
626 walk_all_functions (callback_stmt, callback_op, root->inner);
627 walk_function (callback_stmt, callback_op, root);
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.
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.
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. */
658 check_for_nested_with_variably_modified (tree fndecl, tree orig_fndecl)
660 struct cgraph_node *cgn = cgraph_node (fndecl);
663 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
665 for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = TREE_CHAIN (arg))
666 if (variably_modified_type_p (TREE_TYPE (arg), orig_fndecl))
669 if (check_for_nested_with_variably_modified (cgn->decl, orig_fndecl))
676 /* Construct our local datastructure describing the function nesting
677 tree rooted by CGN. */
679 static struct nesting_info *
680 create_nesting_tree (struct cgraph_node *cgn)
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;
688 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
690 struct nesting_info *sub = create_nesting_tree (cgn);
692 sub->next = info->inner;
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;
704 /* Return an expression computing the static chain for TARGET_CONTEXT
705 from INFO->CONTEXT. Insert any necessary computations before TSI. */
708 get_static_chain (struct nesting_info *info, tree target_context,
709 gimple_stmt_iterator *gsi)
711 struct nesting_info *i;
714 if (info->context == target_context)
716 x = build_addr (info->frame_decl, target_context);
720 x = get_chain_decl (info);
722 for (i = info->outer; i->context != target_context; i = i->outer)
724 tree field = get_chain_field (i);
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);
736 /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
737 frame as seen from INFO->CONTEXT. Insert any necessary computations
741 get_frame_field (struct nesting_info *info, tree target_context,
742 tree field, gimple_stmt_iterator *gsi)
744 struct nesting_info *i;
747 if (info->context == target_context)
749 /* Make sure frame_decl gets created. */
750 (void) get_frame_type (info);
751 x = info->frame_decl;
755 x = get_chain_decl (info);
757 for (i = info->outer; i->context != target_context; i = i->outer)
759 tree field = get_chain_field (i);
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);
766 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
769 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
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. */
780 get_nonlocal_debug_decl (struct nesting_info *info, tree decl)
783 struct nesting_info *i;
784 tree x, field, new_decl;
787 slot = pointer_map_insert (info->var_map, decl);
792 target_context = decl_function_context (decl);
794 /* A copy of the code in get_frame_field, but without the temporaries. */
795 if (info->context == target_context)
797 /* Make sure frame_decl gets created. */
798 (void) get_frame_type (info);
799 x = info->frame_decl;
804 x = get_chain_decl (info);
805 for (i = info->outer; i->context != target_context; i = i->outer)
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);
811 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
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);
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 if ((TREE_CODE (decl) == PARM_DECL
831 || TREE_CODE (decl) == RESULT_DECL
832 || TREE_CODE (decl) == VAR_DECL)
833 && DECL_BY_REFERENCE (decl))
834 DECL_BY_REFERENCE (new_decl) = 1;
836 SET_DECL_VALUE_EXPR (new_decl, x);
837 DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
840 TREE_CHAIN (new_decl) = info->debug_var_chain;
841 info->debug_var_chain = new_decl;
847 /* Callback for walk_gimple_stmt, rewrite all references to VAR
848 and PARM_DECLs that belong to outer functions.
850 The rewrite will involve some number of structure accesses back up
851 the static chain. E.g. for a variable FOO up one nesting level it'll
852 be CHAIN->FOO. For two levels it'll be CHAIN->__chain->FOO. Further
853 indirections apply to decls for which use_pointer_in_frame is true. */
856 convert_nonlocal_reference_op (tree *tp, int *walk_subtrees, void *data)
858 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
859 struct nesting_info *const info = (struct nesting_info *) wi->info;
863 switch (TREE_CODE (t))
866 /* Non-automatic variables are never processed. */
867 if (TREE_STATIC (t) || DECL_EXTERNAL (t))
872 if (decl_function_context (t) != info->context)
877 x = get_nonlocal_debug_decl (info, t);
878 if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
880 tree target_context = decl_function_context (t);
881 struct nesting_info *i;
882 for (i = info->outer; i->context != target_context; i = i->outer)
884 x = lookup_field_for_decl (i, t, INSERT);
885 x = get_frame_field (info, target_context, x, &wi->gsi);
886 if (use_pointer_in_frame (t))
888 x = init_tmp_var (info, x, &wi->gsi);
889 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
896 x = save_tmp_var (info, x, &wi->gsi);
898 x = init_tmp_var (info, x, &wi->gsi);
906 /* We're taking the address of a label from a parent function, but
907 this is not itself a non-local goto. Mark the label such that it
908 will not be deleted, much as we would with a label address in
910 if (decl_function_context (t) != info->context)
911 FORCED_LABEL (t) = 1;
916 bool save_val_only = wi->val_only;
918 wi->val_only = false;
921 walk_tree (&TREE_OPERAND (t, 0), convert_nonlocal_reference_op, wi, 0);
928 /* If we changed anything, we might no longer be directly
929 referencing a decl. */
930 save_context = current_function_decl;
931 current_function_decl = info->context;
932 recompute_tree_invariant_for_addr_expr (t);
933 current_function_decl = save_context;
935 /* If the callback converted the address argument in a context
936 where we only accept variables (and min_invariant, presumably),
937 then compute the address into a temporary. */
939 *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
949 case ARRAY_RANGE_REF:
951 /* Go down this entire nest and just look at the final prefix and
952 anything that describes the references. Otherwise, we lose track
953 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
956 for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
958 if (TREE_CODE (t) == COMPONENT_REF)
959 walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op, wi,
961 else if (TREE_CODE (t) == ARRAY_REF
962 || TREE_CODE (t) == ARRAY_RANGE_REF)
964 walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference_op,
966 walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op,
968 walk_tree (&TREE_OPERAND (t, 3), convert_nonlocal_reference_op,
971 else if (TREE_CODE (t) == BIT_FIELD_REF)
973 walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference_op,
975 walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op,
979 wi->val_only = false;
980 walk_tree (tp, convert_nonlocal_reference_op, wi, NULL);
983 case VIEW_CONVERT_EXPR:
984 /* Just request to look at the subtrees, leaving val_only and lhs
985 untouched. This might actually be for !val_only + lhs, in which
986 case we don't want to force a replacement by a temporary. */
991 if (!IS_TYPE_OR_DECL_P (t))
1003 static tree convert_nonlocal_reference_stmt (gimple_stmt_iterator *, bool *,
1004 struct walk_stmt_info *);
1006 /* Helper for convert_nonlocal_references, rewrite all references to VAR
1007 and PARM_DECLs that belong to outer functions. */
1010 convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1012 struct nesting_info *const info = (struct nesting_info *) wi->info;
1013 bool need_chain = false, need_stmts = false;
1016 bitmap new_suppress;
1018 new_suppress = BITMAP_GGC_ALLOC ();
1019 bitmap_copy (new_suppress, info->suppress_expansion);
1021 for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1023 switch (OMP_CLAUSE_CODE (clause))
1025 case OMP_CLAUSE_REDUCTION:
1026 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1028 goto do_decl_clause;
1030 case OMP_CLAUSE_LASTPRIVATE:
1031 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
1033 goto do_decl_clause;
1035 case OMP_CLAUSE_PRIVATE:
1036 case OMP_CLAUSE_FIRSTPRIVATE:
1037 case OMP_CLAUSE_COPYPRIVATE:
1038 case OMP_CLAUSE_SHARED:
1040 decl = OMP_CLAUSE_DECL (clause);
1041 if (TREE_CODE (decl) == VAR_DECL
1042 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1044 if (decl_function_context (decl) != info->context)
1046 bitmap_set_bit (new_suppress, DECL_UID (decl));
1047 OMP_CLAUSE_DECL (clause) = get_nonlocal_debug_decl (info, decl);
1052 case OMP_CLAUSE_SCHEDULE:
1053 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1057 case OMP_CLAUSE_NUM_THREADS:
1058 wi->val_only = true;
1060 convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
1064 case OMP_CLAUSE_NOWAIT:
1065 case OMP_CLAUSE_ORDERED:
1066 case OMP_CLAUSE_DEFAULT:
1067 case OMP_CLAUSE_COPYIN:
1068 case OMP_CLAUSE_COLLAPSE:
1069 case OMP_CLAUSE_UNTIED:
1077 info->suppress_expansion = new_suppress;
1080 for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1081 switch (OMP_CLAUSE_CODE (clause))
1083 case OMP_CLAUSE_REDUCTION:
1084 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1087 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1088 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1090 walk_body (convert_nonlocal_reference_stmt,
1091 convert_nonlocal_reference_op, info,
1092 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
1093 walk_body (convert_nonlocal_reference_stmt,
1094 convert_nonlocal_reference_op, info,
1095 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
1096 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1101 case OMP_CLAUSE_LASTPRIVATE:
1102 walk_body (convert_nonlocal_reference_stmt,
1103 convert_nonlocal_reference_op, info,
1104 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
1115 /* Callback for walk_gimple_stmt. Rewrite all references to VAR and
1116 PARM_DECLs that belong to outer functions. This handles statements
1117 that are not handled via the standard recursion done in
1118 walk_gimple_stmt. STMT is the statement to examine, DATA is as in
1119 convert_nonlocal_reference_op. Set *HANDLED_OPS_P to true if all the
1120 operands of STMT have been handled by this function. */
1123 convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1124 struct walk_stmt_info *wi)
1126 struct nesting_info *info = (struct nesting_info *) wi->info;
1127 tree save_local_var_chain;
1128 bitmap save_suppress;
1129 gimple stmt = gsi_stmt (*gsi);
1131 switch (gimple_code (stmt))
1134 /* Don't walk non-local gotos for now. */
1135 if (TREE_CODE (gimple_goto_dest (stmt)) != LABEL_DECL)
1137 wi->val_only = true;
1139 *handled_ops_p = true;
1144 case GIMPLE_OMP_PARALLEL:
1145 case GIMPLE_OMP_TASK:
1146 save_suppress = info->suppress_expansion;
1147 if (convert_nonlocal_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
1151 decl = get_chain_decl (info);
1152 c = build_omp_clause (OMP_CLAUSE_FIRSTPRIVATE);
1153 OMP_CLAUSE_DECL (c) = decl;
1154 OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
1155 gimple_omp_taskreg_set_clauses (stmt, c);
1158 save_local_var_chain = info->new_local_var_chain;
1159 info->new_local_var_chain = NULL;
1161 walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1162 info, gimple_omp_body (stmt));
1164 if (info->new_local_var_chain)
1165 declare_vars (info->new_local_var_chain,
1166 gimple_seq_first_stmt (gimple_omp_body (stmt)),
1168 info->new_local_var_chain = save_local_var_chain;
1169 info->suppress_expansion = save_suppress;
1172 case GIMPLE_OMP_FOR:
1173 save_suppress = info->suppress_expansion;
1174 convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
1175 walk_gimple_omp_for (stmt, convert_nonlocal_reference_stmt,
1176 convert_nonlocal_reference_op, info);
1177 walk_body (convert_nonlocal_reference_stmt,
1178 convert_nonlocal_reference_op, info, gimple_omp_body (stmt));
1179 info->suppress_expansion = save_suppress;
1182 case GIMPLE_OMP_SECTIONS:
1183 save_suppress = info->suppress_expansion;
1184 convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
1185 walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1186 info, gimple_omp_body (stmt));
1187 info->suppress_expansion = save_suppress;
1190 case GIMPLE_OMP_SINGLE:
1191 save_suppress = info->suppress_expansion;
1192 convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
1193 walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1194 info, gimple_omp_body (stmt));
1195 info->suppress_expansion = save_suppress;
1198 case GIMPLE_OMP_SECTION:
1199 case GIMPLE_OMP_MASTER:
1200 case GIMPLE_OMP_ORDERED:
1201 walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1202 info, gimple_omp_body (stmt));
1206 /* For every other statement that we are not interested in
1207 handling here, let the walker traverse the operands. */
1208 *handled_ops_p = false;
1212 /* We have handled all of STMT operands, no need to traverse the operands. */
1213 *handled_ops_p = true;
1218 /* A subroutine of convert_local_reference. Create a local variable
1219 in the parent function with DECL_VALUE_EXPR set to reference the
1220 field in FRAME. This is used both for debug info and in OpenMP
1224 get_local_debug_decl (struct nesting_info *info, tree decl, tree field)
1229 slot = pointer_map_insert (info->var_map, decl);
1231 return (tree) *slot;
1233 /* Make sure frame_decl gets created. */
1234 (void) get_frame_type (info);
1235 x = info->frame_decl;
1236 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1238 new_decl = build_decl (VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
1239 DECL_CONTEXT (new_decl) = info->context;
1240 DECL_SOURCE_LOCATION (new_decl) = DECL_SOURCE_LOCATION (decl);
1241 DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
1242 DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
1243 TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
1244 TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
1245 TREE_READONLY (new_decl) = TREE_READONLY (decl);
1246 TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
1247 DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
1248 if ((TREE_CODE (decl) == PARM_DECL
1249 || TREE_CODE (decl) == RESULT_DECL
1250 || TREE_CODE (decl) == VAR_DECL)
1251 && DECL_BY_REFERENCE (decl))
1252 DECL_BY_REFERENCE (new_decl) = 1;
1254 SET_DECL_VALUE_EXPR (new_decl, x);
1255 DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
1258 TREE_CHAIN (new_decl) = info->debug_var_chain;
1259 info->debug_var_chain = new_decl;
1261 /* Do not emit debug info twice. */
1262 DECL_IGNORED_P (decl) = 1;
1268 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1269 and PARM_DECLs that were referenced by inner nested functions.
1270 The rewrite will be a structure reference to the local frame variable. */
1272 static bool convert_local_omp_clauses (tree *, struct walk_stmt_info *);
1275 convert_local_reference_op (tree *tp, int *walk_subtrees, void *data)
1277 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1278 struct nesting_info *const info = (struct nesting_info *) wi->info;
1279 tree t = *tp, field, x;
1283 switch (TREE_CODE (t))
1286 /* Non-automatic variables are never processed. */
1287 if (TREE_STATIC (t) || DECL_EXTERNAL (t))
1292 if (decl_function_context (t) == info->context)
1294 /* If we copied a pointer to the frame, then the original decl
1295 is used unchanged in the parent function. */
1296 if (use_pointer_in_frame (t))
1299 /* No need to transform anything if no child references the
1301 field = lookup_field_for_decl (info, t, NO_INSERT);
1306 x = get_local_debug_decl (info, t, field);
1307 if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
1308 x = get_frame_field (info, info->context, field, &wi->gsi);
1313 x = save_tmp_var (info, x, &wi->gsi);
1315 x = init_tmp_var (info, x, &wi->gsi);
1323 save_val_only = wi->val_only;
1324 wi->val_only = false;
1326 wi->changed = false;
1327 walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op, wi, NULL);
1328 wi->val_only = save_val_only;
1330 /* If we converted anything ... */
1335 /* Then the frame decl is now addressable. */
1336 TREE_ADDRESSABLE (info->frame_decl) = 1;
1338 save_context = current_function_decl;
1339 current_function_decl = info->context;
1340 recompute_tree_invariant_for_addr_expr (t);
1341 current_function_decl = save_context;
1343 /* If we are in a context where we only accept values, then
1344 compute the address into a temporary. */
1346 *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
1355 case ARRAY_RANGE_REF:
1357 /* Go down this entire nest and just look at the final prefix and
1358 anything that describes the references. Otherwise, we lose track
1359 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1360 save_val_only = wi->val_only;
1361 wi->val_only = true;
1363 for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1365 if (TREE_CODE (t) == COMPONENT_REF)
1366 walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
1368 else if (TREE_CODE (t) == ARRAY_REF
1369 || TREE_CODE (t) == ARRAY_RANGE_REF)
1371 walk_tree (&TREE_OPERAND (t, 1), convert_local_reference_op, wi,
1373 walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
1375 walk_tree (&TREE_OPERAND (t, 3), convert_local_reference_op, wi,
1378 else if (TREE_CODE (t) == BIT_FIELD_REF)
1380 walk_tree (&TREE_OPERAND (t, 1), convert_local_reference_op, wi,
1382 walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
1386 wi->val_only = false;
1387 walk_tree (tp, convert_local_reference_op, wi, NULL);
1388 wi->val_only = save_val_only;
1391 case VIEW_CONVERT_EXPR:
1392 /* Just request to look at the subtrees, leaving val_only and lhs
1393 untouched. This might actually be for !val_only + lhs, in which
1394 case we don't want to force a replacement by a temporary. */
1399 if (!IS_TYPE_OR_DECL_P (t))
1402 wi->val_only = true;
1411 static tree convert_local_reference_stmt (gimple_stmt_iterator *, bool *,
1412 struct walk_stmt_info *);
1414 /* Helper for convert_local_reference. Convert all the references in
1415 the chain of clauses at *PCLAUSES. WI is as in convert_local_reference. */
1418 convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1420 struct nesting_info *const info = (struct nesting_info *) wi->info;
1421 bool need_frame = false, need_stmts = false;
1424 bitmap new_suppress;
1426 new_suppress = BITMAP_GGC_ALLOC ();
1427 bitmap_copy (new_suppress, info->suppress_expansion);
1429 for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1431 switch (OMP_CLAUSE_CODE (clause))
1433 case OMP_CLAUSE_REDUCTION:
1434 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1436 goto do_decl_clause;
1438 case OMP_CLAUSE_LASTPRIVATE:
1439 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
1441 goto do_decl_clause;
1443 case OMP_CLAUSE_PRIVATE:
1444 case OMP_CLAUSE_FIRSTPRIVATE:
1445 case OMP_CLAUSE_COPYPRIVATE:
1446 case OMP_CLAUSE_SHARED:
1448 decl = OMP_CLAUSE_DECL (clause);
1449 if (TREE_CODE (decl) == VAR_DECL
1450 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1452 if (decl_function_context (decl) == info->context
1453 && !use_pointer_in_frame (decl))
1455 tree field = lookup_field_for_decl (info, decl, NO_INSERT);
1458 bitmap_set_bit (new_suppress, DECL_UID (decl));
1459 OMP_CLAUSE_DECL (clause)
1460 = get_local_debug_decl (info, decl, field);
1466 case OMP_CLAUSE_SCHEDULE:
1467 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1471 case OMP_CLAUSE_NUM_THREADS:
1472 wi->val_only = true;
1474 convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause, 0), &dummy,
1478 case OMP_CLAUSE_NOWAIT:
1479 case OMP_CLAUSE_ORDERED:
1480 case OMP_CLAUSE_DEFAULT:
1481 case OMP_CLAUSE_COPYIN:
1482 case OMP_CLAUSE_COLLAPSE:
1483 case OMP_CLAUSE_UNTIED:
1491 info->suppress_expansion = new_suppress;
1494 for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1495 switch (OMP_CLAUSE_CODE (clause))
1497 case OMP_CLAUSE_REDUCTION:
1498 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1501 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1502 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1504 walk_body (convert_local_reference_stmt,
1505 convert_local_reference_op, info,
1506 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
1507 walk_body (convert_local_reference_stmt,
1508 convert_local_reference_op, info,
1509 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
1510 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1515 case OMP_CLAUSE_LASTPRIVATE:
1516 walk_body (convert_local_reference_stmt,
1517 convert_local_reference_op, info,
1518 OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
1529 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1530 and PARM_DECLs that were referenced by inner nested functions.
1531 The rewrite will be a structure reference to the local frame variable. */
1534 convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1535 struct walk_stmt_info *wi)
1537 struct nesting_info *info = (struct nesting_info *) wi->info;
1538 tree save_local_var_chain;
1539 bitmap save_suppress;
1540 gimple stmt = gsi_stmt (*gsi);
1542 switch (gimple_code (stmt))
1544 case GIMPLE_OMP_PARALLEL:
1545 case GIMPLE_OMP_TASK:
1546 save_suppress = info->suppress_expansion;
1547 if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
1551 (void) get_frame_type (info);
1552 c = build_omp_clause (OMP_CLAUSE_SHARED);
1553 OMP_CLAUSE_DECL (c) = info->frame_decl;
1554 OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
1555 gimple_omp_taskreg_set_clauses (stmt, c);
1558 save_local_var_chain = info->new_local_var_chain;
1559 info->new_local_var_chain = NULL;
1561 walk_body (convert_local_reference_stmt, convert_local_reference_op, info,
1562 gimple_omp_body (stmt));
1564 if (info->new_local_var_chain)
1565 declare_vars (info->new_local_var_chain,
1566 gimple_seq_first_stmt (gimple_omp_body (stmt)), false);
1567 info->new_local_var_chain = save_local_var_chain;
1568 info->suppress_expansion = save_suppress;
1571 case GIMPLE_OMP_FOR:
1572 save_suppress = info->suppress_expansion;
1573 convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
1574 walk_gimple_omp_for (stmt, convert_local_reference_stmt,
1575 convert_local_reference_op, info);
1576 walk_body (convert_local_reference_stmt, convert_local_reference_op,
1577 info, gimple_omp_body (stmt));
1578 info->suppress_expansion = save_suppress;
1581 case GIMPLE_OMP_SECTIONS:
1582 save_suppress = info->suppress_expansion;
1583 convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
1584 walk_body (convert_local_reference_stmt, convert_local_reference_op,
1585 info, gimple_omp_body (stmt));
1586 info->suppress_expansion = save_suppress;
1589 case GIMPLE_OMP_SINGLE:
1590 save_suppress = info->suppress_expansion;
1591 convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
1592 walk_body (convert_local_reference_stmt, convert_local_reference_op,
1593 info, gimple_omp_body (stmt));
1594 info->suppress_expansion = save_suppress;
1597 case GIMPLE_OMP_SECTION:
1598 case GIMPLE_OMP_MASTER:
1599 case GIMPLE_OMP_ORDERED:
1600 walk_body (convert_local_reference_stmt, convert_local_reference_op,
1601 info, gimple_omp_body (stmt));
1605 /* For every other statement that we are not interested in
1606 handling here, let the walker traverse the operands. */
1607 *handled_ops_p = false;
1611 /* Indicate that we have handled all the operands ourselves. */
1612 *handled_ops_p = true;
1617 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_GOTOs
1618 that reference labels from outer functions. The rewrite will be a
1619 call to __builtin_nonlocal_goto. */
1622 convert_nl_goto_reference (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1623 struct walk_stmt_info *wi)
1625 struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
1626 tree label, new_label, target_context, x, field;
1629 gimple stmt = gsi_stmt (*gsi);
1631 if (gimple_code (stmt) != GIMPLE_GOTO)
1633 *handled_ops_p = false;
1637 label = gimple_goto_dest (stmt);
1638 if (TREE_CODE (label) != LABEL_DECL)
1640 *handled_ops_p = false;
1644 target_context = decl_function_context (label);
1645 if (target_context == info->context)
1647 *handled_ops_p = false;
1651 for (i = info->outer; target_context != i->context; i = i->outer)
1654 /* The original user label may also be use for a normal goto, therefore
1655 we must create a new label that will actually receive the abnormal
1656 control transfer. This new label will be marked LABEL_NONLOCAL; this
1657 mark will trigger proper behavior in the cfg, as well as cause the
1658 (hairy target-specific) non-local goto receiver code to be generated
1659 when we expand rtl. Enter this association into var_map so that we
1660 can insert the new label into the IL during a second pass. */
1661 slot = pointer_map_insert (i->var_map, label);
1664 new_label = create_artificial_label ();
1665 DECL_NONLOCAL (new_label) = 1;
1669 new_label = (tree) *slot;
1671 /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field). */
1672 field = get_nl_goto_field (i);
1673 x = get_frame_field (info, target_context, field, &wi->gsi);
1674 x = build_addr (x, target_context);
1675 x = gsi_gimplify_val (info, x, &wi->gsi);
1676 call = gimple_build_call (implicit_built_in_decls[BUILT_IN_NONLOCAL_GOTO], 2,
1677 build_addr (new_label, target_context), x);
1678 gsi_replace (&wi->gsi, call, false);
1680 /* We have handled all of STMT's operands, no need to keep going. */
1681 *handled_ops_p = true;
1686 /* Called via walk_function+walk_tree, rewrite all GIMPLE_LABELs whose labels
1687 are referenced via nonlocal goto from a nested function. The rewrite
1688 will involve installing a newly generated DECL_NONLOCAL label, and
1689 (potentially) a branch around the rtl gunk that is assumed to be
1690 attached to such a label. */
1693 convert_nl_goto_receiver (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1694 struct walk_stmt_info *wi)
1696 struct nesting_info *const info = (struct nesting_info *) wi->info;
1697 tree label, new_label;
1698 gimple_stmt_iterator tmp_gsi;
1700 gimple stmt = gsi_stmt (*gsi);
1702 if (gimple_code (stmt) != GIMPLE_LABEL)
1704 *handled_ops_p = false;
1708 label = gimple_label_label (stmt);
1710 slot = pointer_map_contains (info->var_map, label);
1713 *handled_ops_p = false;
1717 /* If there's any possibility that the previous statement falls through,
1718 then we must branch around the new non-local label. */
1720 gsi_prev (&tmp_gsi);
1721 if (gsi_end_p (tmp_gsi) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi)))
1723 gimple stmt = gimple_build_goto (label);
1724 gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
1727 new_label = (tree) *slot;
1728 stmt = gimple_build_label (new_label);
1729 gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
1731 *handled_ops_p = true;
1736 /* Called via walk_function+walk_stmt, rewrite all references to addresses
1737 of nested functions that require the use of trampolines. The rewrite
1738 will involve a reference a trampoline generated for the occasion. */
1741 convert_tramp_reference_op (tree *tp, int *walk_subtrees, void *data)
1743 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1744 struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
1745 tree t = *tp, decl, target_context, x, builtin;
1749 switch (TREE_CODE (t))
1753 T.1 = &CHAIN->tramp;
1754 T.2 = __builtin_adjust_trampoline (T.1);
1755 T.3 = (func_type)T.2;
1758 decl = TREE_OPERAND (t, 0);
1759 if (TREE_CODE (decl) != FUNCTION_DECL)
1762 /* Only need to process nested functions. */
1763 target_context = decl_function_context (decl);
1764 if (!target_context)
1767 /* If the nested function doesn't use a static chain, then
1768 it doesn't need a trampoline. */
1769 if (DECL_NO_STATIC_CHAIN (decl))
1772 /* If we don't want a trampoline, then don't build one. */
1773 if (TREE_NO_TRAMPOLINE (t))
1776 /* Lookup the immediate parent of the callee, as that's where
1777 we need to insert the trampoline. */
1778 for (i = info; i->context != target_context; i = i->outer)
1780 x = lookup_tramp_for_decl (i, decl, INSERT);
1782 /* Compute the address of the field holding the trampoline. */
1783 x = get_frame_field (info, target_context, x, &wi->gsi);
1784 x = build_addr (x, target_context);
1785 x = gsi_gimplify_val (info, x, &wi->gsi);
1787 /* Do machine-specific ugliness. Normally this will involve
1788 computing extra alignment, but it can really be anything. */
1789 builtin = implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE];
1790 call = gimple_build_call (builtin, 1, x);
1791 x = init_tmp_var_with_call (info, &wi->gsi, call);
1793 /* Cast back to the proper function type. */
1794 x = build1 (NOP_EXPR, TREE_TYPE (t), x);
1795 x = init_tmp_var (info, x, &wi->gsi);
1801 if (!IS_TYPE_OR_DECL_P (t))
1810 /* Called via walk_function+walk_gimple_stmt, rewrite all references
1811 to addresses of nested functions that require the use of
1812 trampolines. The rewrite will involve a reference a trampoline
1813 generated for the occasion. */
1816 convert_tramp_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1817 struct walk_stmt_info *wi)
1819 gimple stmt = gsi_stmt (*gsi);
1821 switch (gimple_code (stmt))
1825 /* Only walk call arguments, lest we generate trampolines for
1827 unsigned long i, nargs = gimple_call_num_args (stmt);
1828 for (i = 0; i < nargs; i++)
1829 walk_tree (gimple_call_arg_ptr (stmt, i), convert_tramp_reference_op,
1832 *handled_ops_p = true;
1840 *handled_ops_p = false;
1846 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_CALLs
1847 that reference nested functions to make sure that the static chain
1848 is set up properly for the call. */
1851 convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1852 struct walk_stmt_info *wi)
1854 struct nesting_info *const info = (struct nesting_info *) wi->info;
1855 tree decl, target_context;
1856 char save_static_chain_added;
1858 gimple stmt = gsi_stmt (*gsi);
1860 switch (gimple_code (stmt))
1863 decl = gimple_call_fndecl (stmt);
1866 target_context = decl_function_context (decl);
1867 if (target_context && !DECL_NO_STATIC_CHAIN (decl))
1869 gimple_call_set_chain (stmt, get_static_chain (info, target_context,
1871 info->static_chain_added |= (1 << (info->context != target_context));
1875 case GIMPLE_OMP_PARALLEL:
1876 case GIMPLE_OMP_TASK:
1877 save_static_chain_added = info->static_chain_added;
1878 info->static_chain_added = 0;
1879 walk_body (convert_gimple_call, NULL, info, gimple_omp_body (stmt));
1880 for (i = 0; i < 2; i++)
1883 if ((info->static_chain_added & (1 << i)) == 0)
1885 decl = i ? get_chain_decl (info) : info->frame_decl;
1886 /* Don't add CHAIN.* or FRAME.* twice. */
1887 for (c = gimple_omp_taskreg_clauses (stmt);
1889 c = OMP_CLAUSE_CHAIN (c))
1890 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
1891 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
1892 && OMP_CLAUSE_DECL (c) == decl)
1896 c = build_omp_clause (i ? OMP_CLAUSE_FIRSTPRIVATE
1897 : OMP_CLAUSE_SHARED);
1898 OMP_CLAUSE_DECL (c) = decl;
1899 OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
1900 gimple_omp_taskreg_set_clauses (stmt, c);
1903 info->static_chain_added |= save_static_chain_added;
1906 case GIMPLE_OMP_FOR:
1907 walk_body (convert_gimple_call, NULL, info,
1908 gimple_omp_for_pre_body (stmt));
1910 case GIMPLE_OMP_SECTIONS:
1911 case GIMPLE_OMP_SECTION:
1912 case GIMPLE_OMP_SINGLE:
1913 case GIMPLE_OMP_MASTER:
1914 case GIMPLE_OMP_ORDERED:
1915 case GIMPLE_OMP_CRITICAL:
1916 walk_body (convert_gimple_call, NULL, info, gimple_omp_body (stmt));
1920 /* Keep looking for other operands. */
1921 *handled_ops_p = false;
1925 *handled_ops_p = true;
1930 /* Walk the nesting tree starting with ROOT, depth first. Convert all
1931 trampolines and call expressions. On the way back up, determine if
1932 a nested function actually uses its static chain; if not, remember that. */
1935 convert_all_function_calls (struct nesting_info *root)
1940 convert_all_function_calls (root->inner);
1942 walk_function (convert_tramp_reference_stmt, convert_tramp_reference_op,
1944 walk_function (convert_gimple_call, NULL, root);
1946 /* If the function does not use a static chain, then remember that. */
1947 if (root->outer && !root->chain_decl && !root->chain_field)
1948 DECL_NO_STATIC_CHAIN (root->context) = 1;
1950 gcc_assert (!DECL_NO_STATIC_CHAIN (root->context));
1957 struct nesting_copy_body_data
1960 struct nesting_info *root;
1963 /* A helper subroutine for debug_var_chain type remapping. */
1966 nesting_copy_decl (tree decl, copy_body_data *id)
1968 struct nesting_copy_body_data *nid = (struct nesting_copy_body_data *) id;
1969 void **slot = pointer_map_contains (nid->root->var_map, decl);
1972 return (tree) *slot;
1974 if (TREE_CODE (decl) == TYPE_DECL && DECL_ORIGINAL_TYPE (decl))
1976 tree new_decl = copy_decl_no_change (decl, id);
1977 DECL_ORIGINAL_TYPE (new_decl)
1978 = remap_type (DECL_ORIGINAL_TYPE (decl), id);
1982 return copy_decl_no_change (decl, id);
1985 /* Do "everything else" to clean up or complete state collected by the
1986 various walking passes -- lay out the types and decls, generate code
1987 to initialize the frame decl, store critical expressions in the
1988 struct function for rtl to find. */
1991 finalize_nesting_tree_1 (struct nesting_info *root)
1993 gimple_seq stmt_list;
1995 tree context = root->context;
1996 struct function *sf;
2000 /* If we created a non-local frame type or decl, we need to lay them
2001 out at this time. */
2002 if (root->frame_type)
2004 /* In some cases the frame type will trigger the -Wpadded warning.
2005 This is not helpful; suppress it. */
2006 int save_warn_padded = warn_padded;
2008 layout_type (root->frame_type);
2009 warn_padded = save_warn_padded;
2010 layout_decl (root->frame_decl, 0);
2013 /* If any parameters were referenced non-locally, then we need to
2014 insert a copy. Likewise, if any variables were referenced by
2015 pointer, we need to initialize the address. */
2016 if (root->any_parm_remapped)
2019 for (p = DECL_ARGUMENTS (context); p ; p = TREE_CHAIN (p))
2023 field = lookup_field_for_decl (root, p, NO_INSERT);
2027 if (use_pointer_in_frame (p))
2028 x = build_addr (p, context);
2032 y = build3 (COMPONENT_REF, TREE_TYPE (field),
2033 root->frame_decl, field, NULL_TREE);
2034 stmt = gimple_build_assign (y, x);
2035 gimple_seq_add_stmt (&stmt_list, stmt);
2036 /* If the assignment is from a non-register the stmt is
2037 not valid gimple. Make it so by using a temporary instead. */
2038 if (!is_gimple_reg (x)
2039 && is_gimple_reg_type (TREE_TYPE (x)))
2041 gimple_stmt_iterator gsi = gsi_last (stmt_list);
2042 x = init_tmp_var (root, x, &gsi);
2043 gimple_assign_set_rhs1 (stmt, x);
2048 /* If a chain_field was created, then it needs to be initialized
2050 if (root->chain_field)
2052 tree x = build3 (COMPONENT_REF, TREE_TYPE (root->chain_field),
2053 root->frame_decl, root->chain_field, NULL_TREE);
2054 stmt = gimple_build_assign (x, get_chain_decl (root));
2055 gimple_seq_add_stmt (&stmt_list, stmt);
2058 /* If trampolines were created, then we need to initialize them. */
2059 if (root->any_tramp_created)
2061 struct nesting_info *i;
2062 for (i = root->inner; i ; i = i->next)
2064 tree arg1, arg2, arg3, x, field;
2066 field = lookup_tramp_for_decl (root, i->context, NO_INSERT);
2070 if (DECL_NO_STATIC_CHAIN (i->context))
2071 arg3 = null_pointer_node;
2073 arg3 = build_addr (root->frame_decl, context);
2075 arg2 = build_addr (i->context, context);
2077 x = build3 (COMPONENT_REF, TREE_TYPE (field),
2078 root->frame_decl, field, NULL_TREE);
2079 arg1 = build_addr (x, context);
2081 x = implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE];
2082 stmt = gimple_build_call (x, 3, arg1, arg2, arg3);
2083 gimple_seq_add_stmt (&stmt_list, stmt);
2087 /* If we created initialization statements, insert them. */
2091 annotate_all_with_location (stmt_list, DECL_SOURCE_LOCATION (context));
2092 bind = gimple_seq_first_stmt (gimple_body (context));
2093 gimple_seq_add_seq (&stmt_list, gimple_bind_body (bind));
2094 gimple_bind_set_body (bind, stmt_list);
2097 /* If a chain_decl was created, then it needs to be registered with
2098 struct function so that it gets initialized from the static chain
2099 register at the beginning of the function. */
2100 sf = DECL_STRUCT_FUNCTION (root->context);
2101 sf->static_chain_decl = root->chain_decl;
2103 /* Similarly for the non-local goto save area. */
2104 if (root->nl_goto_field)
2106 sf->nonlocal_goto_save_area
2107 = get_frame_field (root, context, root->nl_goto_field, NULL);
2108 sf->has_nonlocal_label = 1;
2111 /* Make sure all new local variables get inserted into the
2112 proper BIND_EXPR. */
2113 if (root->new_local_var_chain)
2114 declare_vars (root->new_local_var_chain,
2115 gimple_seq_first_stmt (gimple_body (root->context)),
2118 if (root->debug_var_chain)
2122 for (debug_var = root->debug_var_chain; debug_var;
2123 debug_var = TREE_CHAIN (debug_var))
2124 if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
2127 /* If there are any debug decls with variable length types,
2128 remap those types using other debug_var_chain variables. */
2131 struct nesting_copy_body_data id;
2133 memset (&id, 0, sizeof (id));
2134 id.cb.copy_decl = nesting_copy_decl;
2135 id.cb.decl_map = pointer_map_create ();
2138 for (; debug_var; debug_var = TREE_CHAIN (debug_var))
2139 if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
2141 tree type = TREE_TYPE (debug_var);
2142 tree newt, t = type;
2143 struct nesting_info *i;
2145 for (i = root; i; i = i->outer)
2146 if (variably_modified_type_p (type, i->context))
2152 id.cb.src_fn = i->context;
2153 id.cb.dst_fn = i->context;
2154 id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
2156 TREE_TYPE (debug_var) = newt = remap_type (type, &id.cb);
2157 while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
2159 newt = TREE_TYPE (newt);
2162 if (TYPE_NAME (newt)
2163 && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
2164 && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
2166 && TYPE_NAME (newt) == TYPE_NAME (t))
2167 TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
2170 pointer_map_destroy (id.cb.decl_map);
2173 declare_vars (root->debug_var_chain,
2174 gimple_seq_first_stmt (gimple_body (root->context)),
2178 /* Dump the translated tree function. */
2179 dump_function (TDI_nested, root->context);
2183 finalize_nesting_tree (struct nesting_info *root)
2188 finalize_nesting_tree (root->inner);
2189 finalize_nesting_tree_1 (root);
2195 /* Unnest the nodes and pass them to cgraph. */
2198 unnest_nesting_tree_1 (struct nesting_info *root)
2200 struct cgraph_node *node = cgraph_node (root->context);
2202 /* For nested functions update the cgraph to reflect unnesting.
2203 We also delay finalizing of these functions up to this point. */
2206 cgraph_unnest_node (cgraph_node (root->context));
2207 cgraph_finalize_function (root->context, true);
2212 unnest_nesting_tree (struct nesting_info *root)
2217 unnest_nesting_tree (root->inner);
2218 unnest_nesting_tree_1 (root);
2224 /* Free the data structures allocated during this pass. */
2227 free_nesting_tree (struct nesting_info *root)
2229 struct nesting_info *next;
2233 free_nesting_tree (root->inner);
2234 pointer_map_destroy (root->var_map);
2235 pointer_map_destroy (root->field_map);
2243 /* Main entry point for this pass. Process FNDECL and all of its nested
2244 subroutines and turn them into something less tightly bound. */
2247 lower_nested_functions (tree fndecl)
2249 struct cgraph_node *cgn;
2250 struct nesting_info *root;
2252 /* If there are no nested functions, there's nothing to do. */
2253 cgn = cgraph_node (fndecl);
2257 bitmap_obstack_initialize (&nesting_info_bitmap_obstack);
2258 root = create_nesting_tree (cgn);
2259 walk_all_functions (convert_nonlocal_reference_stmt,
2260 convert_nonlocal_reference_op,
2262 walk_all_functions (convert_local_reference_stmt,
2263 convert_local_reference_op,
2265 walk_all_functions (convert_nl_goto_reference, NULL, root);
2266 walk_all_functions (convert_nl_goto_receiver, NULL, root);
2267 convert_all_function_calls (root);
2268 finalize_nesting_tree (root);
2269 unnest_nesting_tree (root);
2270 free_nesting_tree (root);
2271 bitmap_obstack_release (&nesting_info_bitmap_obstack);
2274 #include "gt-tree-nested.h"