1 /* Nested function decomposition for GIMPLE.
2 Copyright (C) 2004-2019 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"
30 #include "stringpool.h"
32 #include "fold-const.h"
33 #include "stor-layout.h"
35 #include "tree-inline.h"
37 #include "gimple-iterator.h"
38 #include "gimple-walk.h"
41 #include "langhooks.h"
42 #include "gimple-low.h"
43 #include "gomp-constants.h"
44 #include "diagnostic.h"
47 /* The object of this pass is to lower the representation of a set of nested
48 functions in order to expose all of the gory details of the various
49 nonlocal references. We want to do this sooner rather than later, in
50 order to give us more freedom in emitting all of the functions in question.
52 Back in olden times, when gcc was young, we developed an insanely
53 complicated scheme whereby variables which were referenced nonlocally
54 were forced to live in the stack of the declaring function, and then
55 the nested functions magically discovered where these variables were
56 placed. In order for this scheme to function properly, it required
57 that the outer function be partially expanded, then we switch to
58 compiling the inner function, and once done with those we switch back
59 to compiling the outer function. Such delicate ordering requirements
60 makes it difficult to do whole translation unit optimizations
61 involving such functions.
63 The implementation here is much more direct. Everything that can be
64 referenced by an inner function is a member of an explicitly created
65 structure herein called the "nonlocal frame struct". The incoming
66 static chain for a nested function is a pointer to this struct in
67 the parent. In this way, we settle on known offsets from a known
68 base, and so are decoupled from the logic that places objects in the
69 function's stack frame. More importantly, we don't have to wait for
70 that to happen -- since the compilation of the inner function is no
71 longer tied to a real stack frame, the nonlocal frame struct can be
72 allocated anywhere. Which means that the outer function is now
75 Theory of operation here is very simple. Iterate over all the
76 statements in all the functions (depth first) several times,
77 allocating structures and fields on demand. In general we want to
78 examine inner functions first, so that we can avoid making changes
79 to outer functions which are unnecessary.
81 The order of the passes matters a bit, in that later passes will be
82 skipped if it is discovered that the functions don't actually interact
83 at all. That is, they're nested in the lexical sense but could have
84 been written as independent functions without change. */
89 struct nesting_info
*outer
;
90 struct nesting_info
*inner
;
91 struct nesting_info
*next
;
93 hash_map
<tree
, tree
> *field_map
;
94 hash_map
<tree
, tree
> *var_map
;
95 hash_set
<tree
*> *mem_refs
;
96 bitmap suppress_expansion
;
99 tree new_local_var_chain
;
100 tree debug_var_chain
;
108 bool any_parm_remapped
;
109 bool any_tramp_created
;
110 bool any_descr_created
;
111 char static_chain_added
;
115 /* Iterate over the nesting tree, starting with ROOT, depth first. */
117 static inline struct nesting_info
*
118 iter_nestinfo_start (struct nesting_info
*root
)
125 static inline struct nesting_info
*
126 iter_nestinfo_next (struct nesting_info
*node
)
129 return iter_nestinfo_start (node
->next
);
133 #define FOR_EACH_NEST_INFO(I, ROOT) \
134 for ((I) = iter_nestinfo_start (ROOT); (I); (I) = iter_nestinfo_next (I))
136 /* Obstack used for the bitmaps in the struct above. */
137 static struct bitmap_obstack nesting_info_bitmap_obstack
;
140 /* We're working in so many different function contexts simultaneously,
141 that create_tmp_var is dangerous. Prevent mishap. */
142 #define create_tmp_var cant_use_create_tmp_var_here_dummy
144 /* Like create_tmp_var, except record the variable for registration at
145 the given nesting level. */
148 create_tmp_var_for (struct nesting_info
*info
, tree type
, const char *prefix
)
152 /* If the type is of variable size or a type which must be created by the
153 frontend, something is wrong. Note that we explicitly allow
154 incomplete types here, since we create them ourselves here. */
155 gcc_assert (!TREE_ADDRESSABLE (type
));
156 gcc_assert (!TYPE_SIZE_UNIT (type
)
157 || TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
);
159 tmp_var
= create_tmp_var_raw (type
, prefix
);
160 DECL_CONTEXT (tmp_var
) = info
->context
;
161 DECL_CHAIN (tmp_var
) = info
->new_local_var_chain
;
162 DECL_SEEN_IN_BIND_EXPR_P (tmp_var
) = 1;
163 if (TREE_CODE (type
) == COMPLEX_TYPE
164 || TREE_CODE (type
) == VECTOR_TYPE
)
165 DECL_GIMPLE_REG_P (tmp_var
) = 1;
167 info
->new_local_var_chain
= tmp_var
;
172 /* Take the address of EXP to be used within function CONTEXT.
173 Mark it for addressability as necessary. */
176 build_addr (tree exp
)
178 mark_addressable (exp
);
179 return build_fold_addr_expr (exp
);
182 /* Insert FIELD into TYPE, sorted by alignment requirements. */
185 insert_field_into_struct (tree type
, tree field
)
189 DECL_CONTEXT (field
) = type
;
191 for (p
= &TYPE_FIELDS (type
); *p
; p
= &DECL_CHAIN (*p
))
192 if (DECL_ALIGN (field
) >= DECL_ALIGN (*p
))
195 DECL_CHAIN (field
) = *p
;
198 /* Set correct alignment for frame struct type. */
199 if (TYPE_ALIGN (type
) < DECL_ALIGN (field
))
200 SET_TYPE_ALIGN (type
, DECL_ALIGN (field
));
203 /* Build or return the RECORD_TYPE that describes the frame state that is
204 shared between INFO->CONTEXT and its nested functions. This record will
205 not be complete until finalize_nesting_tree; up until that point we'll
206 be adding fields as necessary.
208 We also build the DECL that represents this frame in the function. */
211 get_frame_type (struct nesting_info
*info
)
213 tree type
= info
->frame_type
;
218 type
= make_node (RECORD_TYPE
);
220 name
= concat ("FRAME.",
221 IDENTIFIER_POINTER (DECL_NAME (info
->context
)),
223 TYPE_NAME (type
) = get_identifier (name
);
226 info
->frame_type
= type
;
228 /* Do not put info->frame_decl on info->new_local_var_chain,
229 so that we can declare it in the lexical blocks, which
230 makes sure virtual regs that end up appearing in its RTL
231 expression get substituted in instantiate_virtual_regs. */
232 info
->frame_decl
= create_tmp_var_raw (type
, "FRAME");
233 DECL_CONTEXT (info
->frame_decl
) = info
->context
;
234 DECL_NONLOCAL_FRAME (info
->frame_decl
) = 1;
235 DECL_SEEN_IN_BIND_EXPR_P (info
->frame_decl
) = 1;
237 /* ??? Always make it addressable for now, since it is meant to
238 be pointed to by the static chain pointer. This pessimizes
239 when it turns out that no static chains are needed because
240 the nested functions referencing non-local variables are not
241 reachable, but the true pessimization is to create the non-
242 local frame structure in the first place. */
243 TREE_ADDRESSABLE (info
->frame_decl
) = 1;
249 /* Return true if DECL should be referenced by pointer in the non-local frame
253 use_pointer_in_frame (tree decl
)
255 if (TREE_CODE (decl
) == PARM_DECL
)
257 /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable-
258 sized DECLs, and inefficient to copy large aggregates. Don't bother
259 moving anything but scalar parameters. */
260 return AGGREGATE_TYPE_P (TREE_TYPE (decl
));
264 /* Variable-sized DECLs can only come from OMP clauses at this point
265 since the gimplifier has already turned the regular variables into
266 pointers. Do the same as the gimplifier. */
267 return !DECL_SIZE (decl
) || TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
;
271 /* Given DECL, a non-locally accessed variable, find or create a field
272 in the non-local frame structure for the given nesting context. */
275 lookup_field_for_decl (struct nesting_info
*info
, tree decl
,
276 enum insert_option insert
)
278 gcc_checking_assert (decl_function_context (decl
) == info
->context
);
280 if (insert
== NO_INSERT
)
282 tree
*slot
= info
->field_map
->get (decl
);
283 return slot
? *slot
: NULL_TREE
;
286 tree
*slot
= &info
->field_map
->get_or_insert (decl
);
289 tree type
= get_frame_type (info
);
290 tree field
= make_node (FIELD_DECL
);
291 DECL_NAME (field
) = DECL_NAME (decl
);
293 if (use_pointer_in_frame (decl
))
295 TREE_TYPE (field
) = build_pointer_type (TREE_TYPE (decl
));
296 SET_DECL_ALIGN (field
, TYPE_ALIGN (TREE_TYPE (field
)));
297 DECL_NONADDRESSABLE_P (field
) = 1;
301 TREE_TYPE (field
) = TREE_TYPE (decl
);
302 DECL_SOURCE_LOCATION (field
) = DECL_SOURCE_LOCATION (decl
);
303 SET_DECL_ALIGN (field
, DECL_ALIGN (decl
));
304 DECL_USER_ALIGN (field
) = DECL_USER_ALIGN (decl
);
305 TREE_ADDRESSABLE (field
) = TREE_ADDRESSABLE (decl
);
306 DECL_NONADDRESSABLE_P (field
) = !TREE_ADDRESSABLE (decl
);
307 TREE_THIS_VOLATILE (field
) = TREE_THIS_VOLATILE (decl
);
309 /* Declare the transformation and adjust the original DECL. For a
310 variable or for a parameter when not optimizing, we make it point
311 to the field in the frame directly. For a parameter, we don't do
312 it when optimizing because the variable tracking pass will already
314 if (VAR_P (decl
) || !optimize
)
317 = build3 (COMPONENT_REF
, TREE_TYPE (field
), info
->frame_decl
,
320 /* If the next declaration is a PARM_DECL pointing to the DECL,
321 we need to adjust its VALUE_EXPR directly, since chains of
322 VALUE_EXPRs run afoul of garbage collection. This occurs
323 in Ada for Out parameters that aren't copied in. */
324 tree next
= DECL_CHAIN (decl
);
326 && TREE_CODE (next
) == PARM_DECL
327 && DECL_HAS_VALUE_EXPR_P (next
)
328 && DECL_VALUE_EXPR (next
) == decl
)
329 SET_DECL_VALUE_EXPR (next
, x
);
331 SET_DECL_VALUE_EXPR (decl
, x
);
332 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
336 insert_field_into_struct (type
, field
);
339 if (TREE_CODE (decl
) == PARM_DECL
)
340 info
->any_parm_remapped
= true;
346 /* Build or return the variable that holds the static chain within
347 INFO->CONTEXT. This variable may only be used within INFO->CONTEXT. */
350 get_chain_decl (struct nesting_info
*info
)
352 tree decl
= info
->chain_decl
;
358 type
= get_frame_type (info
->outer
);
359 type
= build_pointer_type (type
);
361 /* Note that this variable is *not* entered into any BIND_EXPR;
362 the construction of this variable is handled specially in
363 expand_function_start and initialize_inlined_parameters.
364 Note also that it's represented as a parameter. This is more
365 close to the truth, since the initial value does come from
367 decl
= build_decl (DECL_SOURCE_LOCATION (info
->context
),
368 PARM_DECL
, create_tmp_var_name ("CHAIN"), type
);
369 DECL_ARTIFICIAL (decl
) = 1;
370 DECL_IGNORED_P (decl
) = 1;
371 TREE_USED (decl
) = 1;
372 DECL_CONTEXT (decl
) = info
->context
;
373 DECL_ARG_TYPE (decl
) = type
;
375 /* Tell tree-inline.c that we never write to this variable, so
376 it can copy-prop the replacement value immediately. */
377 TREE_READONLY (decl
) = 1;
379 info
->chain_decl
= decl
;
382 && (dump_flags
& TDF_DETAILS
)
383 && !DECL_STATIC_CHAIN (info
->context
))
384 fprintf (dump_file
, "Setting static-chain for %s\n",
385 lang_hooks
.decl_printable_name (info
->context
, 2));
387 DECL_STATIC_CHAIN (info
->context
) = 1;
392 /* Build or return the field within the non-local frame state that holds
393 the static chain for INFO->CONTEXT. This is the way to walk back up
394 multiple nesting levels. */
397 get_chain_field (struct nesting_info
*info
)
399 tree field
= info
->chain_field
;
403 tree type
= build_pointer_type (get_frame_type (info
->outer
));
405 field
= make_node (FIELD_DECL
);
406 DECL_NAME (field
) = get_identifier ("__chain");
407 TREE_TYPE (field
) = type
;
408 SET_DECL_ALIGN (field
, TYPE_ALIGN (type
));
409 DECL_NONADDRESSABLE_P (field
) = 1;
411 insert_field_into_struct (get_frame_type (info
), field
);
413 info
->chain_field
= field
;
416 && (dump_flags
& TDF_DETAILS
)
417 && !DECL_STATIC_CHAIN (info
->context
))
418 fprintf (dump_file
, "Setting static-chain for %s\n",
419 lang_hooks
.decl_printable_name (info
->context
, 2));
421 DECL_STATIC_CHAIN (info
->context
) = 1;
426 /* Initialize a new temporary with the GIMPLE_CALL STMT. */
429 init_tmp_var_with_call (struct nesting_info
*info
, gimple_stmt_iterator
*gsi
,
434 t
= create_tmp_var_for (info
, gimple_call_return_type (call
), NULL
);
435 gimple_call_set_lhs (call
, t
);
436 if (! gsi_end_p (*gsi
))
437 gimple_set_location (call
, gimple_location (gsi_stmt (*gsi
)));
438 gsi_insert_before (gsi
, call
, GSI_SAME_STMT
);
444 /* Copy EXP into a temporary. Allocate the temporary in the context of
445 INFO and insert the initialization statement before GSI. */
448 init_tmp_var (struct nesting_info
*info
, tree exp
, gimple_stmt_iterator
*gsi
)
453 t
= create_tmp_var_for (info
, TREE_TYPE (exp
), NULL
);
454 stmt
= gimple_build_assign (t
, exp
);
455 if (! gsi_end_p (*gsi
))
456 gimple_set_location (stmt
, gimple_location (gsi_stmt (*gsi
)));
457 gsi_insert_before_without_update (gsi
, stmt
, GSI_SAME_STMT
);
463 /* Similarly, but only do so to force EXP to satisfy is_gimple_val. */
466 gsi_gimplify_val (struct nesting_info
*info
, tree exp
,
467 gimple_stmt_iterator
*gsi
)
469 if (is_gimple_val (exp
))
472 return init_tmp_var (info
, exp
, gsi
);
475 /* Similarly, but copy from the temporary and insert the statement
476 after the iterator. */
479 save_tmp_var (struct nesting_info
*info
, tree exp
, gimple_stmt_iterator
*gsi
)
484 t
= create_tmp_var_for (info
, TREE_TYPE (exp
), NULL
);
485 stmt
= gimple_build_assign (exp
, t
);
486 if (! gsi_end_p (*gsi
))
487 gimple_set_location (stmt
, gimple_location (gsi_stmt (*gsi
)));
488 gsi_insert_after_without_update (gsi
, stmt
, GSI_SAME_STMT
);
493 /* Build or return the type used to represent a nested function trampoline. */
495 static GTY(()) tree trampoline_type
;
498 get_trampoline_type (struct nesting_info
*info
)
500 unsigned align
, size
;
504 return trampoline_type
;
506 align
= TRAMPOLINE_ALIGNMENT
;
507 size
= TRAMPOLINE_SIZE
;
509 /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
510 then allocate extra space so that we can do dynamic alignment. */
511 if (align
> STACK_BOUNDARY
)
513 size
+= ((align
/BITS_PER_UNIT
) - 1) & -(STACK_BOUNDARY
/BITS_PER_UNIT
);
514 align
= STACK_BOUNDARY
;
517 t
= build_index_type (size_int (size
- 1));
518 t
= build_array_type (char_type_node
, t
);
519 t
= build_decl (DECL_SOURCE_LOCATION (info
->context
),
520 FIELD_DECL
, get_identifier ("__data"), t
);
521 SET_DECL_ALIGN (t
, align
);
522 DECL_USER_ALIGN (t
) = 1;
524 trampoline_type
= make_node (RECORD_TYPE
);
525 TYPE_NAME (trampoline_type
) = get_identifier ("__builtin_trampoline");
526 TYPE_FIELDS (trampoline_type
) = t
;
527 layout_type (trampoline_type
);
528 DECL_CONTEXT (t
) = trampoline_type
;
530 return trampoline_type
;
533 /* Build or return the type used to represent a nested function descriptor. */
535 static GTY(()) tree descriptor_type
;
538 get_descriptor_type (struct nesting_info
*info
)
540 /* The base alignment is that of a function. */
541 const unsigned align
= FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY
);
545 return descriptor_type
;
547 t
= build_index_type (integer_one_node
);
548 t
= build_array_type (ptr_type_node
, t
);
549 t
= build_decl (DECL_SOURCE_LOCATION (info
->context
),
550 FIELD_DECL
, get_identifier ("__data"), t
);
551 SET_DECL_ALIGN (t
, MAX (TYPE_ALIGN (ptr_type_node
), align
));
552 DECL_USER_ALIGN (t
) = 1;
554 descriptor_type
= make_node (RECORD_TYPE
);
555 TYPE_NAME (descriptor_type
) = get_identifier ("__builtin_descriptor");
556 TYPE_FIELDS (descriptor_type
) = t
;
557 layout_type (descriptor_type
);
558 DECL_CONTEXT (t
) = descriptor_type
;
560 return descriptor_type
;
563 /* Given DECL, a nested function, find or create an element in the
564 var map for this function. */
567 lookup_element_for_decl (struct nesting_info
*info
, tree decl
,
568 enum insert_option insert
)
570 if (insert
== NO_INSERT
)
572 tree
*slot
= info
->var_map
->get (decl
);
573 return slot
? *slot
: NULL_TREE
;
576 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
578 *slot
= build_tree_list (NULL_TREE
, NULL_TREE
);
583 /* Given DECL, a nested function, create a field in the non-local
584 frame structure for this function. */
587 create_field_for_decl (struct nesting_info
*info
, tree decl
, tree type
)
589 tree field
= make_node (FIELD_DECL
);
590 DECL_NAME (field
) = DECL_NAME (decl
);
591 TREE_TYPE (field
) = type
;
592 TREE_ADDRESSABLE (field
) = 1;
593 insert_field_into_struct (get_frame_type (info
), field
);
597 /* Given DECL, a nested function, find or create a field in the non-local
598 frame structure for a trampoline for this function. */
601 lookup_tramp_for_decl (struct nesting_info
*info
, tree decl
,
602 enum insert_option insert
)
606 elt
= lookup_element_for_decl (info
, decl
, insert
);
610 field
= TREE_PURPOSE (elt
);
612 if (!field
&& insert
== INSERT
)
614 field
= create_field_for_decl (info
, decl
, get_trampoline_type (info
));
615 TREE_PURPOSE (elt
) = field
;
616 info
->any_tramp_created
= true;
622 /* Given DECL, a nested function, find or create a field in the non-local
623 frame structure for a descriptor for this function. */
626 lookup_descr_for_decl (struct nesting_info
*info
, tree decl
,
627 enum insert_option insert
)
631 elt
= lookup_element_for_decl (info
, decl
, insert
);
635 field
= TREE_VALUE (elt
);
637 if (!field
&& insert
== INSERT
)
639 field
= create_field_for_decl (info
, decl
, get_descriptor_type (info
));
640 TREE_VALUE (elt
) = field
;
641 info
->any_descr_created
= true;
647 /* Build or return the field within the non-local frame state that holds
648 the non-local goto "jmp_buf". The buffer itself is maintained by the
649 rtl middle-end as dynamic stack space is allocated. */
652 get_nl_goto_field (struct nesting_info
*info
)
654 tree field
= info
->nl_goto_field
;
660 /* For __builtin_nonlocal_goto, we need N words. The first is the
661 frame pointer, the rest is for the target's stack pointer save
662 area. The number of words is controlled by STACK_SAVEAREA_MODE;
663 not the best interface, but it'll do for now. */
664 if (Pmode
== ptr_mode
)
665 type
= ptr_type_node
;
667 type
= lang_hooks
.types
.type_for_mode (Pmode
, 1);
670 = as_a
<scalar_int_mode
> (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
));
671 size
= GET_MODE_SIZE (mode
);
672 size
= size
/ GET_MODE_SIZE (Pmode
);
675 type
= build_array_type
676 (type
, build_index_type (size_int (size
)));
678 field
= make_node (FIELD_DECL
);
679 DECL_NAME (field
) = get_identifier ("__nl_goto_buf");
680 TREE_TYPE (field
) = type
;
681 SET_DECL_ALIGN (field
, TYPE_ALIGN (type
));
682 TREE_ADDRESSABLE (field
) = 1;
684 insert_field_into_struct (get_frame_type (info
), field
);
686 info
->nl_goto_field
= field
;
692 /* Invoke CALLBACK on all statements of GIMPLE sequence *PSEQ. */
695 walk_body (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
696 struct nesting_info
*info
, gimple_seq
*pseq
)
698 struct walk_stmt_info wi
;
700 memset (&wi
, 0, sizeof (wi
));
703 walk_gimple_seq_mod (pseq
, callback_stmt
, callback_op
, &wi
);
707 /* Invoke CALLBACK_STMT/CALLBACK_OP on all statements of INFO->CONTEXT. */
710 walk_function (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
711 struct nesting_info
*info
)
713 gimple_seq body
= gimple_body (info
->context
);
714 walk_body (callback_stmt
, callback_op
, info
, &body
);
715 gimple_set_body (info
->context
, body
);
718 /* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body. */
721 walk_gimple_omp_for (gomp_for
*for_stmt
,
722 walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
723 struct nesting_info
*info
)
725 struct walk_stmt_info wi
;
730 walk_body (callback_stmt
, callback_op
, info
, gimple_omp_for_pre_body_ptr (for_stmt
));
733 memset (&wi
, 0, sizeof (wi
));
735 wi
.gsi
= gsi_last (seq
);
737 for (i
= 0; i
< gimple_omp_for_collapse (for_stmt
); i
++)
740 walk_tree (gimple_omp_for_index_ptr (for_stmt
, i
), callback_op
,
744 walk_tree (gimple_omp_for_initial_ptr (for_stmt
, i
), callback_op
,
749 walk_tree (gimple_omp_for_final_ptr (for_stmt
, i
), callback_op
,
752 t
= gimple_omp_for_incr (for_stmt
, i
);
753 gcc_assert (BINARY_CLASS_P (t
));
755 walk_tree (&TREE_OPERAND (t
, 0), callback_op
, &wi
, NULL
);
758 walk_tree (&TREE_OPERAND (t
, 1), callback_op
, &wi
, NULL
);
761 seq
= gsi_seq (wi
.gsi
);
762 if (!gimple_seq_empty_p (seq
))
764 gimple_seq pre_body
= gimple_omp_for_pre_body (for_stmt
);
765 annotate_all_with_location (seq
, gimple_location (for_stmt
));
766 gimple_seq_add_seq (&pre_body
, seq
);
767 gimple_omp_for_set_pre_body (for_stmt
, pre_body
);
771 /* Similarly for ROOT and all functions nested underneath, depth first. */
774 walk_all_functions (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
775 struct nesting_info
*root
)
777 struct nesting_info
*n
;
778 FOR_EACH_NEST_INFO (n
, root
)
779 walk_function (callback_stmt
, callback_op
, n
);
783 /* We have to check for a fairly pathological case. The operands of function
784 nested function are to be interpreted in the context of the enclosing
785 function. So if any are variably-sized, they will get remapped when the
786 enclosing function is inlined. But that remapping would also have to be
787 done in the types of the PARM_DECLs of the nested function, meaning the
788 argument types of that function will disagree with the arguments in the
789 calls to that function. So we'd either have to make a copy of the nested
790 function corresponding to each time the enclosing function was inlined or
791 add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
792 function. The former is not practical. The latter would still require
793 detecting this case to know when to add the conversions. So, for now at
794 least, we don't inline such an enclosing function.
796 We have to do that check recursively, so here return indicating whether
797 FNDECL has such a nested function. ORIG_FN is the function we were
798 trying to inline to use for checking whether any argument is variably
799 modified by anything in it.
801 It would be better to do this in tree-inline.c so that we could give
802 the appropriate warning for why a function can't be inlined, but that's
803 too late since the nesting structure has already been flattened and
804 adding a flag just to record this fact seems a waste of a flag. */
807 check_for_nested_with_variably_modified (tree fndecl
, tree orig_fndecl
)
809 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
812 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
814 for (arg
= DECL_ARGUMENTS (cgn
->decl
); arg
; arg
= DECL_CHAIN (arg
))
815 if (variably_modified_type_p (TREE_TYPE (arg
), orig_fndecl
))
818 if (check_for_nested_with_variably_modified (cgn
->decl
,
826 /* Construct our local datastructure describing the function nesting
827 tree rooted by CGN. */
829 static struct nesting_info
*
830 create_nesting_tree (struct cgraph_node
*cgn
)
832 struct nesting_info
*info
= XCNEW (struct nesting_info
);
833 info
->field_map
= new hash_map
<tree
, tree
>;
834 info
->var_map
= new hash_map
<tree
, tree
>;
835 info
->mem_refs
= new hash_set
<tree
*>;
836 info
->suppress_expansion
= BITMAP_ALLOC (&nesting_info_bitmap_obstack
);
837 info
->context
= cgn
->decl
;
838 info
->thunk_p
= cgn
->thunk
.thunk_p
;
840 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
842 struct nesting_info
*sub
= create_nesting_tree (cgn
);
844 sub
->next
= info
->inner
;
848 /* See discussion at check_for_nested_with_variably_modified for a
849 discussion of why this has to be here. */
850 if (check_for_nested_with_variably_modified (info
->context
, info
->context
))
851 DECL_UNINLINABLE (info
->context
) = true;
856 /* Return an expression computing the static chain for TARGET_CONTEXT
857 from INFO->CONTEXT. Insert any necessary computations before TSI. */
860 get_static_chain (struct nesting_info
*info
, tree target_context
,
861 gimple_stmt_iterator
*gsi
)
863 struct nesting_info
*i
;
866 if (info
->context
== target_context
)
868 x
= build_addr (info
->frame_decl
);
869 info
->static_chain_added
|= 1;
873 x
= get_chain_decl (info
);
874 info
->static_chain_added
|= 2;
876 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
878 tree field
= get_chain_field (i
);
880 x
= build_simple_mem_ref (x
);
881 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
882 x
= init_tmp_var (info
, x
, gsi
);
890 /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
891 frame as seen from INFO->CONTEXT. Insert any necessary computations
895 get_frame_field (struct nesting_info
*info
, tree target_context
,
896 tree field
, gimple_stmt_iterator
*gsi
)
898 struct nesting_info
*i
;
901 if (info
->context
== target_context
)
903 /* Make sure frame_decl gets created. */
904 (void) get_frame_type (info
);
905 x
= info
->frame_decl
;
906 info
->static_chain_added
|= 1;
910 x
= get_chain_decl (info
);
911 info
->static_chain_added
|= 2;
913 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
915 tree field
= get_chain_field (i
);
917 x
= build_simple_mem_ref (x
);
918 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
919 x
= init_tmp_var (info
, x
, gsi
);
922 x
= build_simple_mem_ref (x
);
925 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
929 static void note_nonlocal_vla_type (struct nesting_info
*info
, tree type
);
931 /* A subroutine of convert_nonlocal_reference_op. Create a local variable
932 in the nested function with DECL_VALUE_EXPR set to reference the true
933 variable in the parent function. This is used both for debug info
934 and in OMP lowering. */
937 get_nonlocal_debug_decl (struct nesting_info
*info
, tree decl
)
940 struct nesting_info
*i
;
941 tree x
, field
, new_decl
;
943 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
948 target_context
= decl_function_context (decl
);
950 /* A copy of the code in get_frame_field, but without the temporaries. */
951 if (info
->context
== target_context
)
953 /* Make sure frame_decl gets created. */
954 (void) get_frame_type (info
);
955 x
= info
->frame_decl
;
957 info
->static_chain_added
|= 1;
961 x
= get_chain_decl (info
);
962 info
->static_chain_added
|= 2;
963 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
965 field
= get_chain_field (i
);
966 x
= build_simple_mem_ref (x
);
967 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
969 x
= build_simple_mem_ref (x
);
972 field
= lookup_field_for_decl (i
, decl
, INSERT
);
973 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
974 if (use_pointer_in_frame (decl
))
975 x
= build_simple_mem_ref (x
);
977 /* ??? We should be remapping types as well, surely. */
978 new_decl
= build_decl (DECL_SOURCE_LOCATION (decl
),
979 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
980 DECL_CONTEXT (new_decl
) = info
->context
;
981 DECL_ARTIFICIAL (new_decl
) = DECL_ARTIFICIAL (decl
);
982 DECL_IGNORED_P (new_decl
) = DECL_IGNORED_P (decl
);
983 TREE_THIS_VOLATILE (new_decl
) = TREE_THIS_VOLATILE (decl
);
984 TREE_SIDE_EFFECTS (new_decl
) = TREE_SIDE_EFFECTS (decl
);
985 TREE_READONLY (new_decl
) = TREE_READONLY (decl
);
986 TREE_ADDRESSABLE (new_decl
) = TREE_ADDRESSABLE (decl
);
987 DECL_SEEN_IN_BIND_EXPR_P (new_decl
) = 1;
988 if ((TREE_CODE (decl
) == PARM_DECL
989 || TREE_CODE (decl
) == RESULT_DECL
991 && DECL_BY_REFERENCE (decl
))
992 DECL_BY_REFERENCE (new_decl
) = 1;
994 SET_DECL_VALUE_EXPR (new_decl
, x
);
995 DECL_HAS_VALUE_EXPR_P (new_decl
) = 1;
998 DECL_CHAIN (new_decl
) = info
->debug_var_chain
;
999 info
->debug_var_chain
= new_decl
;
1002 && info
->context
!= target_context
1003 && variably_modified_type_p (TREE_TYPE (decl
), NULL
))
1004 note_nonlocal_vla_type (info
, TREE_TYPE (decl
));
1010 /* Callback for walk_gimple_stmt, rewrite all references to VAR
1011 and PARM_DECLs that belong to outer functions.
1013 The rewrite will involve some number of structure accesses back up
1014 the static chain. E.g. for a variable FOO up one nesting level it'll
1015 be CHAIN->FOO. For two levels it'll be CHAIN->__chain->FOO. Further
1016 indirections apply to decls for which use_pointer_in_frame is true. */
1019 convert_nonlocal_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
1021 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
1022 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1026 switch (TREE_CODE (t
))
1029 /* Non-automatic variables are never processed. */
1030 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
1036 tree x
, target_context
= decl_function_context (t
);
1038 if (info
->context
== target_context
)
1043 if (bitmap_bit_p (info
->suppress_expansion
, DECL_UID (t
)))
1044 x
= get_nonlocal_debug_decl (info
, t
);
1047 struct nesting_info
*i
= info
;
1048 while (i
&& i
->context
!= target_context
)
1050 /* If none of the outer contexts is the target context, this means
1051 that the VAR or PARM_DECL is referenced in a wrong context. */
1053 internal_error ("%s from %s referenced in %s",
1054 IDENTIFIER_POINTER (DECL_NAME (t
)),
1055 IDENTIFIER_POINTER (DECL_NAME (target_context
)),
1056 IDENTIFIER_POINTER (DECL_NAME (info
->context
)));
1058 x
= lookup_field_for_decl (i
, t
, INSERT
);
1059 x
= get_frame_field (info
, target_context
, x
, &wi
->gsi
);
1060 if (use_pointer_in_frame (t
))
1062 x
= init_tmp_var (info
, x
, &wi
->gsi
);
1063 x
= build_simple_mem_ref (x
);
1070 x
= save_tmp_var (info
, x
, &wi
->gsi
);
1072 x
= init_tmp_var (info
, x
, &wi
->gsi
);
1080 /* We're taking the address of a label from a parent function, but
1081 this is not itself a non-local goto. Mark the label such that it
1082 will not be deleted, much as we would with a label address in
1084 if (decl_function_context (t
) != info
->context
)
1085 FORCED_LABEL (t
) = 1;
1090 bool save_val_only
= wi
->val_only
;
1092 wi
->val_only
= false;
1094 wi
->changed
= false;
1095 walk_tree (&TREE_OPERAND (t
, 0), convert_nonlocal_reference_op
, wi
, 0);
1096 wi
->val_only
= true;
1102 /* If we changed anything, we might no longer be directly
1103 referencing a decl. */
1104 save_context
= current_function_decl
;
1105 current_function_decl
= info
->context
;
1106 recompute_tree_invariant_for_addr_expr (t
);
1107 current_function_decl
= save_context
;
1109 /* If the callback converted the address argument in a context
1110 where we only accept variables (and min_invariant, presumably),
1111 then compute the address into a temporary. */
1113 *tp
= gsi_gimplify_val ((struct nesting_info
*) wi
->info
,
1123 case ARRAY_RANGE_REF
:
1125 /* Go down this entire nest and just look at the final prefix and
1126 anything that describes the references. Otherwise, we lose track
1127 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1128 wi
->val_only
= true;
1130 for (; handled_component_p (t
); tp
= &TREE_OPERAND (t
, 0), t
= *tp
)
1132 if (TREE_CODE (t
) == COMPONENT_REF
)
1133 walk_tree (&TREE_OPERAND (t
, 2), convert_nonlocal_reference_op
, wi
,
1135 else if (TREE_CODE (t
) == ARRAY_REF
1136 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
1138 walk_tree (&TREE_OPERAND (t
, 1), convert_nonlocal_reference_op
,
1140 walk_tree (&TREE_OPERAND (t
, 2), convert_nonlocal_reference_op
,
1142 walk_tree (&TREE_OPERAND (t
, 3), convert_nonlocal_reference_op
,
1146 wi
->val_only
= false;
1147 walk_tree (tp
, convert_nonlocal_reference_op
, wi
, NULL
);
1150 case VIEW_CONVERT_EXPR
:
1151 /* Just request to look at the subtrees, leaving val_only and lhs
1152 untouched. This might actually be for !val_only + lhs, in which
1153 case we don't want to force a replacement by a temporary. */
1158 if (!IS_TYPE_OR_DECL_P (t
))
1161 wi
->val_only
= true;
1170 static tree
convert_nonlocal_reference_stmt (gimple_stmt_iterator
*, bool *,
1171 struct walk_stmt_info
*);
1173 /* Helper for convert_nonlocal_references, rewrite all references to VAR
1174 and PARM_DECLs that belong to outer functions. */
1177 convert_nonlocal_omp_clauses (tree
*pclauses
, struct walk_stmt_info
*wi
)
1179 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1180 bool need_chain
= false, need_stmts
= false;
1183 bitmap new_suppress
;
1185 new_suppress
= BITMAP_GGC_ALLOC ();
1186 bitmap_copy (new_suppress
, info
->suppress_expansion
);
1188 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1190 switch (OMP_CLAUSE_CODE (clause
))
1192 case OMP_CLAUSE_REDUCTION
:
1193 case OMP_CLAUSE_IN_REDUCTION
:
1194 case OMP_CLAUSE_TASK_REDUCTION
:
1195 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1197 goto do_decl_clause
;
1199 case OMP_CLAUSE_LASTPRIVATE
:
1200 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
))
1202 goto do_decl_clause
;
1204 case OMP_CLAUSE_LINEAR
:
1205 if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
))
1207 wi
->val_only
= true;
1209 convert_nonlocal_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause
),
1211 goto do_decl_clause
;
1213 case OMP_CLAUSE_PRIVATE
:
1214 case OMP_CLAUSE_FIRSTPRIVATE
:
1215 case OMP_CLAUSE_COPYPRIVATE
:
1216 case OMP_CLAUSE_SHARED
:
1217 case OMP_CLAUSE_TO_DECLARE
:
1218 case OMP_CLAUSE_LINK
:
1219 case OMP_CLAUSE_USE_DEVICE_PTR
:
1220 case OMP_CLAUSE_IS_DEVICE_PTR
:
1222 decl
= OMP_CLAUSE_DECL (clause
);
1224 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1226 if (decl_function_context (decl
) != info
->context
)
1228 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_SHARED
)
1229 OMP_CLAUSE_SHARED_READONLY (clause
) = 0;
1230 bitmap_set_bit (new_suppress
, DECL_UID (decl
));
1231 OMP_CLAUSE_DECL (clause
) = get_nonlocal_debug_decl (info
, decl
);
1232 if (OMP_CLAUSE_CODE (clause
) != OMP_CLAUSE_PRIVATE
)
1237 case OMP_CLAUSE_SCHEDULE
:
1238 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
) == NULL
)
1241 case OMP_CLAUSE_FINAL
:
1243 case OMP_CLAUSE_NUM_THREADS
:
1244 case OMP_CLAUSE_DEPEND
:
1245 case OMP_CLAUSE_DEVICE
:
1246 case OMP_CLAUSE_NUM_TEAMS
:
1247 case OMP_CLAUSE_THREAD_LIMIT
:
1248 case OMP_CLAUSE_SAFELEN
:
1249 case OMP_CLAUSE_SIMDLEN
:
1250 case OMP_CLAUSE_PRIORITY
:
1251 case OMP_CLAUSE_GRAINSIZE
:
1252 case OMP_CLAUSE_NUM_TASKS
:
1253 case OMP_CLAUSE_HINT
:
1254 case OMP_CLAUSE_NUM_GANGS
:
1255 case OMP_CLAUSE_NUM_WORKERS
:
1256 case OMP_CLAUSE_VECTOR_LENGTH
:
1257 case OMP_CLAUSE_GANG
:
1258 case OMP_CLAUSE_WORKER
:
1259 case OMP_CLAUSE_VECTOR
:
1260 case OMP_CLAUSE_ASYNC
:
1261 case OMP_CLAUSE_WAIT
:
1262 /* Several OpenACC clauses have optional arguments. Check if they
1264 if (OMP_CLAUSE_OPERAND (clause
, 0))
1266 wi
->val_only
= true;
1268 convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
1272 /* The gang clause accepts two arguments. */
1273 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_GANG
1274 && OMP_CLAUSE_GANG_STATIC_EXPR (clause
))
1276 wi
->val_only
= true;
1278 convert_nonlocal_reference_op
1279 (&OMP_CLAUSE_GANG_STATIC_EXPR (clause
), &dummy
, wi
);
1283 case OMP_CLAUSE_DIST_SCHEDULE
:
1284 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
) != NULL
)
1286 wi
->val_only
= true;
1288 convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
1293 case OMP_CLAUSE_MAP
:
1295 case OMP_CLAUSE_FROM
:
1296 if (OMP_CLAUSE_SIZE (clause
))
1298 wi
->val_only
= true;
1300 convert_nonlocal_reference_op (&OMP_CLAUSE_SIZE (clause
),
1303 if (DECL_P (OMP_CLAUSE_DECL (clause
)))
1304 goto do_decl_clause
;
1305 wi
->val_only
= true;
1307 walk_tree (&OMP_CLAUSE_DECL (clause
), convert_nonlocal_reference_op
,
1311 case OMP_CLAUSE_ALIGNED
:
1312 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
1314 wi
->val_only
= true;
1316 convert_nonlocal_reference_op
1317 (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
), &dummy
, wi
);
1320 case OMP_CLAUSE_NONTEMPORAL
:
1321 /* Like do_decl_clause, but don't add any suppression. */
1322 decl
= OMP_CLAUSE_DECL (clause
);
1324 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1326 if (decl_function_context (decl
) != info
->context
)
1328 OMP_CLAUSE_DECL (clause
) = get_nonlocal_debug_decl (info
, decl
);
1333 case OMP_CLAUSE_NOWAIT
:
1334 case OMP_CLAUSE_ORDERED
:
1335 case OMP_CLAUSE_DEFAULT
:
1336 case OMP_CLAUSE_COPYIN
:
1337 case OMP_CLAUSE_COLLAPSE
:
1338 case OMP_CLAUSE_TILE
:
1339 case OMP_CLAUSE_UNTIED
:
1340 case OMP_CLAUSE_MERGEABLE
:
1341 case OMP_CLAUSE_PROC_BIND
:
1342 case OMP_CLAUSE_NOGROUP
:
1343 case OMP_CLAUSE_THREADS
:
1344 case OMP_CLAUSE_SIMD
:
1345 case OMP_CLAUSE_DEFAULTMAP
:
1346 case OMP_CLAUSE_SEQ
:
1347 case OMP_CLAUSE_INDEPENDENT
:
1348 case OMP_CLAUSE_AUTO
:
1349 case OMP_CLAUSE_IF_PRESENT
:
1350 case OMP_CLAUSE_FINALIZE
:
1351 case OMP_CLAUSE__CONDTEMP_
:
1352 case OMP_CLAUSE__SCANTEMP_
:
1355 /* The following clause belongs to the OpenACC cache directive, which
1356 is discarded during gimplification. */
1357 case OMP_CLAUSE__CACHE_
:
1358 /* The following clauses are only allowed in the OpenMP declare simd
1359 directive, so not seen here. */
1360 case OMP_CLAUSE_UNIFORM
:
1361 case OMP_CLAUSE_INBRANCH
:
1362 case OMP_CLAUSE_NOTINBRANCH
:
1363 /* The following clauses are only allowed on OpenMP cancel and
1364 cancellation point directives, which at this point have already
1365 been lowered into a function call. */
1366 case OMP_CLAUSE_FOR
:
1367 case OMP_CLAUSE_PARALLEL
:
1368 case OMP_CLAUSE_SECTIONS
:
1369 case OMP_CLAUSE_TASKGROUP
:
1370 /* The following clauses are only added during OMP lowering; nested
1371 function decomposition happens before that. */
1372 case OMP_CLAUSE__LOOPTEMP_
:
1373 case OMP_CLAUSE__REDUCTEMP_
:
1374 case OMP_CLAUSE__SIMDUID_
:
1375 case OMP_CLAUSE__GRIDDIM_
:
1376 case OMP_CLAUSE__SIMT_
:
1377 /* Anything else. */
1383 info
->suppress_expansion
= new_suppress
;
1386 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1387 switch (OMP_CLAUSE_CODE (clause
))
1389 case OMP_CLAUSE_REDUCTION
:
1390 case OMP_CLAUSE_IN_REDUCTION
:
1391 case OMP_CLAUSE_TASK_REDUCTION
:
1392 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1395 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
));
1396 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1398 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
1399 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
1401 walk_body (convert_nonlocal_reference_stmt
,
1402 convert_nonlocal_reference_op
, info
,
1403 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause
));
1404 walk_body (convert_nonlocal_reference_stmt
,
1405 convert_nonlocal_reference_op
, info
,
1406 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause
));
1407 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1409 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
1410 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
1415 case OMP_CLAUSE_LASTPRIVATE
:
1416 walk_body (convert_nonlocal_reference_stmt
,
1417 convert_nonlocal_reference_op
, info
,
1418 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
));
1421 case OMP_CLAUSE_LINEAR
:
1422 walk_body (convert_nonlocal_reference_stmt
,
1423 convert_nonlocal_reference_op
, info
,
1424 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
));
1434 /* Create nonlocal debug decls for nonlocal VLA array bounds. */
1437 note_nonlocal_vla_type (struct nesting_info
*info
, tree type
)
1439 while (POINTER_TYPE_P (type
) && !TYPE_NAME (type
))
1440 type
= TREE_TYPE (type
);
1442 if (TYPE_NAME (type
)
1443 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1444 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1445 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1447 while (POINTER_TYPE_P (type
)
1448 || TREE_CODE (type
) == VECTOR_TYPE
1449 || TREE_CODE (type
) == FUNCTION_TYPE
1450 || TREE_CODE (type
) == METHOD_TYPE
)
1451 type
= TREE_TYPE (type
);
1453 if (TREE_CODE (type
) == ARRAY_TYPE
)
1457 note_nonlocal_vla_type (info
, TREE_TYPE (type
));
1458 domain
= TYPE_DOMAIN (type
);
1461 t
= TYPE_MIN_VALUE (domain
);
1462 if (t
&& (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
1463 && decl_function_context (t
) != info
->context
)
1464 get_nonlocal_debug_decl (info
, t
);
1465 t
= TYPE_MAX_VALUE (domain
);
1466 if (t
&& (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
1467 && decl_function_context (t
) != info
->context
)
1468 get_nonlocal_debug_decl (info
, t
);
1473 /* Callback for walk_gimple_stmt. Rewrite all references to VAR and
1474 PARM_DECLs that belong to outer functions. This handles statements
1475 that are not handled via the standard recursion done in
1476 walk_gimple_stmt. STMT is the statement to examine, DATA is as in
1477 convert_nonlocal_reference_op. Set *HANDLED_OPS_P to true if all the
1478 operands of STMT have been handled by this function. */
1481 convert_nonlocal_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
1482 struct walk_stmt_info
*wi
)
1484 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
1485 tree save_local_var_chain
;
1486 bitmap save_suppress
;
1487 gimple
*stmt
= gsi_stmt (*gsi
);
1489 switch (gimple_code (stmt
))
1492 /* Don't walk non-local gotos for now. */
1493 if (TREE_CODE (gimple_goto_dest (stmt
)) != LABEL_DECL
)
1495 wi
->val_only
= true;
1497 *handled_ops_p
= false;
1502 case GIMPLE_OMP_TEAMS
:
1503 if (!gimple_omp_teams_host (as_a
<gomp_teams
*> (stmt
)))
1505 save_suppress
= info
->suppress_expansion
;
1506 convert_nonlocal_omp_clauses (gimple_omp_teams_clauses_ptr (stmt
),
1508 walk_body (convert_nonlocal_reference_stmt
,
1509 convert_nonlocal_reference_op
, info
,
1510 gimple_omp_body_ptr (stmt
));
1511 info
->suppress_expansion
= save_suppress
;
1516 case GIMPLE_OMP_PARALLEL
:
1517 case GIMPLE_OMP_TASK
:
1518 save_suppress
= info
->suppress_expansion
;
1519 if (convert_nonlocal_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt
),
1523 decl
= get_chain_decl (info
);
1524 c
= build_omp_clause (gimple_location (stmt
),
1525 OMP_CLAUSE_FIRSTPRIVATE
);
1526 OMP_CLAUSE_DECL (c
) = decl
;
1527 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
1528 gimple_omp_taskreg_set_clauses (stmt
, c
);
1531 save_local_var_chain
= info
->new_local_var_chain
;
1532 info
->new_local_var_chain
= NULL
;
1534 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1535 info
, gimple_omp_body_ptr (stmt
));
1537 if (info
->new_local_var_chain
)
1538 declare_vars (info
->new_local_var_chain
,
1539 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
1541 info
->new_local_var_chain
= save_local_var_chain
;
1542 info
->suppress_expansion
= save_suppress
;
1545 case GIMPLE_OMP_FOR
:
1546 save_suppress
= info
->suppress_expansion
;
1547 convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt
), wi
);
1548 walk_gimple_omp_for (as_a
<gomp_for
*> (stmt
),
1549 convert_nonlocal_reference_stmt
,
1550 convert_nonlocal_reference_op
, info
);
1551 walk_body (convert_nonlocal_reference_stmt
,
1552 convert_nonlocal_reference_op
, info
, gimple_omp_body_ptr (stmt
));
1553 info
->suppress_expansion
= save_suppress
;
1556 case GIMPLE_OMP_SECTIONS
:
1557 save_suppress
= info
->suppress_expansion
;
1558 convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt
), wi
);
1559 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1560 info
, gimple_omp_body_ptr (stmt
));
1561 info
->suppress_expansion
= save_suppress
;
1564 case GIMPLE_OMP_SINGLE
:
1565 save_suppress
= info
->suppress_expansion
;
1566 convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt
), wi
);
1567 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1568 info
, gimple_omp_body_ptr (stmt
));
1569 info
->suppress_expansion
= save_suppress
;
1572 case GIMPLE_OMP_TASKGROUP
:
1573 save_suppress
= info
->suppress_expansion
;
1574 convert_nonlocal_omp_clauses (gimple_omp_taskgroup_clauses_ptr (stmt
), wi
);
1575 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1576 info
, gimple_omp_body_ptr (stmt
));
1577 info
->suppress_expansion
= save_suppress
;
1580 case GIMPLE_OMP_TARGET
:
1581 if (!is_gimple_omp_offloaded (stmt
))
1583 save_suppress
= info
->suppress_expansion
;
1584 convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt
),
1586 info
->suppress_expansion
= save_suppress
;
1587 walk_body (convert_nonlocal_reference_stmt
,
1588 convert_nonlocal_reference_op
, info
,
1589 gimple_omp_body_ptr (stmt
));
1592 save_suppress
= info
->suppress_expansion
;
1593 if (convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt
),
1597 decl
= get_chain_decl (info
);
1598 c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
1599 OMP_CLAUSE_DECL (c
) = decl
;
1600 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TO
);
1601 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
1602 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
1603 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
), c
);
1606 save_local_var_chain
= info
->new_local_var_chain
;
1607 info
->new_local_var_chain
= NULL
;
1609 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1610 info
, gimple_omp_body_ptr (stmt
));
1612 if (info
->new_local_var_chain
)
1613 declare_vars (info
->new_local_var_chain
,
1614 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
1616 info
->new_local_var_chain
= save_local_var_chain
;
1617 info
->suppress_expansion
= save_suppress
;
1620 case GIMPLE_OMP_SECTION
:
1621 case GIMPLE_OMP_MASTER
:
1622 case GIMPLE_OMP_ORDERED
:
1623 case GIMPLE_OMP_SCAN
:
1624 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1625 info
, gimple_omp_body_ptr (stmt
));
1630 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1632 for (tree var
= gimple_bind_vars (bind_stmt
); var
; var
= DECL_CHAIN (var
))
1633 if (TREE_CODE (var
) == NAMELIST_DECL
)
1635 /* Adjust decls mentioned in NAMELIST_DECL. */
1636 tree decls
= NAMELIST_DECL_ASSOCIATED_DECL (var
);
1640 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls
), i
, decl
)
1643 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1645 if (decl_function_context (decl
) != info
->context
)
1646 CONSTRUCTOR_ELT (decls
, i
)->value
1647 = get_nonlocal_debug_decl (info
, decl
);
1651 *handled_ops_p
= false;
1655 wi
->val_only
= true;
1657 *handled_ops_p
= false;
1661 if (gimple_clobber_p (stmt
))
1663 tree lhs
= gimple_assign_lhs (stmt
);
1665 && !(TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
1666 && decl_function_context (lhs
) != info
->context
)
1668 gsi_replace (gsi
, gimple_build_nop (), true);
1672 *handled_ops_p
= false;
1676 /* For every other statement that we are not interested in
1677 handling here, let the walker traverse the operands. */
1678 *handled_ops_p
= false;
1682 /* We have handled all of STMT operands, no need to traverse the operands. */
1683 *handled_ops_p
= true;
1688 /* A subroutine of convert_local_reference. Create a local variable
1689 in the parent function with DECL_VALUE_EXPR set to reference the
1690 field in FRAME. This is used both for debug info and in OMP
1694 get_local_debug_decl (struct nesting_info
*info
, tree decl
, tree field
)
1698 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
1702 /* Make sure frame_decl gets created. */
1703 (void) get_frame_type (info
);
1704 x
= info
->frame_decl
;
1705 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
1707 new_decl
= build_decl (DECL_SOURCE_LOCATION (decl
),
1708 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
1709 DECL_CONTEXT (new_decl
) = info
->context
;
1710 DECL_ARTIFICIAL (new_decl
) = DECL_ARTIFICIAL (decl
);
1711 DECL_IGNORED_P (new_decl
) = DECL_IGNORED_P (decl
);
1712 TREE_THIS_VOLATILE (new_decl
) = TREE_THIS_VOLATILE (decl
);
1713 TREE_SIDE_EFFECTS (new_decl
) = TREE_SIDE_EFFECTS (decl
);
1714 TREE_READONLY (new_decl
) = TREE_READONLY (decl
);
1715 TREE_ADDRESSABLE (new_decl
) = TREE_ADDRESSABLE (decl
);
1716 DECL_SEEN_IN_BIND_EXPR_P (new_decl
) = 1;
1717 if ((TREE_CODE (decl
) == PARM_DECL
1718 || TREE_CODE (decl
) == RESULT_DECL
1720 && DECL_BY_REFERENCE (decl
))
1721 DECL_BY_REFERENCE (new_decl
) = 1;
1723 SET_DECL_VALUE_EXPR (new_decl
, x
);
1724 DECL_HAS_VALUE_EXPR_P (new_decl
) = 1;
1727 DECL_CHAIN (new_decl
) = info
->debug_var_chain
;
1728 info
->debug_var_chain
= new_decl
;
1730 /* Do not emit debug info twice. */
1731 DECL_IGNORED_P (decl
) = 1;
1737 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1738 and PARM_DECLs that were referenced by inner nested functions.
1739 The rewrite will be a structure reference to the local frame variable. */
1741 static bool convert_local_omp_clauses (tree
*, struct walk_stmt_info
*);
1744 convert_local_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
1746 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
1747 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1748 tree t
= *tp
, field
, x
;
1752 switch (TREE_CODE (t
))
1755 /* Non-automatic variables are never processed. */
1756 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
1761 if (t
!= info
->frame_decl
&& decl_function_context (t
) == info
->context
)
1763 /* If we copied a pointer to the frame, then the original decl
1764 is used unchanged in the parent function. */
1765 if (use_pointer_in_frame (t
))
1768 /* No need to transform anything if no child references the
1770 field
= lookup_field_for_decl (info
, t
, NO_INSERT
);
1775 if (bitmap_bit_p (info
->suppress_expansion
, DECL_UID (t
)))
1776 x
= get_local_debug_decl (info
, t
, field
);
1778 x
= get_frame_field (info
, info
->context
, field
, &wi
->gsi
);
1783 x
= save_tmp_var (info
, x
, &wi
->gsi
);
1785 x
= init_tmp_var (info
, x
, &wi
->gsi
);
1793 save_val_only
= wi
->val_only
;
1794 wi
->val_only
= false;
1796 wi
->changed
= false;
1797 walk_tree (&TREE_OPERAND (t
, 0), convert_local_reference_op
, wi
, NULL
);
1798 wi
->val_only
= save_val_only
;
1800 /* If we converted anything ... */
1805 /* Then the frame decl is now addressable. */
1806 TREE_ADDRESSABLE (info
->frame_decl
) = 1;
1808 save_context
= current_function_decl
;
1809 current_function_decl
= info
->context
;
1810 recompute_tree_invariant_for_addr_expr (t
);
1811 current_function_decl
= save_context
;
1813 /* If we are in a context where we only accept values, then
1814 compute the address into a temporary. */
1816 *tp
= gsi_gimplify_val ((struct nesting_info
*) wi
->info
,
1825 case ARRAY_RANGE_REF
:
1827 /* Go down this entire nest and just look at the final prefix and
1828 anything that describes the references. Otherwise, we lose track
1829 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1830 save_val_only
= wi
->val_only
;
1831 wi
->val_only
= true;
1833 for (; handled_component_p (t
); tp
= &TREE_OPERAND (t
, 0), t
= *tp
)
1835 if (TREE_CODE (t
) == COMPONENT_REF
)
1836 walk_tree (&TREE_OPERAND (t
, 2), convert_local_reference_op
, wi
,
1838 else if (TREE_CODE (t
) == ARRAY_REF
1839 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
1841 walk_tree (&TREE_OPERAND (t
, 1), convert_local_reference_op
, wi
,
1843 walk_tree (&TREE_OPERAND (t
, 2), convert_local_reference_op
, wi
,
1845 walk_tree (&TREE_OPERAND (t
, 3), convert_local_reference_op
, wi
,
1849 wi
->val_only
= false;
1850 walk_tree (tp
, convert_local_reference_op
, wi
, NULL
);
1851 wi
->val_only
= save_val_only
;
1855 save_val_only
= wi
->val_only
;
1856 wi
->val_only
= true;
1858 walk_tree (&TREE_OPERAND (t
, 0), convert_local_reference_op
,
1860 /* We need to re-fold the MEM_REF as component references as
1861 part of a ADDR_EXPR address are not allowed. But we cannot
1862 fold here, as the chain record type is not yet finalized. */
1863 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
1864 && !DECL_P (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)))
1865 info
->mem_refs
->add (tp
);
1866 wi
->val_only
= save_val_only
;
1869 case VIEW_CONVERT_EXPR
:
1870 /* Just request to look at the subtrees, leaving val_only and lhs
1871 untouched. This might actually be for !val_only + lhs, in which
1872 case we don't want to force a replacement by a temporary. */
1877 if (!IS_TYPE_OR_DECL_P (t
))
1880 wi
->val_only
= true;
1889 static tree
convert_local_reference_stmt (gimple_stmt_iterator
*, bool *,
1890 struct walk_stmt_info
*);
1892 /* Helper for convert_local_reference. Convert all the references in
1893 the chain of clauses at *PCLAUSES. WI is as in convert_local_reference. */
1896 convert_local_omp_clauses (tree
*pclauses
, struct walk_stmt_info
*wi
)
1898 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1899 bool need_frame
= false, need_stmts
= false;
1902 bitmap new_suppress
;
1904 new_suppress
= BITMAP_GGC_ALLOC ();
1905 bitmap_copy (new_suppress
, info
->suppress_expansion
);
1907 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1909 switch (OMP_CLAUSE_CODE (clause
))
1911 case OMP_CLAUSE_REDUCTION
:
1912 case OMP_CLAUSE_IN_REDUCTION
:
1913 case OMP_CLAUSE_TASK_REDUCTION
:
1914 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1916 goto do_decl_clause
;
1918 case OMP_CLAUSE_LASTPRIVATE
:
1919 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
))
1921 goto do_decl_clause
;
1923 case OMP_CLAUSE_LINEAR
:
1924 if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
))
1926 wi
->val_only
= true;
1928 convert_local_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause
), &dummy
,
1930 goto do_decl_clause
;
1932 case OMP_CLAUSE_PRIVATE
:
1933 case OMP_CLAUSE_FIRSTPRIVATE
:
1934 case OMP_CLAUSE_COPYPRIVATE
:
1935 case OMP_CLAUSE_SHARED
:
1936 case OMP_CLAUSE_TO_DECLARE
:
1937 case OMP_CLAUSE_LINK
:
1938 case OMP_CLAUSE_USE_DEVICE_PTR
:
1939 case OMP_CLAUSE_IS_DEVICE_PTR
:
1941 decl
= OMP_CLAUSE_DECL (clause
);
1943 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1945 if (decl_function_context (decl
) == info
->context
1946 && !use_pointer_in_frame (decl
))
1948 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
1951 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_SHARED
)
1952 OMP_CLAUSE_SHARED_READONLY (clause
) = 0;
1953 bitmap_set_bit (new_suppress
, DECL_UID (decl
));
1954 OMP_CLAUSE_DECL (clause
)
1955 = get_local_debug_decl (info
, decl
, field
);
1961 case OMP_CLAUSE_SCHEDULE
:
1962 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
) == NULL
)
1965 case OMP_CLAUSE_FINAL
:
1967 case OMP_CLAUSE_NUM_THREADS
:
1968 case OMP_CLAUSE_DEPEND
:
1969 case OMP_CLAUSE_DEVICE
:
1970 case OMP_CLAUSE_NUM_TEAMS
:
1971 case OMP_CLAUSE_THREAD_LIMIT
:
1972 case OMP_CLAUSE_SAFELEN
:
1973 case OMP_CLAUSE_SIMDLEN
:
1974 case OMP_CLAUSE_PRIORITY
:
1975 case OMP_CLAUSE_GRAINSIZE
:
1976 case OMP_CLAUSE_NUM_TASKS
:
1977 case OMP_CLAUSE_HINT
:
1978 case OMP_CLAUSE_NUM_GANGS
:
1979 case OMP_CLAUSE_NUM_WORKERS
:
1980 case OMP_CLAUSE_VECTOR_LENGTH
:
1981 case OMP_CLAUSE_GANG
:
1982 case OMP_CLAUSE_WORKER
:
1983 case OMP_CLAUSE_VECTOR
:
1984 case OMP_CLAUSE_ASYNC
:
1985 case OMP_CLAUSE_WAIT
:
1986 /* Several OpenACC clauses have optional arguments. Check if they
1988 if (OMP_CLAUSE_OPERAND (clause
, 0))
1990 wi
->val_only
= true;
1992 convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
1996 /* The gang clause accepts two arguments. */
1997 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_GANG
1998 && OMP_CLAUSE_GANG_STATIC_EXPR (clause
))
2000 wi
->val_only
= true;
2002 convert_nonlocal_reference_op
2003 (&OMP_CLAUSE_GANG_STATIC_EXPR (clause
), &dummy
, wi
);
2007 case OMP_CLAUSE_DIST_SCHEDULE
:
2008 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
) != NULL
)
2010 wi
->val_only
= true;
2012 convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
2017 case OMP_CLAUSE_MAP
:
2019 case OMP_CLAUSE_FROM
:
2020 if (OMP_CLAUSE_SIZE (clause
))
2022 wi
->val_only
= true;
2024 convert_local_reference_op (&OMP_CLAUSE_SIZE (clause
),
2027 if (DECL_P (OMP_CLAUSE_DECL (clause
)))
2028 goto do_decl_clause
;
2029 wi
->val_only
= true;
2031 walk_tree (&OMP_CLAUSE_DECL (clause
), convert_local_reference_op
,
2035 case OMP_CLAUSE_ALIGNED
:
2036 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
2038 wi
->val_only
= true;
2040 convert_local_reference_op
2041 (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
), &dummy
, wi
);
2044 case OMP_CLAUSE_NONTEMPORAL
:
2045 /* Like do_decl_clause, but don't add any suppression. */
2046 decl
= OMP_CLAUSE_DECL (clause
);
2048 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
2050 if (decl_function_context (decl
) == info
->context
2051 && !use_pointer_in_frame (decl
))
2053 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
2056 OMP_CLAUSE_DECL (clause
)
2057 = get_local_debug_decl (info
, decl
, field
);
2063 case OMP_CLAUSE_NOWAIT
:
2064 case OMP_CLAUSE_ORDERED
:
2065 case OMP_CLAUSE_DEFAULT
:
2066 case OMP_CLAUSE_COPYIN
:
2067 case OMP_CLAUSE_COLLAPSE
:
2068 case OMP_CLAUSE_TILE
:
2069 case OMP_CLAUSE_UNTIED
:
2070 case OMP_CLAUSE_MERGEABLE
:
2071 case OMP_CLAUSE_PROC_BIND
:
2072 case OMP_CLAUSE_NOGROUP
:
2073 case OMP_CLAUSE_THREADS
:
2074 case OMP_CLAUSE_SIMD
:
2075 case OMP_CLAUSE_DEFAULTMAP
:
2076 case OMP_CLAUSE_SEQ
:
2077 case OMP_CLAUSE_INDEPENDENT
:
2078 case OMP_CLAUSE_AUTO
:
2079 case OMP_CLAUSE_IF_PRESENT
:
2080 case OMP_CLAUSE_FINALIZE
:
2081 case OMP_CLAUSE__CONDTEMP_
:
2082 case OMP_CLAUSE__SCANTEMP_
:
2085 /* The following clause belongs to the OpenACC cache directive, which
2086 is discarded during gimplification. */
2087 case OMP_CLAUSE__CACHE_
:
2088 /* The following clauses are only allowed in the OpenMP declare simd
2089 directive, so not seen here. */
2090 case OMP_CLAUSE_UNIFORM
:
2091 case OMP_CLAUSE_INBRANCH
:
2092 case OMP_CLAUSE_NOTINBRANCH
:
2093 /* The following clauses are only allowed on OpenMP cancel and
2094 cancellation point directives, which at this point have already
2095 been lowered into a function call. */
2096 case OMP_CLAUSE_FOR
:
2097 case OMP_CLAUSE_PARALLEL
:
2098 case OMP_CLAUSE_SECTIONS
:
2099 case OMP_CLAUSE_TASKGROUP
:
2100 /* The following clauses are only added during OMP lowering; nested
2101 function decomposition happens before that. */
2102 case OMP_CLAUSE__LOOPTEMP_
:
2103 case OMP_CLAUSE__REDUCTEMP_
:
2104 case OMP_CLAUSE__SIMDUID_
:
2105 case OMP_CLAUSE__GRIDDIM_
:
2106 case OMP_CLAUSE__SIMT_
:
2107 /* Anything else. */
2113 info
->suppress_expansion
= new_suppress
;
2116 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
2117 switch (OMP_CLAUSE_CODE (clause
))
2119 case OMP_CLAUSE_REDUCTION
:
2120 case OMP_CLAUSE_IN_REDUCTION
:
2121 case OMP_CLAUSE_TASK_REDUCTION
:
2122 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
2125 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
));
2126 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
2128 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
2129 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
2131 walk_body (convert_local_reference_stmt
,
2132 convert_local_reference_op
, info
,
2133 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause
));
2134 walk_body (convert_local_reference_stmt
,
2135 convert_local_reference_op
, info
,
2136 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause
));
2137 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
2139 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
2140 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
2145 case OMP_CLAUSE_LASTPRIVATE
:
2146 walk_body (convert_local_reference_stmt
,
2147 convert_local_reference_op
, info
,
2148 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
));
2151 case OMP_CLAUSE_LINEAR
:
2152 walk_body (convert_local_reference_stmt
,
2153 convert_local_reference_op
, info
,
2154 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
));
2165 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
2166 and PARM_DECLs that were referenced by inner nested functions.
2167 The rewrite will be a structure reference to the local frame variable. */
2170 convert_local_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2171 struct walk_stmt_info
*wi
)
2173 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
2174 tree save_local_var_chain
;
2175 bitmap save_suppress
;
2176 char save_static_chain_added
;
2177 bool frame_decl_added
;
2178 gimple
*stmt
= gsi_stmt (*gsi
);
2180 switch (gimple_code (stmt
))
2182 case GIMPLE_OMP_TEAMS
:
2183 if (!gimple_omp_teams_host (as_a
<gomp_teams
*> (stmt
)))
2185 save_suppress
= info
->suppress_expansion
;
2186 convert_local_omp_clauses (gimple_omp_teams_clauses_ptr (stmt
), wi
);
2187 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2188 info
, gimple_omp_body_ptr (stmt
));
2189 info
->suppress_expansion
= save_suppress
;
2194 case GIMPLE_OMP_PARALLEL
:
2195 case GIMPLE_OMP_TASK
:
2196 save_suppress
= info
->suppress_expansion
;
2197 frame_decl_added
= false;
2198 if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt
),
2201 tree c
= build_omp_clause (gimple_location (stmt
),
2203 (void) get_frame_type (info
);
2204 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
2205 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2206 gimple_omp_taskreg_set_clauses (stmt
, c
);
2207 info
->static_chain_added
|= 4;
2208 frame_decl_added
= true;
2211 save_local_var_chain
= info
->new_local_var_chain
;
2212 save_static_chain_added
= info
->static_chain_added
;
2213 info
->new_local_var_chain
= NULL
;
2214 info
->static_chain_added
= 0;
2216 walk_body (convert_local_reference_stmt
, convert_local_reference_op
, info
,
2217 gimple_omp_body_ptr (stmt
));
2219 if ((info
->static_chain_added
& 4) != 0 && !frame_decl_added
)
2221 tree c
= build_omp_clause (gimple_location (stmt
),
2223 (void) get_frame_type (info
);
2224 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
2225 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2226 info
->static_chain_added
|= 4;
2227 gimple_omp_taskreg_set_clauses (stmt
, c
);
2229 if (info
->new_local_var_chain
)
2230 declare_vars (info
->new_local_var_chain
,
2231 gimple_seq_first_stmt (gimple_omp_body (stmt
)), false);
2232 info
->new_local_var_chain
= save_local_var_chain
;
2233 info
->suppress_expansion
= save_suppress
;
2234 info
->static_chain_added
|= save_static_chain_added
;
2237 case GIMPLE_OMP_FOR
:
2238 save_suppress
= info
->suppress_expansion
;
2239 convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt
), wi
);
2240 walk_gimple_omp_for (as_a
<gomp_for
*> (stmt
),
2241 convert_local_reference_stmt
,
2242 convert_local_reference_op
, info
);
2243 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2244 info
, gimple_omp_body_ptr (stmt
));
2245 info
->suppress_expansion
= save_suppress
;
2248 case GIMPLE_OMP_SECTIONS
:
2249 save_suppress
= info
->suppress_expansion
;
2250 convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt
), wi
);
2251 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2252 info
, gimple_omp_body_ptr (stmt
));
2253 info
->suppress_expansion
= save_suppress
;
2256 case GIMPLE_OMP_SINGLE
:
2257 save_suppress
= info
->suppress_expansion
;
2258 convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt
), wi
);
2259 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2260 info
, gimple_omp_body_ptr (stmt
));
2261 info
->suppress_expansion
= save_suppress
;
2264 case GIMPLE_OMP_TASKGROUP
:
2265 save_suppress
= info
->suppress_expansion
;
2266 convert_local_omp_clauses (gimple_omp_taskgroup_clauses_ptr (stmt
), wi
);
2267 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2268 info
, gimple_omp_body_ptr (stmt
));
2269 info
->suppress_expansion
= save_suppress
;
2272 case GIMPLE_OMP_TARGET
:
2273 if (!is_gimple_omp_offloaded (stmt
))
2275 save_suppress
= info
->suppress_expansion
;
2276 convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt
), wi
);
2277 info
->suppress_expansion
= save_suppress
;
2278 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2279 info
, gimple_omp_body_ptr (stmt
));
2282 save_suppress
= info
->suppress_expansion
;
2283 frame_decl_added
= false;
2284 if (convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt
), wi
))
2286 tree c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
2287 (void) get_frame_type (info
);
2288 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
2289 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TOFROM
);
2290 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (info
->frame_decl
);
2291 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
2292 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
), c
);
2293 info
->static_chain_added
|= 4;
2294 frame_decl_added
= true;
2297 save_local_var_chain
= info
->new_local_var_chain
;
2298 save_static_chain_added
= info
->static_chain_added
;
2299 info
->new_local_var_chain
= NULL
;
2300 info
->static_chain_added
= 0;
2302 walk_body (convert_local_reference_stmt
, convert_local_reference_op
, info
,
2303 gimple_omp_body_ptr (stmt
));
2305 if ((info
->static_chain_added
& 4) != 0 && !frame_decl_added
)
2307 tree c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
2308 (void) get_frame_type (info
);
2309 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
2310 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TOFROM
);
2311 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (info
->frame_decl
);
2312 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
2313 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
), c
);
2314 info
->static_chain_added
|= 4;
2317 if (info
->new_local_var_chain
)
2318 declare_vars (info
->new_local_var_chain
,
2319 gimple_seq_first_stmt (gimple_omp_body (stmt
)), false);
2320 info
->new_local_var_chain
= save_local_var_chain
;
2321 info
->suppress_expansion
= save_suppress
;
2322 info
->static_chain_added
|= save_static_chain_added
;
2325 case GIMPLE_OMP_SECTION
:
2326 case GIMPLE_OMP_MASTER
:
2327 case GIMPLE_OMP_ORDERED
:
2328 case GIMPLE_OMP_SCAN
:
2329 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2330 info
, gimple_omp_body_ptr (stmt
));
2334 wi
->val_only
= true;
2336 *handled_ops_p
= false;
2340 if (gimple_clobber_p (stmt
))
2342 tree lhs
= gimple_assign_lhs (stmt
);
2344 && !use_pointer_in_frame (lhs
)
2345 && lookup_field_for_decl (info
, lhs
, NO_INSERT
))
2347 gsi_replace (gsi
, gimple_build_nop (), true);
2351 *handled_ops_p
= false;
2355 for (tree var
= gimple_bind_vars (as_a
<gbind
*> (stmt
));
2357 var
= DECL_CHAIN (var
))
2358 if (TREE_CODE (var
) == NAMELIST_DECL
)
2360 /* Adjust decls mentioned in NAMELIST_DECL. */
2361 tree decls
= NAMELIST_DECL_ASSOCIATED_DECL (var
);
2365 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls
), i
, decl
)
2368 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
2370 if (decl_function_context (decl
) == info
->context
2371 && !use_pointer_in_frame (decl
))
2373 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
2376 CONSTRUCTOR_ELT (decls
, i
)->value
2377 = get_local_debug_decl (info
, decl
, field
);
2383 *handled_ops_p
= false;
2387 /* For every other statement that we are not interested in
2388 handling here, let the walker traverse the operands. */
2389 *handled_ops_p
= false;
2393 /* Indicate that we have handled all the operands ourselves. */
2394 *handled_ops_p
= true;
2399 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_GOTOs
2400 that reference labels from outer functions. The rewrite will be a
2401 call to __builtin_nonlocal_goto. */
2404 convert_nl_goto_reference (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2405 struct walk_stmt_info
*wi
)
2407 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
, *i
;
2408 tree label
, new_label
, target_context
, x
, field
;
2410 gimple
*stmt
= gsi_stmt (*gsi
);
2412 if (gimple_code (stmt
) != GIMPLE_GOTO
)
2414 *handled_ops_p
= false;
2418 label
= gimple_goto_dest (stmt
);
2419 if (TREE_CODE (label
) != LABEL_DECL
)
2421 *handled_ops_p
= false;
2425 target_context
= decl_function_context (label
);
2426 if (target_context
== info
->context
)
2428 *handled_ops_p
= false;
2432 for (i
= info
->outer
; target_context
!= i
->context
; i
= i
->outer
)
2435 /* The original user label may also be use for a normal goto, therefore
2436 we must create a new label that will actually receive the abnormal
2437 control transfer. This new label will be marked LABEL_NONLOCAL; this
2438 mark will trigger proper behavior in the cfg, as well as cause the
2439 (hairy target-specific) non-local goto receiver code to be generated
2440 when we expand rtl. Enter this association into var_map so that we
2441 can insert the new label into the IL during a second pass. */
2442 tree
*slot
= &i
->var_map
->get_or_insert (label
);
2445 new_label
= create_artificial_label (UNKNOWN_LOCATION
);
2446 DECL_NONLOCAL (new_label
) = 1;
2452 /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field). */
2453 field
= get_nl_goto_field (i
);
2454 x
= get_frame_field (info
, target_context
, field
, gsi
);
2456 x
= gsi_gimplify_val (info
, x
, gsi
);
2457 call
= gimple_build_call (builtin_decl_implicit (BUILT_IN_NONLOCAL_GOTO
),
2458 2, build_addr (new_label
), x
);
2459 gsi_replace (gsi
, call
, false);
2461 /* We have handled all of STMT's operands, no need to keep going. */
2462 *handled_ops_p
= true;
2467 /* Called via walk_function+walk_tree, rewrite all GIMPLE_LABELs whose labels
2468 are referenced via nonlocal goto from a nested function. The rewrite
2469 will involve installing a newly generated DECL_NONLOCAL label, and
2470 (potentially) a branch around the rtl gunk that is assumed to be
2471 attached to such a label. */
2474 convert_nl_goto_receiver (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2475 struct walk_stmt_info
*wi
)
2477 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
2478 tree label
, new_label
;
2479 gimple_stmt_iterator tmp_gsi
;
2480 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (*gsi
));
2484 *handled_ops_p
= false;
2488 label
= gimple_label_label (stmt
);
2490 tree
*slot
= info
->var_map
->get (label
);
2493 *handled_ops_p
= false;
2497 /* If there's any possibility that the previous statement falls through,
2498 then we must branch around the new non-local label. */
2500 gsi_prev (&tmp_gsi
);
2501 if (gsi_end_p (tmp_gsi
) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi
)))
2503 gimple
*stmt
= gimple_build_goto (label
);
2504 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2507 new_label
= (tree
) *slot
;
2508 stmt
= gimple_build_label (new_label
);
2509 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2511 *handled_ops_p
= true;
2516 /* Called via walk_function+walk_stmt, rewrite all references to addresses
2517 of nested functions that require the use of trampolines. The rewrite
2518 will involve a reference a trampoline generated for the occasion. */
2521 convert_tramp_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
2523 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
2524 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
, *i
;
2525 tree t
= *tp
, decl
, target_context
, x
, builtin
;
2530 switch (TREE_CODE (t
))
2534 T.1 = &CHAIN->tramp;
2535 T.2 = __builtin_adjust_trampoline (T.1);
2536 T.3 = (func_type)T.2;
2539 decl
= TREE_OPERAND (t
, 0);
2540 if (TREE_CODE (decl
) != FUNCTION_DECL
)
2543 /* Only need to process nested functions. */
2544 target_context
= decl_function_context (decl
);
2545 if (!target_context
)
2548 /* If the nested function doesn't use a static chain, then
2549 it doesn't need a trampoline. */
2550 if (!DECL_STATIC_CHAIN (decl
))
2553 /* If we don't want a trampoline, then don't build one. */
2554 if (TREE_NO_TRAMPOLINE (t
))
2557 /* Lookup the immediate parent of the callee, as that's where
2558 we need to insert the trampoline. */
2559 for (i
= info
; i
->context
!= target_context
; i
= i
->outer
)
2562 /* Decide whether to generate a descriptor or a trampoline. */
2563 descr
= FUNC_ADDR_BY_DESCRIPTOR (t
) && !flag_trampolines
;
2566 x
= lookup_descr_for_decl (i
, decl
, INSERT
);
2568 x
= lookup_tramp_for_decl (i
, decl
, INSERT
);
2570 /* Compute the address of the field holding the trampoline. */
2571 x
= get_frame_field (info
, target_context
, x
, &wi
->gsi
);
2573 x
= gsi_gimplify_val (info
, x
, &wi
->gsi
);
2575 /* Do machine-specific ugliness. Normally this will involve
2576 computing extra alignment, but it can really be anything. */
2578 builtin
= builtin_decl_implicit (BUILT_IN_ADJUST_DESCRIPTOR
);
2580 builtin
= builtin_decl_implicit (BUILT_IN_ADJUST_TRAMPOLINE
);
2581 call
= gimple_build_call (builtin
, 1, x
);
2582 x
= init_tmp_var_with_call (info
, &wi
->gsi
, call
);
2584 /* Cast back to the proper function type. */
2585 x
= build1 (NOP_EXPR
, TREE_TYPE (t
), x
);
2586 x
= init_tmp_var (info
, x
, &wi
->gsi
);
2592 if (!IS_TYPE_OR_DECL_P (t
))
2601 /* Called via walk_function+walk_gimple_stmt, rewrite all references
2602 to addresses of nested functions that require the use of
2603 trampolines. The rewrite will involve a reference a trampoline
2604 generated for the occasion. */
2607 convert_tramp_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2608 struct walk_stmt_info
*wi
)
2610 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
2611 gimple
*stmt
= gsi_stmt (*gsi
);
2613 switch (gimple_code (stmt
))
2617 /* Only walk call arguments, lest we generate trampolines for
2619 unsigned long i
, nargs
= gimple_call_num_args (stmt
);
2620 for (i
= 0; i
< nargs
; i
++)
2621 walk_tree (gimple_call_arg_ptr (stmt
, i
), convert_tramp_reference_op
,
2626 case GIMPLE_OMP_TEAMS
:
2627 if (!gimple_omp_teams_host (as_a
<gomp_teams
*> (stmt
)))
2629 *handled_ops_p
= false;
2634 case GIMPLE_OMP_TARGET
:
2635 if (!is_gimple_omp_offloaded (stmt
))
2637 *handled_ops_p
= false;
2641 case GIMPLE_OMP_PARALLEL
:
2642 case GIMPLE_OMP_TASK
:
2645 tree save_local_var_chain
= info
->new_local_var_chain
;
2646 walk_gimple_op (stmt
, convert_tramp_reference_op
, wi
);
2647 info
->new_local_var_chain
= NULL
;
2648 char save_static_chain_added
= info
->static_chain_added
;
2649 info
->static_chain_added
= 0;
2650 walk_body (convert_tramp_reference_stmt
, convert_tramp_reference_op
,
2651 info
, gimple_omp_body_ptr (stmt
));
2652 if (info
->new_local_var_chain
)
2653 declare_vars (info
->new_local_var_chain
,
2654 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
2656 for (int i
= 0; i
< 2; i
++)
2659 if ((info
->static_chain_added
& (1 << i
)) == 0)
2661 decl
= i
? get_chain_decl (info
) : info
->frame_decl
;
2662 /* Don't add CHAIN.* or FRAME.* twice. */
2663 for (c
= gimple_omp_taskreg_clauses (stmt
);
2665 c
= OMP_CLAUSE_CHAIN (c
))
2666 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
2667 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
)
2668 && OMP_CLAUSE_DECL (c
) == decl
)
2670 if (c
== NULL
&& gimple_code (stmt
) != GIMPLE_OMP_TARGET
)
2672 c
= build_omp_clause (gimple_location (stmt
),
2673 i
? OMP_CLAUSE_FIRSTPRIVATE
2674 : OMP_CLAUSE_SHARED
);
2675 OMP_CLAUSE_DECL (c
) = decl
;
2676 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2677 gimple_omp_taskreg_set_clauses (stmt
, c
);
2681 c
= build_omp_clause (gimple_location (stmt
),
2683 OMP_CLAUSE_DECL (c
) = decl
;
2684 OMP_CLAUSE_SET_MAP_KIND (c
,
2685 i
? GOMP_MAP_TO
: GOMP_MAP_TOFROM
);
2686 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
2687 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
2688 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
),
2692 info
->new_local_var_chain
= save_local_var_chain
;
2693 info
->static_chain_added
|= save_static_chain_added
;
2698 *handled_ops_p
= false;
2702 *handled_ops_p
= true;
2708 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_CALLs
2709 that reference nested functions to make sure that the static chain
2710 is set up properly for the call. */
2713 convert_gimple_call (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2714 struct walk_stmt_info
*wi
)
2716 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
2717 tree decl
, target_context
;
2718 char save_static_chain_added
;
2720 gimple
*stmt
= gsi_stmt (*gsi
);
2722 switch (gimple_code (stmt
))
2725 if (gimple_call_chain (stmt
))
2727 decl
= gimple_call_fndecl (stmt
);
2730 target_context
= decl_function_context (decl
);
2731 if (target_context
&& DECL_STATIC_CHAIN (decl
))
2733 struct nesting_info
*i
= info
;
2734 while (i
&& i
->context
!= target_context
)
2736 /* If none of the outer contexts is the target context, this means
2737 that the function is called in a wrong context. */
2739 internal_error ("%s from %s called in %s",
2740 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2741 IDENTIFIER_POINTER (DECL_NAME (target_context
)),
2742 IDENTIFIER_POINTER (DECL_NAME (info
->context
)));
2744 gimple_call_set_chain (as_a
<gcall
*> (stmt
),
2745 get_static_chain (info
, target_context
,
2747 info
->static_chain_added
|= (1 << (info
->context
!= target_context
));
2751 case GIMPLE_OMP_TEAMS
:
2752 if (!gimple_omp_teams_host (as_a
<gomp_teams
*> (stmt
)))
2754 walk_body (convert_gimple_call
, NULL
, info
,
2755 gimple_omp_body_ptr (stmt
));
2760 case GIMPLE_OMP_PARALLEL
:
2761 case GIMPLE_OMP_TASK
:
2762 save_static_chain_added
= info
->static_chain_added
;
2763 info
->static_chain_added
= 0;
2764 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2765 for (i
= 0; i
< 2; i
++)
2768 if ((info
->static_chain_added
& (1 << i
)) == 0)
2770 decl
= i
? get_chain_decl (info
) : info
->frame_decl
;
2771 /* Don't add CHAIN.* or FRAME.* twice. */
2772 for (c
= gimple_omp_taskreg_clauses (stmt
);
2774 c
= OMP_CLAUSE_CHAIN (c
))
2775 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
2776 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
)
2777 && OMP_CLAUSE_DECL (c
) == decl
)
2781 c
= build_omp_clause (gimple_location (stmt
),
2782 i
? OMP_CLAUSE_FIRSTPRIVATE
2783 : OMP_CLAUSE_SHARED
);
2784 OMP_CLAUSE_DECL (c
) = decl
;
2785 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2786 gimple_omp_taskreg_set_clauses (stmt
, c
);
2789 info
->static_chain_added
|= save_static_chain_added
;
2792 case GIMPLE_OMP_TARGET
:
2793 if (!is_gimple_omp_offloaded (stmt
))
2795 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2798 save_static_chain_added
= info
->static_chain_added
;
2799 info
->static_chain_added
= 0;
2800 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2801 for (i
= 0; i
< 2; i
++)
2804 if ((info
->static_chain_added
& (1 << i
)) == 0)
2806 decl
= i
? get_chain_decl (info
) : info
->frame_decl
;
2807 /* Don't add CHAIN.* or FRAME.* twice. */
2808 for (c
= gimple_omp_target_clauses (stmt
);
2810 c
= OMP_CLAUSE_CHAIN (c
))
2811 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
2812 && OMP_CLAUSE_DECL (c
) == decl
)
2816 c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
2817 OMP_CLAUSE_DECL (c
) = decl
;
2818 OMP_CLAUSE_SET_MAP_KIND (c
, i
? GOMP_MAP_TO
: GOMP_MAP_TOFROM
);
2819 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
2820 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
2821 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
),
2825 info
->static_chain_added
|= save_static_chain_added
;
2828 case GIMPLE_OMP_FOR
:
2829 walk_body (convert_gimple_call
, NULL
, info
,
2830 gimple_omp_for_pre_body_ptr (stmt
));
2832 case GIMPLE_OMP_SECTIONS
:
2833 case GIMPLE_OMP_SECTION
:
2834 case GIMPLE_OMP_SINGLE
:
2835 case GIMPLE_OMP_MASTER
:
2836 case GIMPLE_OMP_TASKGROUP
:
2837 case GIMPLE_OMP_ORDERED
:
2838 case GIMPLE_OMP_SCAN
:
2839 case GIMPLE_OMP_CRITICAL
:
2840 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2844 /* Keep looking for other operands. */
2845 *handled_ops_p
= false;
2849 *handled_ops_p
= true;
2853 /* Walk the nesting tree starting with ROOT. Convert all trampolines and
2854 call expressions. At the same time, determine if a nested function
2855 actually uses its static chain; if not, remember that. */
2858 convert_all_function_calls (struct nesting_info
*root
)
2860 unsigned int chain_count
= 0, old_chain_count
, iter_count
;
2861 struct nesting_info
*n
;
2863 /* First, optimistically clear static_chain for all decls that haven't
2864 used the static chain already for variable access. But always create
2865 it if not optimizing. This makes it possible to reconstruct the static
2866 nesting tree at run time and thus to resolve up-level references from
2867 within the debugger. */
2868 FOR_EACH_NEST_INFO (n
, root
)
2872 tree decl
= n
->context
;
2876 (void) get_frame_type (n
);
2878 (void) get_chain_decl (n
);
2880 else if (!n
->outer
|| (!n
->chain_decl
&& !n
->chain_field
))
2882 DECL_STATIC_CHAIN (decl
) = 0;
2883 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2884 fprintf (dump_file
, "Guessing no static-chain for %s\n",
2885 lang_hooks
.decl_printable_name (decl
, 2));
2888 DECL_STATIC_CHAIN (decl
) = 1;
2889 chain_count
+= DECL_STATIC_CHAIN (decl
);
2892 FOR_EACH_NEST_INFO (n
, root
)
2895 tree decl
= n
->context
;
2896 tree alias
= cgraph_node::get (decl
)->thunk
.alias
;
2897 DECL_STATIC_CHAIN (decl
) = DECL_STATIC_CHAIN (alias
);
2900 /* Walk the functions and perform transformations. Note that these
2901 transformations can induce new uses of the static chain, which in turn
2902 require re-examining all users of the decl. */
2903 /* ??? It would make sense to try to use the call graph to speed this up,
2904 but the call graph hasn't really been built yet. Even if it did, we
2905 would still need to iterate in this loop since address-of references
2906 wouldn't show up in the callgraph anyway. */
2910 old_chain_count
= chain_count
;
2914 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2915 fputc ('\n', dump_file
);
2917 FOR_EACH_NEST_INFO (n
, root
)
2921 tree decl
= n
->context
;
2922 walk_function (convert_tramp_reference_stmt
,
2923 convert_tramp_reference_op
, n
);
2924 walk_function (convert_gimple_call
, NULL
, n
);
2925 chain_count
+= DECL_STATIC_CHAIN (decl
);
2928 FOR_EACH_NEST_INFO (n
, root
)
2931 tree decl
= n
->context
;
2932 tree alias
= cgraph_node::get (decl
)->thunk
.alias
;
2933 DECL_STATIC_CHAIN (decl
) = DECL_STATIC_CHAIN (alias
);
2936 while (chain_count
!= old_chain_count
);
2938 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2939 fprintf (dump_file
, "convert_all_function_calls iterations: %u\n\n",
2943 struct nesting_copy_body_data
2946 struct nesting_info
*root
;
2949 /* A helper subroutine for debug_var_chain type remapping. */
2952 nesting_copy_decl (tree decl
, copy_body_data
*id
)
2954 struct nesting_copy_body_data
*nid
= (struct nesting_copy_body_data
*) id
;
2955 tree
*slot
= nid
->root
->var_map
->get (decl
);
2958 return (tree
) *slot
;
2960 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (decl
))
2962 tree new_decl
= copy_decl_no_change (decl
, id
);
2963 DECL_ORIGINAL_TYPE (new_decl
)
2964 = remap_type (DECL_ORIGINAL_TYPE (decl
), id
);
2969 || TREE_CODE (decl
) == PARM_DECL
2970 || TREE_CODE (decl
) == RESULT_DECL
)
2973 return copy_decl_no_change (decl
, id
);
2976 /* A helper function for remap_vla_decls. See if *TP contains
2977 some remapped variables. */
2980 contains_remapped_vars (tree
*tp
, int *walk_subtrees
, void *data
)
2982 struct nesting_info
*root
= (struct nesting_info
*) data
;
2988 tree
*slot
= root
->var_map
->get (t
);
2996 /* Remap VLA decls in BLOCK and subblocks if remapped variables are
3000 remap_vla_decls (tree block
, struct nesting_info
*root
)
3002 tree var
, subblock
, val
, type
;
3003 struct nesting_copy_body_data id
;
3005 for (subblock
= BLOCK_SUBBLOCKS (block
);
3007 subblock
= BLOCK_CHAIN (subblock
))
3008 remap_vla_decls (subblock
, root
);
3010 for (var
= BLOCK_VARS (block
); var
; var
= DECL_CHAIN (var
))
3011 if (VAR_P (var
) && DECL_HAS_VALUE_EXPR_P (var
))
3013 val
= DECL_VALUE_EXPR (var
);
3014 type
= TREE_TYPE (var
);
3016 if (!(TREE_CODE (val
) == INDIRECT_REF
3017 && TREE_CODE (TREE_OPERAND (val
, 0)) == VAR_DECL
3018 && variably_modified_type_p (type
, NULL
)))
3021 if (root
->var_map
->get (TREE_OPERAND (val
, 0))
3022 || walk_tree (&type
, contains_remapped_vars
, root
, NULL
))
3026 if (var
== NULL_TREE
)
3029 memset (&id
, 0, sizeof (id
));
3030 id
.cb
.copy_decl
= nesting_copy_decl
;
3031 id
.cb
.decl_map
= new hash_map
<tree
, tree
>;
3034 for (; var
; var
= DECL_CHAIN (var
))
3035 if (VAR_P (var
) && DECL_HAS_VALUE_EXPR_P (var
))
3037 struct nesting_info
*i
;
3040 val
= DECL_VALUE_EXPR (var
);
3041 type
= TREE_TYPE (var
);
3043 if (!(TREE_CODE (val
) == INDIRECT_REF
3044 && TREE_CODE (TREE_OPERAND (val
, 0)) == VAR_DECL
3045 && variably_modified_type_p (type
, NULL
)))
3048 tree
*slot
= root
->var_map
->get (TREE_OPERAND (val
, 0));
3049 if (!slot
&& !walk_tree (&type
, contains_remapped_vars
, root
, NULL
))
3052 context
= decl_function_context (var
);
3053 for (i
= root
; i
; i
= i
->outer
)
3054 if (i
->context
== context
)
3060 /* Fully expand value expressions. This avoids having debug variables
3061 only referenced from them and that can be swept during GC. */
3064 tree t
= (tree
) *slot
;
3065 gcc_assert (DECL_P (t
) && DECL_HAS_VALUE_EXPR_P (t
));
3066 val
= build1 (INDIRECT_REF
, TREE_TYPE (val
), DECL_VALUE_EXPR (t
));
3069 id
.cb
.src_fn
= i
->context
;
3070 id
.cb
.dst_fn
= i
->context
;
3071 id
.cb
.src_cfun
= DECL_STRUCT_FUNCTION (root
->context
);
3073 TREE_TYPE (var
) = newt
= remap_type (type
, &id
.cb
);
3074 while (POINTER_TYPE_P (newt
) && !TYPE_NAME (newt
))
3076 newt
= TREE_TYPE (newt
);
3077 type
= TREE_TYPE (type
);
3079 if (TYPE_NAME (newt
)
3080 && TREE_CODE (TYPE_NAME (newt
)) == TYPE_DECL
3081 && DECL_ORIGINAL_TYPE (TYPE_NAME (newt
))
3083 && TYPE_NAME (newt
) == TYPE_NAME (type
))
3084 TYPE_NAME (newt
) = remap_decl (TYPE_NAME (newt
), &id
.cb
);
3086 walk_tree (&val
, copy_tree_body_r
, &id
.cb
, NULL
);
3087 if (val
!= DECL_VALUE_EXPR (var
))
3088 SET_DECL_VALUE_EXPR (var
, val
);
3091 delete id
.cb
.decl_map
;
3094 /* Fixup VLA decls in BLOCK and subblocks if remapped variables are
3098 fixup_vla_decls (tree block
)
3100 for (tree var
= BLOCK_VARS (block
); var
; var
= DECL_CHAIN (var
))
3101 if (VAR_P (var
) && DECL_HAS_VALUE_EXPR_P (var
))
3103 tree val
= DECL_VALUE_EXPR (var
);
3105 if (!(TREE_CODE (val
) == INDIRECT_REF
3106 && VAR_P (TREE_OPERAND (val
, 0))
3107 && DECL_HAS_VALUE_EXPR_P (TREE_OPERAND (val
, 0))))
3110 /* Fully expand value expressions. This avoids having debug variables
3111 only referenced from them and that can be swept during GC. */
3112 val
= build1 (INDIRECT_REF
, TREE_TYPE (val
),
3113 DECL_VALUE_EXPR (TREE_OPERAND (val
, 0)));
3114 SET_DECL_VALUE_EXPR (var
, val
);
3117 for (tree sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= BLOCK_CHAIN (sub
))
3118 fixup_vla_decls (sub
);
3121 /* Fold the MEM_REF *E. */
3123 fold_mem_refs (tree
*const &e
, void *data ATTRIBUTE_UNUSED
)
3125 tree
*ref_p
= CONST_CAST2 (tree
*, const tree
*, (const tree
*)e
);
3126 *ref_p
= fold (*ref_p
);
3130 /* Given DECL, a nested function, build an initialization call for FIELD,
3131 the trampoline or descriptor for DECL, using FUNC as the function. */
3134 build_init_call_stmt (struct nesting_info
*info
, tree decl
, tree field
,
3137 tree arg1
, arg2
, arg3
, x
;
3139 gcc_assert (DECL_STATIC_CHAIN (decl
));
3140 arg3
= build_addr (info
->frame_decl
);
3142 arg2
= build_addr (decl
);
3144 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
),
3145 info
->frame_decl
, field
, NULL_TREE
);
3146 arg1
= build_addr (x
);
3148 return gimple_build_call (func
, 3, arg1
, arg2
, arg3
);
3151 /* Do "everything else" to clean up or complete state collected by the various
3152 walking passes -- create a field to hold the frame base address, lay out the
3153 types and decls, generate code to initialize the frame decl, store critical
3154 expressions in the struct function for rtl to find. */
3157 finalize_nesting_tree_1 (struct nesting_info
*root
)
3159 gimple_seq stmt_list
= NULL
;
3161 tree context
= root
->context
;
3162 struct function
*sf
;
3167 /* If we created a non-local frame type or decl, we need to lay them
3168 out at this time. */
3169 if (root
->frame_type
)
3171 /* Debugging information needs to compute the frame base address of the
3172 parent frame out of the static chain from the nested frame.
3174 The static chain is the address of the FRAME record, so one could
3175 imagine it would be possible to compute the frame base address just
3176 adding a constant offset to this address. Unfortunately, this is not
3177 possible: if the FRAME object has alignment constraints that are
3178 stronger than the stack, then the offset between the frame base and
3179 the FRAME object will be dynamic.
3181 What we do instead is to append a field to the FRAME object that holds
3182 the frame base address: then debug info just has to fetch this
3185 /* Debugging information will refer to the CFA as the frame base
3186 address: we will do the same here. */
3187 const tree frame_addr_fndecl
3188 = builtin_decl_explicit (BUILT_IN_DWARF_CFA
);
3190 /* Create a field in the FRAME record to hold the frame base address for
3191 this stack frame. Since it will be used only by the debugger, put it
3192 at the end of the record in order not to shift all other offsets. */
3193 tree fb_decl
= make_node (FIELD_DECL
);
3195 DECL_NAME (fb_decl
) = get_identifier ("FRAME_BASE.PARENT");
3196 TREE_TYPE (fb_decl
) = ptr_type_node
;
3197 TREE_ADDRESSABLE (fb_decl
) = 1;
3198 DECL_CONTEXT (fb_decl
) = root
->frame_type
;
3199 TYPE_FIELDS (root
->frame_type
) = chainon (TYPE_FIELDS (root
->frame_type
),
3202 /* In some cases the frame type will trigger the -Wpadded warning.
3203 This is not helpful; suppress it. */
3204 int save_warn_padded
= warn_padded
;
3206 layout_type (root
->frame_type
);
3207 warn_padded
= save_warn_padded
;
3208 layout_decl (root
->frame_decl
, 0);
3210 /* Initialize the frame base address field. If the builtin we need is
3211 not available, set it to NULL so that debugging information does not
3213 tree fb_ref
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
3214 root
->frame_decl
, fb_decl
, NULL_TREE
);
3217 if (frame_addr_fndecl
!= NULL_TREE
)
3219 gcall
*fb_gimple
= gimple_build_call (frame_addr_fndecl
, 1,
3221 gimple_stmt_iterator gsi
= gsi_last (stmt_list
);
3223 fb_tmp
= init_tmp_var_with_call (root
, &gsi
, fb_gimple
);
3226 fb_tmp
= build_int_cst (TREE_TYPE (fb_ref
), 0);
3227 gimple_seq_add_stmt (&stmt_list
,
3228 gimple_build_assign (fb_ref
, fb_tmp
));
3230 declare_vars (root
->frame_decl
,
3231 gimple_seq_first_stmt (gimple_body (context
)), true);
3234 /* If any parameters were referenced non-locally, then we need to insert
3235 a copy or a pointer. */
3236 if (root
->any_parm_remapped
)
3239 for (p
= DECL_ARGUMENTS (context
); p
; p
= DECL_CHAIN (p
))
3243 field
= lookup_field_for_decl (root
, p
, NO_INSERT
);
3247 if (use_pointer_in_frame (p
))
3252 /* If the assignment is from a non-register the stmt is
3253 not valid gimple. Make it so by using a temporary instead. */
3254 if (!is_gimple_reg (x
)
3255 && is_gimple_reg_type (TREE_TYPE (x
)))
3257 gimple_stmt_iterator gsi
= gsi_last (stmt_list
);
3258 x
= init_tmp_var (root
, x
, &gsi
);
3261 y
= build3 (COMPONENT_REF
, TREE_TYPE (field
),
3262 root
->frame_decl
, field
, NULL_TREE
);
3263 stmt
= gimple_build_assign (y
, x
);
3264 gimple_seq_add_stmt (&stmt_list
, stmt
);
3268 /* If a chain_field was created, then it needs to be initialized
3270 if (root
->chain_field
)
3272 tree x
= build3 (COMPONENT_REF
, TREE_TYPE (root
->chain_field
),
3273 root
->frame_decl
, root
->chain_field
, NULL_TREE
);
3274 stmt
= gimple_build_assign (x
, get_chain_decl (root
));
3275 gimple_seq_add_stmt (&stmt_list
, stmt
);
3278 /* If trampolines were created, then we need to initialize them. */
3279 if (root
->any_tramp_created
)
3281 struct nesting_info
*i
;
3282 for (i
= root
->inner
; i
; i
= i
->next
)
3286 field
= lookup_tramp_for_decl (root
, i
->context
, NO_INSERT
);
3290 x
= builtin_decl_implicit (BUILT_IN_INIT_TRAMPOLINE
);
3291 stmt
= build_init_call_stmt (root
, i
->context
, field
, x
);
3292 gimple_seq_add_stmt (&stmt_list
, stmt
);
3296 /* If descriptors were created, then we need to initialize them. */
3297 if (root
->any_descr_created
)
3299 struct nesting_info
*i
;
3300 for (i
= root
->inner
; i
; i
= i
->next
)
3304 field
= lookup_descr_for_decl (root
, i
->context
, NO_INSERT
);
3308 x
= builtin_decl_implicit (BUILT_IN_INIT_DESCRIPTOR
);
3309 stmt
= build_init_call_stmt (root
, i
->context
, field
, x
);
3310 gimple_seq_add_stmt (&stmt_list
, stmt
);
3314 /* If we created initialization statements, insert them. */
3318 annotate_all_with_location (stmt_list
, DECL_SOURCE_LOCATION (context
));
3319 bind
= gimple_seq_first_stmt_as_a_bind (gimple_body (context
));
3320 gimple_seq_add_seq (&stmt_list
, gimple_bind_body (bind
));
3321 gimple_bind_set_body (bind
, stmt_list
);
3324 /* If a chain_decl was created, then it needs to be registered with
3325 struct function so that it gets initialized from the static chain
3326 register at the beginning of the function. */
3327 sf
= DECL_STRUCT_FUNCTION (root
->context
);
3328 sf
->static_chain_decl
= root
->chain_decl
;
3330 /* Similarly for the non-local goto save area. */
3331 if (root
->nl_goto_field
)
3333 sf
->nonlocal_goto_save_area
3334 = get_frame_field (root
, context
, root
->nl_goto_field
, NULL
);
3335 sf
->has_nonlocal_label
= 1;
3338 /* Make sure all new local variables get inserted into the
3339 proper BIND_EXPR. */
3340 if (root
->new_local_var_chain
)
3341 declare_vars (root
->new_local_var_chain
,
3342 gimple_seq_first_stmt (gimple_body (root
->context
)),
3345 if (root
->debug_var_chain
)
3350 remap_vla_decls (DECL_INITIAL (root
->context
), root
);
3352 for (debug_var
= root
->debug_var_chain
; debug_var
;
3353 debug_var
= DECL_CHAIN (debug_var
))
3354 if (variably_modified_type_p (TREE_TYPE (debug_var
), NULL
))
3357 /* If there are any debug decls with variable length types,
3358 remap those types using other debug_var_chain variables. */
3361 struct nesting_copy_body_data id
;
3363 memset (&id
, 0, sizeof (id
));
3364 id
.cb
.copy_decl
= nesting_copy_decl
;
3365 id
.cb
.decl_map
= new hash_map
<tree
, tree
>;
3368 for (; debug_var
; debug_var
= DECL_CHAIN (debug_var
))
3369 if (variably_modified_type_p (TREE_TYPE (debug_var
), NULL
))
3371 tree type
= TREE_TYPE (debug_var
);
3372 tree newt
, t
= type
;
3373 struct nesting_info
*i
;
3375 for (i
= root
; i
; i
= i
->outer
)
3376 if (variably_modified_type_p (type
, i
->context
))
3382 id
.cb
.src_fn
= i
->context
;
3383 id
.cb
.dst_fn
= i
->context
;
3384 id
.cb
.src_cfun
= DECL_STRUCT_FUNCTION (root
->context
);
3386 TREE_TYPE (debug_var
) = newt
= remap_type (type
, &id
.cb
);
3387 while (POINTER_TYPE_P (newt
) && !TYPE_NAME (newt
))
3389 newt
= TREE_TYPE (newt
);
3392 if (TYPE_NAME (newt
)
3393 && TREE_CODE (TYPE_NAME (newt
)) == TYPE_DECL
3394 && DECL_ORIGINAL_TYPE (TYPE_NAME (newt
))
3396 && TYPE_NAME (newt
) == TYPE_NAME (t
))
3397 TYPE_NAME (newt
) = remap_decl (TYPE_NAME (newt
), &id
.cb
);
3400 delete id
.cb
.decl_map
;
3403 scope
= gimple_seq_first_stmt_as_a_bind (gimple_body (root
->context
));
3404 if (gimple_bind_block (scope
))
3405 declare_vars (root
->debug_var_chain
, scope
, true);
3407 BLOCK_VARS (DECL_INITIAL (root
->context
))
3408 = chainon (BLOCK_VARS (DECL_INITIAL (root
->context
)),
3409 root
->debug_var_chain
);
3412 fixup_vla_decls (DECL_INITIAL (root
->context
));
3414 /* Fold the rewritten MEM_REF trees. */
3415 root
->mem_refs
->traverse
<void *, fold_mem_refs
> (NULL
);
3417 /* Dump the translated tree function. */
3420 fputs ("\n\n", dump_file
);
3421 dump_function_to_file (root
->context
, dump_file
, dump_flags
);
3426 finalize_nesting_tree (struct nesting_info
*root
)
3428 struct nesting_info
*n
;
3429 FOR_EACH_NEST_INFO (n
, root
)
3430 finalize_nesting_tree_1 (n
);
3433 /* Unnest the nodes and pass them to cgraph. */
3436 unnest_nesting_tree_1 (struct nesting_info
*root
)
3438 struct cgraph_node
*node
= cgraph_node::get (root
->context
);
3440 /* For nested functions update the cgraph to reflect unnesting.
3441 We also delay finalizing of these functions up to this point. */
3446 cgraph_node::finalize_function (root
->context
, true);
3451 unnest_nesting_tree (struct nesting_info
*root
)
3453 struct nesting_info
*n
;
3454 FOR_EACH_NEST_INFO (n
, root
)
3455 unnest_nesting_tree_1 (n
);
3458 /* Free the data structures allocated during this pass. */
3461 free_nesting_tree (struct nesting_info
*root
)
3463 struct nesting_info
*node
, *next
;
3465 node
= iter_nestinfo_start (root
);
3468 next
= iter_nestinfo_next (node
);
3469 delete node
->var_map
;
3470 delete node
->field_map
;
3471 delete node
->mem_refs
;
3478 /* Gimplify a function and all its nested functions. */
3480 gimplify_all_functions (struct cgraph_node
*root
)
3482 struct cgraph_node
*iter
;
3483 if (!gimple_body (root
->decl
))
3484 gimplify_function_tree (root
->decl
);
3485 for (iter
= root
->nested
; iter
; iter
= iter
->next_nested
)
3486 if (!iter
->thunk
.thunk_p
)
3487 gimplify_all_functions (iter
);
3490 /* Main entry point for this pass. Process FNDECL and all of its nested
3491 subroutines and turn them into something less tightly bound. */
3494 lower_nested_functions (tree fndecl
)
3496 struct cgraph_node
*cgn
;
3497 struct nesting_info
*root
;
3499 /* If there are no nested functions, there's nothing to do. */
3500 cgn
= cgraph_node::get (fndecl
);
3504 gimplify_all_functions (cgn
);
3506 set_dump_file (dump_begin (TDI_nested
, &dump_flags
));
3508 fprintf (dump_file
, "\n;; Function %s\n\n",
3509 lang_hooks
.decl_printable_name (fndecl
, 2));
3511 bitmap_obstack_initialize (&nesting_info_bitmap_obstack
);
3512 root
= create_nesting_tree (cgn
);
3514 walk_all_functions (convert_nonlocal_reference_stmt
,
3515 convert_nonlocal_reference_op
,
3517 walk_all_functions (convert_local_reference_stmt
,
3518 convert_local_reference_op
,
3520 walk_all_functions (convert_nl_goto_reference
, NULL
, root
);
3521 walk_all_functions (convert_nl_goto_receiver
, NULL
, root
);
3523 convert_all_function_calls (root
);
3524 finalize_nesting_tree (root
);
3525 unnest_nesting_tree (root
);
3527 free_nesting_tree (root
);
3528 bitmap_obstack_release (&nesting_info_bitmap_obstack
);
3532 dump_end (TDI_nested
, dump_file
);
3533 set_dump_file (NULL
);
3537 #include "gt-tree-nested.h"