1 /* Nested function decomposition for trees.
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"
30 #include "tree-gimple.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 ? *slot : NULL;
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 /* Copy EXP into a temporary. Allocate the temporary in the context of
359 INFO and insert the initialization statement before TSI. */
362 init_tmp_var (struct nesting_info *info, tree exp, tree_stmt_iterator *tsi)
366 t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
367 stmt = build_gimple_modify_stmt (t, exp);
368 SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi)));
369 tsi_link_before (tsi, stmt, TSI_SAME_STMT);
374 /* Similarly, but only do so to force EXP to satisfy is_gimple_val. */
377 tsi_gimplify_val (struct nesting_info *info, tree exp, tree_stmt_iterator *tsi)
379 if (is_gimple_val (exp))
382 return init_tmp_var (info, exp, tsi);
385 /* Similarly, but copy from the temporary and insert the statement
386 after the iterator. */
389 save_tmp_var (struct nesting_info *info, tree exp,
390 tree_stmt_iterator *tsi)
394 t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
395 stmt = build_gimple_modify_stmt (exp, t);
396 SET_EXPR_LOCUS (stmt, EXPR_LOCUS (tsi_stmt (*tsi)));
397 tsi_link_after (tsi, stmt, TSI_SAME_STMT);
402 /* Build or return the type used to represent a nested function trampoline. */
404 static GTY(()) tree trampoline_type;
407 get_trampoline_type (void)
409 unsigned align, size;
413 return trampoline_type;
415 align = TRAMPOLINE_ALIGNMENT;
416 size = TRAMPOLINE_SIZE;
418 /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
419 then allocate extra space so that we can do dynamic alignment. */
420 if (align > STACK_BOUNDARY)
422 size += ((align/BITS_PER_UNIT) - 1) & -(STACK_BOUNDARY/BITS_PER_UNIT);
423 align = STACK_BOUNDARY;
426 t = build_index_type (build_int_cst (NULL_TREE, size - 1));
427 t = build_array_type (char_type_node, t);
428 t = build_decl (FIELD_DECL, get_identifier ("__data"), t);
429 DECL_ALIGN (t) = align;
430 DECL_USER_ALIGN (t) = 1;
432 trampoline_type = make_node (RECORD_TYPE);
433 TYPE_NAME (trampoline_type) = get_identifier ("__builtin_trampoline");
434 TYPE_FIELDS (trampoline_type) = t;
435 layout_type (trampoline_type);
436 DECL_CONTEXT (t) = trampoline_type;
438 return trampoline_type;
441 /* Given DECL, a nested function, find or create a field in the non-local
442 frame structure for a trampoline for this function. */
445 lookup_tramp_for_decl (struct nesting_info *info, tree decl,
446 enum insert_option insert)
450 if (insert == NO_INSERT)
452 slot = pointer_map_contains (info->var_map, decl);
453 return slot ? *slot : NULL;
456 slot = pointer_map_insert (info->var_map, decl);
459 tree field = make_node (FIELD_DECL);
460 DECL_NAME (field) = DECL_NAME (decl);
461 TREE_TYPE (field) = get_trampoline_type ();
462 TREE_ADDRESSABLE (field) = 1;
464 insert_field_into_struct (get_frame_type (info), field);
467 info->any_tramp_created = true;
473 /* Build or return the field within the non-local frame state that holds
474 the non-local goto "jmp_buf". The buffer itself is maintained by the
475 rtl middle-end as dynamic stack space is allocated. */
478 get_nl_goto_field (struct nesting_info *info)
480 tree field = info->nl_goto_field;
486 /* For __builtin_nonlocal_goto, we need N words. The first is the
487 frame pointer, the rest is for the target's stack pointer save
488 area. The number of words is controlled by STACK_SAVEAREA_MODE;
489 not the best interface, but it'll do for now. */
490 if (Pmode == ptr_mode)
491 type = ptr_type_node;
493 type = lang_hooks.types.type_for_mode (Pmode, 1);
495 size = GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL));
496 size = size / GET_MODE_SIZE (Pmode);
499 type = build_array_type
500 (type, build_index_type (build_int_cst (NULL_TREE, size)));
502 field = make_node (FIELD_DECL);
503 DECL_NAME (field) = get_identifier ("__nl_goto_buf");
504 TREE_TYPE (field) = type;
505 DECL_ALIGN (field) = TYPE_ALIGN (type);
506 TREE_ADDRESSABLE (field) = 1;
508 insert_field_into_struct (get_frame_type (info), field);
510 info->nl_goto_field = field;
516 /* Helper function for walk_stmts. Walk output operands of an ASM_EXPR. */
519 walk_asm_expr (struct walk_stmt_info *wi, tree stmt)
521 int noutputs = list_length (ASM_OUTPUTS (stmt));
522 const char **oconstraints
523 = (const char **) alloca ((noutputs) * sizeof (const char *));
526 const char *constraint;
527 bool allows_mem, allows_reg, is_inout;
530 for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
532 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
533 oconstraints[i] = constraint;
534 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
535 &allows_reg, &is_inout);
537 wi->val_only = (allows_reg || !allows_mem);
538 walk_tree (&TREE_VALUE (link), wi->callback, wi, NULL);
541 for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
543 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
544 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
545 oconstraints, &allows_mem, &allows_reg);
547 wi->val_only = (allows_reg || !allows_mem);
548 /* Although input "m" is not really a LHS, we need a lvalue. */
549 wi->is_lhs = !wi->val_only;
550 walk_tree (&TREE_VALUE (link), wi->callback, wi, NULL);
557 /* Iterate over all sub-statements of *TP calling walk_tree with
558 WI->CALLBACK for every sub-expression in each statement found. */
561 walk_stmts (struct walk_stmt_info *wi, tree *tp)
569 if (wi->want_locations && EXPR_HAS_LOCATION (t))
570 input_location = EXPR_LOCATION (t);
572 switch (TREE_CODE (t))
576 tree_stmt_iterator i;
577 for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i))
580 walk_stmts (wi, tsi_stmt_ptr (i));
586 walk_tree (&COND_EXPR_COND (t), wi->callback, wi, NULL);
587 walk_stmts (wi, &COND_EXPR_THEN (t));
588 walk_stmts (wi, &COND_EXPR_ELSE (t));
591 walk_stmts (wi, &CATCH_BODY (t));
594 walk_stmts (wi, &EH_FILTER_FAILURE (t));
597 case TRY_FINALLY_EXPR:
598 walk_stmts (wi, &TREE_OPERAND (t, 0));
599 walk_stmts (wi, &TREE_OPERAND (t, 1));
603 if (wi->want_bind_expr)
606 wi->callback (tp, &walk_subtrees, wi);
610 walk_stmts (wi, &BIND_EXPR_BODY (t));
614 if (wi->want_return_expr)
617 wi->callback (tp, &walk_subtrees, wi);
621 walk_stmts (wi, &TREE_OPERAND (t, 0));
624 case GIMPLE_MODIFY_STMT:
625 /* A formal temporary lhs may use a COMPONENT_REF rhs. */
626 wi->val_only = !is_gimple_formal_tmp_var (GIMPLE_STMT_OPERAND (t, 0));
627 walk_tree (&GIMPLE_STMT_OPERAND (t, 1), wi->callback, wi, NULL);
629 /* If the rhs is appropriate for a memory, we may use a
630 COMPONENT_REF on the lhs. */
631 wi->val_only = !is_gimple_mem_rhs (GIMPLE_STMT_OPERAND (t, 1));
633 walk_tree (&GIMPLE_STMT_OPERAND (t, 0), wi->callback, wi, NULL);
640 walk_asm_expr (wi, *tp);
645 walk_tree (tp, wi->callback, wi, NULL);
650 /* Invoke CALLBACK on all statements of *STMT_P. */
653 walk_body (walk_tree_fn callback, struct nesting_info *info, tree *stmt_p)
655 struct walk_stmt_info wi;
657 memset (&wi, 0, sizeof (wi));
658 wi.callback = callback;
662 walk_stmts (&wi, stmt_p);
665 /* Invoke CALLBACK on all statements of INFO->CONTEXT. */
668 walk_function (walk_tree_fn callback, struct nesting_info *info)
670 walk_body (callback, info, &DECL_SAVED_TREE (info->context));
673 /* Invoke CALLBACK on OMP_FOR init, cond, incr and pre-body. */
676 walk_omp_for (walk_tree_fn callback, struct nesting_info *info, tree for_stmt)
678 struct walk_stmt_info wi;
679 tree t, list = NULL, empty;
682 walk_body (callback, info, &OMP_FOR_PRE_BODY (for_stmt));
684 empty = build_empty_stmt ();
685 append_to_statement_list_force (empty, &list);
686 memset (&wi, 0, sizeof (wi));
687 wi.callback = callback;
689 wi.tsi = tsi_last (list);
691 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
693 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
694 gcc_assert (TREE_CODE (t) == GIMPLE_MODIFY_STMT);
695 SET_EXPR_LOCUS (empty, EXPR_LOCUS (t));
697 walk_tree (&GIMPLE_STMT_OPERAND (t, 0), callback, &wi, NULL);
700 walk_tree (&GIMPLE_STMT_OPERAND (t, 1), callback, &wi, NULL);
702 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
703 gcc_assert (COMPARISON_CLASS_P (t));
704 SET_EXPR_LOCUS (empty, EXPR_LOCUS (t));
706 walk_tree (&TREE_OPERAND (t, 0), callback, &wi, NULL);
709 walk_tree (&TREE_OPERAND (t, 1), callback, &wi, NULL);
711 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
712 gcc_assert (TREE_CODE (t) == GIMPLE_MODIFY_STMT);
713 SET_EXPR_LOCUS (empty, EXPR_LOCUS (t));
715 walk_tree (&GIMPLE_STMT_OPERAND (t, 0), callback, &wi, NULL);
716 t = GIMPLE_STMT_OPERAND (t, 1);
717 gcc_assert (BINARY_CLASS_P (t));
719 walk_tree (&TREE_OPERAND (t, 0), callback, &wi, NULL);
722 walk_tree (&TREE_OPERAND (t, 1), callback, &wi, NULL);
725 /* Remove empty statement added above from the end of statement list. */
726 tsi_delink (&wi.tsi);
727 append_to_statement_list (list, &OMP_FOR_PRE_BODY (for_stmt));
730 /* Similarly for ROOT and all functions nested underneath, depth first. */
733 walk_all_functions (walk_tree_fn callback, struct nesting_info *root)
738 walk_all_functions (callback, root->inner);
739 walk_function (callback, root);
745 /* We have to check for a fairly pathological case. The operands of function
746 nested function are to be interpreted in the context of the enclosing
747 function. So if any are variably-sized, they will get remapped when the
748 enclosing function is inlined. But that remapping would also have to be
749 done in the types of the PARM_DECLs of the nested function, meaning the
750 argument types of that function will disagree with the arguments in the
751 calls to that function. So we'd either have to make a copy of the nested
752 function corresponding to each time the enclosing function was inlined or
753 add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
754 function. The former is not practical. The latter would still require
755 detecting this case to know when to add the conversions. So, for now at
756 least, we don't inline such an enclosing function.
758 We have to do that check recursively, so here return indicating whether
759 FNDECL has such a nested function. ORIG_FN is the function we were
760 trying to inline to use for checking whether any argument is variably
761 modified by anything in it.
763 It would be better to do this in tree-inline.c so that we could give
764 the appropriate warning for why a function can't be inlined, but that's
765 too late since the nesting structure has already been flattened and
766 adding a flag just to record this fact seems a waste of a flag. */
769 check_for_nested_with_variably_modified (tree fndecl, tree orig_fndecl)
771 struct cgraph_node *cgn = cgraph_node (fndecl);
774 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
776 for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = TREE_CHAIN (arg))
777 if (variably_modified_type_p (TREE_TYPE (arg), orig_fndecl))
780 if (check_for_nested_with_variably_modified (cgn->decl, orig_fndecl))
787 /* Construct our local datastructure describing the function nesting
788 tree rooted by CGN. */
790 static struct nesting_info *
791 create_nesting_tree (struct cgraph_node *cgn)
793 struct nesting_info *info = XCNEW (struct nesting_info);
794 info->field_map = pointer_map_create ();
795 info->var_map = pointer_map_create ();
796 info->suppress_expansion = BITMAP_ALLOC (&nesting_info_bitmap_obstack);
797 info->context = cgn->decl;
799 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
801 struct nesting_info *sub = create_nesting_tree (cgn);
803 sub->next = info->inner;
807 /* See discussion at check_for_nested_with_variably_modified for a
808 discussion of why this has to be here. */
809 if (check_for_nested_with_variably_modified (info->context, info->context))
810 DECL_UNINLINABLE (info->context) = true;
815 /* Return an expression computing the static chain for TARGET_CONTEXT
816 from INFO->CONTEXT. Insert any necessary computations before TSI. */
819 get_static_chain (struct nesting_info *info, tree target_context,
820 tree_stmt_iterator *tsi)
822 struct nesting_info *i;
825 if (info->context == target_context)
827 x = build_addr (info->frame_decl, target_context);
831 x = get_chain_decl (info);
833 for (i = info->outer; i->context != target_context; i = i->outer)
835 tree field = get_chain_field (i);
837 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
838 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
839 x = init_tmp_var (info, x, tsi);
846 /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
847 frame as seen from INFO->CONTEXT. Insert any necessary computations
851 get_frame_field (struct nesting_info *info, tree target_context,
852 tree field, tree_stmt_iterator *tsi)
854 struct nesting_info *i;
857 if (info->context == target_context)
859 /* Make sure frame_decl gets created. */
860 (void) get_frame_type (info);
861 x = info->frame_decl;
865 x = get_chain_decl (info);
867 for (i = info->outer; i->context != target_context; i = i->outer)
869 tree field = get_chain_field (i);
871 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
872 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
873 x = init_tmp_var (info, x, tsi);
876 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
879 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
883 /* A subroutine of convert_nonlocal_reference. Create a local variable
884 in the nested function with DECL_VALUE_EXPR set to reference the true
885 variable in the parent function. This is used both for debug info
886 and in OpenMP lowering. */
889 get_nonlocal_debug_decl (struct nesting_info *info, tree decl)
892 struct nesting_info *i;
893 tree x, field, new_decl;
896 slot = pointer_map_insert (info->var_map, decl);
901 target_context = decl_function_context (decl);
903 /* A copy of the code in get_frame_field, but without the temporaries. */
904 if (info->context == target_context)
906 /* Make sure frame_decl gets created. */
907 (void) get_frame_type (info);
908 x = info->frame_decl;
913 x = get_chain_decl (info);
914 for (i = info->outer; i->context != target_context; i = i->outer)
916 field = get_chain_field (i);
917 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
918 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
920 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
923 field = lookup_field_for_decl (i, decl, INSERT);
924 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
925 if (use_pointer_in_frame (decl))
926 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
928 /* ??? We should be remapping types as well, surely. */
929 new_decl = build_decl (VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
930 DECL_CONTEXT (new_decl) = info->context;
931 DECL_SOURCE_LOCATION (new_decl) = DECL_SOURCE_LOCATION (decl);
932 DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
933 DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
934 TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
935 TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
936 TREE_READONLY (new_decl) = TREE_READONLY (decl);
937 TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
938 DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
940 SET_DECL_VALUE_EXPR (new_decl, x);
941 DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
944 TREE_CHAIN (new_decl) = info->debug_var_chain;
945 info->debug_var_chain = new_decl;
950 /* Called via walk_function+walk_tree, rewrite all references to VAR
951 and PARM_DECLs that belong to outer functions.
953 The rewrite will involve some number of structure accesses back up
954 the static chain. E.g. for a variable FOO up one nesting level it'll
955 be CHAIN->FOO. For two levels it'll be CHAIN->__chain->FOO. Further
956 indirections apply to decls for which use_pointer_in_frame is true. */
958 static bool convert_nonlocal_omp_clauses (tree *, struct walk_stmt_info *);
961 convert_nonlocal_reference (tree *tp, int *walk_subtrees, void *data)
963 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
964 struct nesting_info *info = wi->info;
966 tree save_local_var_chain;
967 bitmap save_suppress;
970 switch (TREE_CODE (t))
973 /* Non-automatic variables are never processed. */
974 if (TREE_STATIC (t) || DECL_EXTERNAL (t))
979 if (decl_function_context (t) != info->context)
984 x = get_nonlocal_debug_decl (info, t);
985 if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
987 tree target_context = decl_function_context (t);
988 struct nesting_info *i;
989 for (i = info->outer; i->context != target_context; i = i->outer)
991 x = lookup_field_for_decl (i, t, INSERT);
992 x = get_frame_field (info, target_context, x, &wi->tsi);
993 if (use_pointer_in_frame (t))
995 x = init_tmp_var (info, x, &wi->tsi);
996 x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
1003 x = save_tmp_var (info, x, &wi->tsi);
1005 x = init_tmp_var (info, x, &wi->tsi);
1013 /* Don't walk non-local gotos for now. */
1014 if (TREE_CODE (GOTO_DESTINATION (t)) != LABEL_DECL)
1017 wi->val_only = true;
1023 /* We're taking the address of a label from a parent function, but
1024 this is not itself a non-local goto. Mark the label such that it
1025 will not be deleted, much as we would with a label address in
1027 if (decl_function_context (t) != info->context)
1028 FORCED_LABEL (t) = 1;
1033 bool save_val_only = wi->val_only;
1035 wi->val_only = false;
1037 wi->changed = false;
1038 walk_tree (&TREE_OPERAND (t, 0), convert_nonlocal_reference, wi, NULL);
1039 wi->val_only = true;
1045 /* If we changed anything, we might no longer be directly
1046 referencing a decl. */
1047 save_context = current_function_decl;
1048 current_function_decl = info->context;
1049 recompute_tree_invariant_for_addr_expr (t);
1050 current_function_decl = save_context;
1052 /* If the callback converted the address argument in a context
1053 where we only accept variables (and min_invariant, presumably),
1054 then compute the address into a temporary. */
1056 *tp = tsi_gimplify_val (wi->info, t, &wi->tsi);
1065 case ARRAY_RANGE_REF:
1067 /* Go down this entire nest and just look at the final prefix and
1068 anything that describes the references. Otherwise, we lose track
1069 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1070 wi->val_only = true;
1072 for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1074 if (TREE_CODE (t) == COMPONENT_REF)
1075 walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
1077 else if (TREE_CODE (t) == ARRAY_REF
1078 || TREE_CODE (t) == ARRAY_RANGE_REF)
1080 walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference, wi,
1082 walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
1084 walk_tree (&TREE_OPERAND (t, 3), convert_nonlocal_reference, wi,
1087 else if (TREE_CODE (t) == BIT_FIELD_REF)
1089 walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference, wi,
1091 walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference, wi,
1095 wi->val_only = false;
1096 walk_tree (tp, convert_nonlocal_reference, wi, NULL);
1099 case VIEW_CONVERT_EXPR:
1100 /* Just request to look at the subtrees, leaving val_only and lhs
1101 untouched. This might actually be for !val_only + lhs, in which
1102 case we don't want to force a replacement by a temporary. */
1108 save_suppress = info->suppress_expansion;
1109 if (convert_nonlocal_omp_clauses (&OMP_TASKREG_CLAUSES (t), wi))
1112 decl = get_chain_decl (info);
1113 c = build_omp_clause (OMP_CLAUSE_FIRSTPRIVATE);
1114 OMP_CLAUSE_DECL (c) = decl;
1115 OMP_CLAUSE_CHAIN (c) = OMP_TASKREG_CLAUSES (t);
1116 OMP_TASKREG_CLAUSES (t) = c;
1119 save_local_var_chain = info->new_local_var_chain;
1120 info->new_local_var_chain = NULL;
1122 walk_body (convert_nonlocal_reference, info, &OMP_TASKREG_BODY (t));
1124 if (info->new_local_var_chain)
1125 declare_vars (info->new_local_var_chain, OMP_TASKREG_BODY (t), false);
1126 info->new_local_var_chain = save_local_var_chain;
1127 info->suppress_expansion = save_suppress;
1131 save_suppress = info->suppress_expansion;
1132 convert_nonlocal_omp_clauses (&OMP_FOR_CLAUSES (t), wi);
1133 walk_omp_for (convert_nonlocal_reference, info, t);
1134 walk_body (convert_nonlocal_reference, info, &OMP_FOR_BODY (t));
1135 info->suppress_expansion = save_suppress;
1140 save_suppress = info->suppress_expansion;
1141 convert_nonlocal_omp_clauses (&OMP_CLAUSES (t), wi);
1142 walk_body (convert_nonlocal_reference, info, &OMP_BODY (t));
1143 info->suppress_expansion = save_suppress;
1149 walk_body (convert_nonlocal_reference, info, &OMP_BODY (t));
1153 if (!IS_TYPE_OR_DECL_P (t))
1156 wi->val_only = true;
1166 convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1168 struct nesting_info *info = wi->info;
1169 bool need_chain = false, need_stmts = false;
1172 bitmap new_suppress;
1174 new_suppress = BITMAP_GGC_ALLOC ();
1175 bitmap_copy (new_suppress, info->suppress_expansion);
1177 for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1179 switch (OMP_CLAUSE_CODE (clause))
1181 case OMP_CLAUSE_REDUCTION:
1182 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1184 goto do_decl_clause;
1186 case OMP_CLAUSE_LASTPRIVATE:
1187 if (OMP_CLAUSE_LASTPRIVATE_STMT (clause))
1189 goto do_decl_clause;
1191 case OMP_CLAUSE_PRIVATE:
1192 case OMP_CLAUSE_FIRSTPRIVATE:
1193 case OMP_CLAUSE_COPYPRIVATE:
1194 case OMP_CLAUSE_SHARED:
1196 decl = OMP_CLAUSE_DECL (clause);
1197 if (TREE_CODE (decl) == VAR_DECL
1198 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1200 if (decl_function_context (decl) != info->context)
1202 bitmap_set_bit (new_suppress, DECL_UID (decl));
1203 OMP_CLAUSE_DECL (clause) = get_nonlocal_debug_decl (info, decl);
1208 case OMP_CLAUSE_SCHEDULE:
1209 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1213 case OMP_CLAUSE_NUM_THREADS:
1214 wi->val_only = true;
1216 convert_nonlocal_reference (&OMP_CLAUSE_OPERAND (clause, 0), &dummy,
1220 case OMP_CLAUSE_NOWAIT:
1221 case OMP_CLAUSE_ORDERED:
1222 case OMP_CLAUSE_DEFAULT:
1223 case OMP_CLAUSE_COPYIN:
1224 case OMP_CLAUSE_COLLAPSE:
1225 case OMP_CLAUSE_UNTIED:
1233 info->suppress_expansion = new_suppress;
1236 for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1237 switch (OMP_CLAUSE_CODE (clause))
1239 case OMP_CLAUSE_REDUCTION:
1240 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1243 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1244 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1246 walk_body (convert_nonlocal_reference, info,
1247 &OMP_CLAUSE_REDUCTION_INIT (clause));
1248 walk_body (convert_nonlocal_reference, info,
1249 &OMP_CLAUSE_REDUCTION_MERGE (clause));
1250 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1255 case OMP_CLAUSE_LASTPRIVATE:
1256 walk_body (convert_nonlocal_reference, info,
1257 &OMP_CLAUSE_LASTPRIVATE_STMT (clause));
1267 /* A subroutine of convert_local_reference. Create a local variable
1268 in the parent function with DECL_VALUE_EXPR set to reference the
1269 field in FRAME. This is used both for debug info and in OpenMP
1273 get_local_debug_decl (struct nesting_info *info, tree decl, tree field)
1278 slot = pointer_map_insert (info->var_map, decl);
1282 /* Make sure frame_decl gets created. */
1283 (void) get_frame_type (info);
1284 x = info->frame_decl;
1285 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1287 new_decl = build_decl (VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
1288 DECL_CONTEXT (new_decl) = info->context;
1289 DECL_SOURCE_LOCATION (new_decl) = DECL_SOURCE_LOCATION (decl);
1290 DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
1291 DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
1292 TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
1293 TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
1294 TREE_READONLY (new_decl) = TREE_READONLY (decl);
1295 TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
1296 DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
1298 SET_DECL_VALUE_EXPR (new_decl, x);
1299 DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
1302 TREE_CHAIN (new_decl) = info->debug_var_chain;
1303 info->debug_var_chain = new_decl;
1305 /* Do not emit debug info twice. */
1306 DECL_IGNORED_P (decl) = 1;
1311 /* Called via walk_function+walk_tree, rewrite all references to VAR
1312 and PARM_DECLs that were referenced by inner nested functions.
1313 The rewrite will be a structure reference to the local frame variable. */
1315 static bool convert_local_omp_clauses (tree *, struct walk_stmt_info *);
1318 convert_local_reference (tree *tp, int *walk_subtrees, void *data)
1320 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1321 struct nesting_info *info = wi->info;
1322 tree t = *tp, field, x;
1324 tree save_local_var_chain;
1325 bitmap save_suppress;
1328 switch (TREE_CODE (t))
1331 /* Non-automatic variables are never processed. */
1332 if (TREE_STATIC (t) || DECL_EXTERNAL (t))
1337 if (decl_function_context (t) == info->context)
1339 /* If we copied a pointer to the frame, then the original decl
1340 is used unchanged in the parent function. */
1341 if (use_pointer_in_frame (t))
1344 /* No need to transform anything if no child references the
1346 field = lookup_field_for_decl (info, t, NO_INSERT);
1351 x = get_local_debug_decl (info, t, field);
1352 if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
1353 x = get_frame_field (info, info->context, field, &wi->tsi);
1358 x = save_tmp_var (info, x, &wi->tsi);
1360 x = init_tmp_var (info, x, &wi->tsi);
1368 save_val_only = wi->val_only;
1369 wi->val_only = false;
1371 wi->changed = false;
1372 walk_tree (&TREE_OPERAND (t, 0), convert_local_reference, wi, NULL);
1373 wi->val_only = save_val_only;
1375 /* If we converted anything ... */
1380 /* Then the frame decl is now addressable. */
1381 TREE_ADDRESSABLE (info->frame_decl) = 1;
1383 save_context = current_function_decl;
1384 current_function_decl = info->context;
1385 recompute_tree_invariant_for_addr_expr (t);
1386 current_function_decl = save_context;
1388 /* If we are in a context where we only accept values, then
1389 compute the address into a temporary. */
1391 *tp = tsi_gimplify_val (wi->info, t, &wi->tsi);
1399 case ARRAY_RANGE_REF:
1401 /* Go down this entire nest and just look at the final prefix and
1402 anything that describes the references. Otherwise, we lose track
1403 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1404 save_val_only = wi->val_only;
1405 wi->val_only = true;
1407 for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1409 if (TREE_CODE (t) == COMPONENT_REF)
1410 walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
1412 else if (TREE_CODE (t) == ARRAY_REF
1413 || TREE_CODE (t) == ARRAY_RANGE_REF)
1415 walk_tree (&TREE_OPERAND (t, 1), convert_local_reference, wi,
1417 walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
1419 walk_tree (&TREE_OPERAND (t, 3), convert_local_reference, wi,
1422 else if (TREE_CODE (t) == BIT_FIELD_REF)
1424 walk_tree (&TREE_OPERAND (t, 1), convert_local_reference, wi,
1426 walk_tree (&TREE_OPERAND (t, 2), convert_local_reference, wi,
1430 wi->val_only = false;
1431 walk_tree (tp, convert_local_reference, wi, NULL);
1432 wi->val_only = save_val_only;
1435 case VIEW_CONVERT_EXPR:
1436 /* Just request to look at the subtrees, leaving val_only and lhs
1437 untouched. This might actually be for !val_only + lhs, in which
1438 case we don't want to force a replacement by a temporary. */
1444 save_suppress = info->suppress_expansion;
1445 if (convert_local_omp_clauses (&OMP_TASKREG_CLAUSES (t), wi))
1448 (void) get_frame_type (info);
1449 c = build_omp_clause (OMP_CLAUSE_SHARED);
1450 OMP_CLAUSE_DECL (c) = info->frame_decl;
1451 OMP_CLAUSE_CHAIN (c) = OMP_TASKREG_CLAUSES (t);
1452 OMP_TASKREG_CLAUSES (t) = c;
1455 save_local_var_chain = info->new_local_var_chain;
1456 info->new_local_var_chain = NULL;
1458 walk_body (convert_local_reference, info, &OMP_TASKREG_BODY (t));
1460 if (info->new_local_var_chain)
1461 declare_vars (info->new_local_var_chain, OMP_TASKREG_BODY (t), false);
1462 info->new_local_var_chain = save_local_var_chain;
1463 info->suppress_expansion = save_suppress;
1467 save_suppress = info->suppress_expansion;
1468 convert_local_omp_clauses (&OMP_FOR_CLAUSES (t), wi);
1469 walk_omp_for (convert_local_reference, info, t);
1470 walk_body (convert_local_reference, info, &OMP_FOR_BODY (t));
1471 info->suppress_expansion = save_suppress;
1476 save_suppress = info->suppress_expansion;
1477 convert_local_omp_clauses (&OMP_CLAUSES (t), wi);
1478 walk_body (convert_local_reference, info, &OMP_BODY (t));
1479 info->suppress_expansion = save_suppress;
1485 walk_body (convert_local_reference, info, &OMP_BODY (t));
1489 if (!IS_TYPE_OR_DECL_P (t))
1492 wi->val_only = true;
1502 convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1504 struct nesting_info *info = wi->info;
1505 bool need_frame = false, need_stmts = false;
1508 bitmap new_suppress;
1510 new_suppress = BITMAP_GGC_ALLOC ();
1511 bitmap_copy (new_suppress, info->suppress_expansion);
1513 for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1515 switch (OMP_CLAUSE_CODE (clause))
1517 case OMP_CLAUSE_REDUCTION:
1518 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1520 goto do_decl_clause;
1522 case OMP_CLAUSE_LASTPRIVATE:
1523 if (OMP_CLAUSE_LASTPRIVATE_STMT (clause))
1525 goto do_decl_clause;
1527 case OMP_CLAUSE_PRIVATE:
1528 case OMP_CLAUSE_FIRSTPRIVATE:
1529 case OMP_CLAUSE_COPYPRIVATE:
1530 case OMP_CLAUSE_SHARED:
1532 decl = OMP_CLAUSE_DECL (clause);
1533 if (TREE_CODE (decl) == VAR_DECL
1534 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1536 if (decl_function_context (decl) == info->context
1537 && !use_pointer_in_frame (decl))
1539 tree field = lookup_field_for_decl (info, decl, NO_INSERT);
1542 bitmap_set_bit (new_suppress, DECL_UID (decl));
1543 OMP_CLAUSE_DECL (clause)
1544 = get_local_debug_decl (info, decl, field);
1550 case OMP_CLAUSE_SCHEDULE:
1551 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1555 case OMP_CLAUSE_NUM_THREADS:
1556 wi->val_only = true;
1558 convert_local_reference (&OMP_CLAUSE_OPERAND (clause, 0), &dummy, wi);
1561 case OMP_CLAUSE_NOWAIT:
1562 case OMP_CLAUSE_ORDERED:
1563 case OMP_CLAUSE_DEFAULT:
1564 case OMP_CLAUSE_COPYIN:
1565 case OMP_CLAUSE_COLLAPSE:
1566 case OMP_CLAUSE_UNTIED:
1574 info->suppress_expansion = new_suppress;
1577 for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1578 switch (OMP_CLAUSE_CODE (clause))
1580 case OMP_CLAUSE_REDUCTION:
1581 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1584 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1585 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1587 walk_body (convert_local_reference, info,
1588 &OMP_CLAUSE_REDUCTION_INIT (clause));
1589 walk_body (convert_local_reference, info,
1590 &OMP_CLAUSE_REDUCTION_MERGE (clause));
1591 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1596 case OMP_CLAUSE_LASTPRIVATE:
1597 walk_body (convert_local_reference, info,
1598 &OMP_CLAUSE_LASTPRIVATE_STMT (clause));
1608 /* Called via walk_function+walk_tree, rewrite all GOTO_EXPRs that
1609 reference labels from outer functions. The rewrite will be a
1610 call to __builtin_nonlocal_goto. */
1613 convert_nl_goto_reference (tree *tp, int *walk_subtrees, void *data)
1615 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1616 struct nesting_info *info = wi->info, *i;
1617 tree t = *tp, label, new_label, target_context, x, field;
1621 if (TREE_CODE (t) != GOTO_EXPR)
1623 label = GOTO_DESTINATION (t);
1624 if (TREE_CODE (label) != LABEL_DECL)
1626 target_context = decl_function_context (label);
1627 if (target_context == info->context)
1630 for (i = info->outer; target_context != i->context; i = i->outer)
1633 /* The original user label may also be use for a normal goto, therefore
1634 we must create a new label that will actually receive the abnormal
1635 control transfer. This new label will be marked LABEL_NONLOCAL; this
1636 mark will trigger proper behavior in the cfg, as well as cause the
1637 (hairy target-specific) non-local goto receiver code to be generated
1638 when we expand rtl. Enter this association into var_map so that we
1639 can insert the new label into the IL during a second pass. */
1640 slot = pointer_map_insert (i->var_map, label);
1643 new_label = create_artificial_label ();
1644 DECL_NONLOCAL (new_label) = 1;
1650 /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field). */
1651 field = get_nl_goto_field (i);
1652 x = get_frame_field (info, target_context, field, &wi->tsi);
1653 x = build_addr (x, target_context);
1654 x = tsi_gimplify_val (info, x, &wi->tsi);
1655 x = build_call_expr (implicit_built_in_decls[BUILT_IN_NONLOCAL_GOTO], 2,
1656 build_addr (new_label, target_context), x);
1658 SET_EXPR_LOCUS (x, EXPR_LOCUS (tsi_stmt (wi->tsi)));
1659 *tsi_stmt_ptr (wi->tsi) = x;
1664 /* Called via walk_function+walk_tree, rewrite all LABEL_EXPRs that
1665 are referenced via nonlocal goto from a nested function. The rewrite
1666 will involve installing a newly generated DECL_NONLOCAL label, and
1667 (potentially) a branch around the rtl gunk that is assumed to be
1668 attached to such a label. */
1671 convert_nl_goto_receiver (tree *tp, int *walk_subtrees, void *data)
1673 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1674 struct nesting_info *info = wi->info;
1675 tree t = *tp, label, new_label, x;
1676 tree_stmt_iterator tmp_tsi;
1680 if (TREE_CODE (t) != LABEL_EXPR)
1682 label = LABEL_EXPR_LABEL (t);
1684 slot = pointer_map_contains (info->var_map, label);
1688 /* If there's any possibility that the previous statement falls through,
1689 then we must branch around the new non-local label. */
1691 tsi_prev (&tmp_tsi);
1692 if (tsi_end_p (tmp_tsi) || block_may_fallthru (tsi_stmt (tmp_tsi)))
1694 x = build1 (GOTO_EXPR, void_type_node, label);
1695 tsi_link_before (&wi->tsi, x, TSI_SAME_STMT);
1698 new_label = (tree) *slot;
1699 x = build1 (LABEL_EXPR, void_type_node, new_label);
1700 tsi_link_before (&wi->tsi, x, TSI_SAME_STMT);
1705 /* Called via walk_function+walk_tree, rewrite all references to addresses
1706 of nested functions that require the use of trampolines. The rewrite
1707 will involve a reference a trampoline generated for the occasion. */
1710 convert_tramp_reference (tree *tp, int *walk_subtrees, void *data)
1712 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1713 struct nesting_info *info = wi->info, *i;
1714 tree t = *tp, decl, target_context, x;
1717 switch (TREE_CODE (t))
1721 T.1 = &CHAIN->tramp;
1722 T.2 = __builtin_adjust_trampoline (T.1);
1723 T.3 = (func_type)T.2;
1726 decl = TREE_OPERAND (t, 0);
1727 if (TREE_CODE (decl) != FUNCTION_DECL)
1730 /* Only need to process nested functions. */
1731 target_context = decl_function_context (decl);
1732 if (!target_context)
1735 /* If the nested function doesn't use a static chain, then
1736 it doesn't need a trampoline. */
1737 if (DECL_NO_STATIC_CHAIN (decl))
1740 /* If we don't want a trampoline, then don't build one. */
1741 if (TREE_NO_TRAMPOLINE (t))
1744 /* Lookup the immediate parent of the callee, as that's where
1745 we need to insert the trampoline. */
1746 for (i = info; i->context != target_context; i = i->outer)
1748 x = lookup_tramp_for_decl (i, decl, INSERT);
1750 /* Compute the address of the field holding the trampoline. */
1751 x = get_frame_field (info, target_context, x, &wi->tsi);
1752 x = build_addr (x, target_context);
1753 x = tsi_gimplify_val (info, x, &wi->tsi);
1755 /* Do machine-specific ugliness. Normally this will involve
1756 computing extra alignment, but it can really be anything. */
1757 x = build_call_expr (implicit_built_in_decls[BUILT_IN_ADJUST_TRAMPOLINE],
1759 x = init_tmp_var (info, x, &wi->tsi);
1761 /* Cast back to the proper function type. */
1762 x = build1 (NOP_EXPR, TREE_TYPE (t), x);
1763 x = init_tmp_var (info, x, &wi->tsi);
1769 /* Only walk call arguments, lest we generate trampolines for
1772 int nargs = call_expr_nargs (t);
1774 for (i = 0; i < nargs; i++)
1775 walk_tree (&CALL_EXPR_ARG (t, i), convert_tramp_reference, wi, NULL);
1780 if (!IS_TYPE_OR_DECL_P (t))
1788 /* Called via walk_function+walk_tree, rewrite all CALL_EXPRs that
1789 reference nested functions to make sure that the static chain is
1790 set up properly for the call. */
1793 convert_call_expr (tree *tp, int *walk_subtrees, void *data)
1795 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1796 struct nesting_info *info = wi->info;
1797 tree t = *tp, decl, target_context;
1798 char save_static_chain_added;
1802 switch (TREE_CODE (t))
1805 decl = get_callee_fndecl (t);
1808 target_context = decl_function_context (decl);
1809 if (target_context && !DECL_NO_STATIC_CHAIN (decl))
1811 CALL_EXPR_STATIC_CHAIN (t)
1812 = get_static_chain (info, target_context, &wi->tsi);
1813 info->static_chain_added
1814 |= (1 << (info->context != target_context));
1819 case GIMPLE_MODIFY_STMT:
1820 case WITH_SIZE_EXPR:
1821 /* Only return modify and with_size_expr may contain calls. */
1827 save_static_chain_added = info->static_chain_added;
1828 info->static_chain_added = 0;
1829 walk_body (convert_call_expr, info, &OMP_TASKREG_BODY (t));
1830 for (i = 0; i < 2; i++)
1833 if ((info->static_chain_added & (1 << i)) == 0)
1835 decl = i ? get_chain_decl (info) : info->frame_decl;
1836 /* Don't add CHAIN.* or FRAME.* twice. */
1837 for (c = OMP_TASKREG_CLAUSES (t); c; c = OMP_CLAUSE_CHAIN (c))
1838 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
1839 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
1840 && OMP_CLAUSE_DECL (c) == decl)
1844 c = build_omp_clause (i ? OMP_CLAUSE_FIRSTPRIVATE
1845 : OMP_CLAUSE_SHARED);
1846 OMP_CLAUSE_DECL (c) = decl;
1847 OMP_CLAUSE_CHAIN (c) = OMP_TASKREG_CLAUSES (t);
1848 OMP_TASKREG_CLAUSES (t) = c;
1851 info->static_chain_added |= save_static_chain_added;
1855 walk_body (convert_call_expr, info, &OMP_FOR_PRE_BODY (t));
1863 walk_body (convert_call_expr, info, &OMP_BODY (t));
1873 /* Walk the nesting tree starting with ROOT, depth first. Convert all
1874 trampolines and call expressions. On the way back up, determine if
1875 a nested function actually uses its static chain; if not, remember that. */
1878 convert_all_function_calls (struct nesting_info *root)
1883 convert_all_function_calls (root->inner);
1885 walk_function (convert_tramp_reference, root);
1886 walk_function (convert_call_expr, root);
1888 /* If the function does not use a static chain, then remember that. */
1889 if (root->outer && !root->chain_decl && !root->chain_field)
1890 DECL_NO_STATIC_CHAIN (root->context) = 1;
1892 gcc_assert (!DECL_NO_STATIC_CHAIN (root->context));
1899 /* Do "everything else" to clean up or complete state collected by the
1900 various walking passes -- lay out the types and decls, generate code
1901 to initialize the frame decl, store critical expressions in the
1902 struct function for rtl to find. */
1905 finalize_nesting_tree_1 (struct nesting_info *root)
1907 tree stmt_list = NULL;
1908 tree context = root->context;
1909 struct function *sf;
1911 /* If we created a non-local frame type or decl, we need to lay them
1912 out at this time. */
1913 if (root->frame_type)
1915 /* In some cases the frame type will trigger the -Wpadded warning.
1916 This is not helpful; suppress it. */
1917 int save_warn_padded = warn_padded;
1919 layout_type (root->frame_type);
1920 warn_padded = save_warn_padded;
1921 layout_decl (root->frame_decl, 0);
1924 /* If any parameters were referenced non-locally, then we need to
1925 insert a copy. Likewise, if any variables were referenced by
1926 pointer, we need to initialize the address. */
1927 if (root->any_parm_remapped)
1930 for (p = DECL_ARGUMENTS (context); p ; p = TREE_CHAIN (p))
1934 field = lookup_field_for_decl (root, p, NO_INSERT);
1938 if (use_pointer_in_frame (p))
1939 x = build_addr (p, context);
1943 y = build3 (COMPONENT_REF, TREE_TYPE (field),
1944 root->frame_decl, field, NULL_TREE);
1945 x = build_gimple_modify_stmt (y, x);
1946 append_to_statement_list (x, &stmt_list);
1950 /* If a chain_field was created, then it needs to be initialized
1952 if (root->chain_field)
1954 tree x = build3 (COMPONENT_REF, TREE_TYPE (root->chain_field),
1955 root->frame_decl, root->chain_field, NULL_TREE);
1956 x = build_gimple_modify_stmt (x, get_chain_decl (root));
1957 append_to_statement_list (x, &stmt_list);
1960 /* If trampolines were created, then we need to initialize them. */
1961 if (root->any_tramp_created)
1963 struct nesting_info *i;
1964 for (i = root->inner; i ; i = i->next)
1966 tree arg1, arg2, arg3, x, field;
1968 field = lookup_tramp_for_decl (root, i->context, NO_INSERT);
1972 if (DECL_NO_STATIC_CHAIN (i->context))
1973 arg3 = null_pointer_node;
1975 arg3 = build_addr (root->frame_decl, context);
1977 arg2 = build_addr (i->context, context);
1979 x = build3 (COMPONENT_REF, TREE_TYPE (field),
1980 root->frame_decl, field, NULL_TREE);
1981 arg1 = build_addr (x, context);
1983 x = implicit_built_in_decls[BUILT_IN_INIT_TRAMPOLINE];
1984 x = build_call_expr (x, 3, arg1, arg2, arg3);
1985 append_to_statement_list (x, &stmt_list);
1989 /* If we created initialization statements, insert them. */
1992 annotate_all_with_locus (&stmt_list,
1993 DECL_SOURCE_LOCATION (context));
1994 append_to_statement_list (BIND_EXPR_BODY (DECL_SAVED_TREE (context)),
1996 BIND_EXPR_BODY (DECL_SAVED_TREE (context)) = stmt_list;
1999 /* If a chain_decl was created, then it needs to be registered with
2000 struct function so that it gets initialized from the static chain
2001 register at the beginning of the function. */
2002 sf = DECL_STRUCT_FUNCTION (root->context);
2003 sf->static_chain_decl = root->chain_decl;
2005 /* Similarly for the non-local goto save area. */
2006 if (root->nl_goto_field)
2008 sf->nonlocal_goto_save_area
2009 = get_frame_field (root, context, root->nl_goto_field, NULL);
2010 sf->has_nonlocal_label = 1;
2013 /* Make sure all new local variables get inserted into the
2014 proper BIND_EXPR. */
2015 if (root->new_local_var_chain)
2016 declare_vars (root->new_local_var_chain, DECL_SAVED_TREE (root->context),
2018 if (root->debug_var_chain)
2019 declare_vars (root->debug_var_chain, DECL_SAVED_TREE (root->context),
2022 /* Dump the translated tree function. */
2023 dump_function (TDI_nested, root->context);
2027 finalize_nesting_tree (struct nesting_info *root)
2032 finalize_nesting_tree (root->inner);
2033 finalize_nesting_tree_1 (root);
2039 /* Unnest the nodes and pass them to cgraph. */
2042 unnest_nesting_tree_1 (struct nesting_info *root)
2044 struct cgraph_node *node = cgraph_node (root->context);
2046 /* For nested functions update the cgraph to reflect unnesting.
2047 We also delay finalizing of these functions up to this point. */
2050 cgraph_unnest_node (cgraph_node (root->context));
2051 cgraph_finalize_function (root->context, true);
2056 unnest_nesting_tree (struct nesting_info *root)
2061 unnest_nesting_tree (root->inner);
2062 unnest_nesting_tree_1 (root);
2068 /* Free the data structures allocated during this pass. */
2071 free_nesting_tree (struct nesting_info *root)
2073 struct nesting_info *next;
2077 free_nesting_tree (root->inner);
2078 pointer_map_destroy (root->var_map);
2079 pointer_map_destroy (root->field_map);
2087 /* Main entry point for this pass. Process FNDECL and all of its nested
2088 subroutines and turn them into something less tightly bound. */
2091 lower_nested_functions (tree fndecl)
2093 struct cgraph_node *cgn;
2094 struct nesting_info *root;
2096 /* If there are no nested functions, there's nothing to do. */
2097 cgn = cgraph_node (fndecl);
2101 bitmap_obstack_initialize (&nesting_info_bitmap_obstack);
2102 root = create_nesting_tree (cgn);
2103 walk_all_functions (convert_nonlocal_reference, root);
2104 walk_all_functions (convert_local_reference, root);
2105 walk_all_functions (convert_nl_goto_reference, root);
2106 walk_all_functions (convert_nl_goto_receiver, root);
2107 convert_all_function_calls (root);
2108 finalize_nesting_tree (root);
2109 unnest_nesting_tree (root);
2110 free_nesting_tree (root);
2111 bitmap_obstack_release (&nesting_info_bitmap_obstack);
2114 #include "gt-tree-nested.h"