1 /* Nested function decomposition for GIMPLE.
2 Copyright (C) 2004-2021 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"
45 #include "alloc-pool.h"
46 #include "tree-nested.h"
47 #include "symbol-summary.h"
48 #include "symtab-thunks.h"
50 /* Summary of nested functions. */
51 static function_summary
<nested_function_info
*>
52 *nested_function_sum
= NULL
;
54 /* Return nested_function_info, if available. */
55 nested_function_info
*
56 nested_function_info::get (cgraph_node
*node
)
58 if (!nested_function_sum
)
60 return nested_function_sum
->get (node
);
63 /* Return nested_function_info possibly creating new one. */
64 nested_function_info
*
65 nested_function_info::get_create (cgraph_node
*node
)
67 if (!nested_function_sum
)
69 nested_function_sum
= new function_summary
<nested_function_info
*>
71 nested_function_sum
->disable_insertion_hook ();
73 return nested_function_sum
->get_create (node
);
76 /* cgraph_node is no longer nested function; update cgraph accordingly. */
78 unnest_function (cgraph_node
*node
)
80 nested_function_info
*info
= nested_function_info::get (node
);
81 cgraph_node
**node2
= &nested_function_info::get
82 (nested_function_origin (node
))->nested
;
84 gcc_checking_assert (info
->origin
);
85 while (*node2
!= node
)
86 node2
= &nested_function_info::get (*node2
)->next_nested
;
87 *node2
= info
->next_nested
;
88 info
->next_nested
= NULL
;
90 nested_function_sum
->remove (node
);
93 /* Destructor: unlink function from nested function lists. */
94 nested_function_info::~nested_function_info ()
97 for (cgraph_node
*n
= nested
; n
; n
= next
)
99 nested_function_info
*info
= nested_function_info::get (n
);
100 next
= info
->next_nested
;
102 info
->next_nested
= NULL
;
108 = &nested_function_info::get (origin
)->nested
;
110 nested_function_info
*info
;
111 while ((info
= nested_function_info::get (*node2
)) != this && info
)
112 node2
= &info
->next_nested
;
113 *node2
= next_nested
;
117 /* Free nested function info summaries. */
119 nested_function_info::release ()
121 if (nested_function_sum
)
122 delete (nested_function_sum
);
123 nested_function_sum
= NULL
;
126 /* If NODE is nested function, record it. */
128 maybe_record_nested_function (cgraph_node
*node
)
130 /* All nested functions gets lowered during the construction of symtab. */
131 if (symtab
->state
> CONSTRUCTION
)
133 if (DECL_CONTEXT (node
->decl
)
134 && TREE_CODE (DECL_CONTEXT (node
->decl
)) == FUNCTION_DECL
)
136 cgraph_node
*origin
= cgraph_node::get_create (DECL_CONTEXT (node
->decl
));
137 nested_function_info
*info
= nested_function_info::get_create (node
);
138 nested_function_info
*origin_info
139 = nested_function_info::get_create (origin
);
141 info
->origin
= origin
;
142 info
->next_nested
= origin_info
->nested
;
143 origin_info
->nested
= node
;
147 /* The object of this pass is to lower the representation of a set of nested
148 functions in order to expose all of the gory details of the various
149 nonlocal references. We want to do this sooner rather than later, in
150 order to give us more freedom in emitting all of the functions in question.
152 Back in olden times, when gcc was young, we developed an insanely
153 complicated scheme whereby variables which were referenced nonlocally
154 were forced to live in the stack of the declaring function, and then
155 the nested functions magically discovered where these variables were
156 placed. In order for this scheme to function properly, it required
157 that the outer function be partially expanded, then we switch to
158 compiling the inner function, and once done with those we switch back
159 to compiling the outer function. Such delicate ordering requirements
160 makes it difficult to do whole translation unit optimizations
161 involving such functions.
163 The implementation here is much more direct. Everything that can be
164 referenced by an inner function is a member of an explicitly created
165 structure herein called the "nonlocal frame struct". The incoming
166 static chain for a nested function is a pointer to this struct in
167 the parent. In this way, we settle on known offsets from a known
168 base, and so are decoupled from the logic that places objects in the
169 function's stack frame. More importantly, we don't have to wait for
170 that to happen -- since the compilation of the inner function is no
171 longer tied to a real stack frame, the nonlocal frame struct can be
172 allocated anywhere. Which means that the outer function is now
175 Theory of operation here is very simple. Iterate over all the
176 statements in all the functions (depth first) several times,
177 allocating structures and fields on demand. In general we want to
178 examine inner functions first, so that we can avoid making changes
179 to outer functions which are unnecessary.
181 The order of the passes matters a bit, in that later passes will be
182 skipped if it is discovered that the functions don't actually interact
183 at all. That is, they're nested in the lexical sense but could have
184 been written as independent functions without change. */
189 struct nesting_info
*outer
;
190 struct nesting_info
*inner
;
191 struct nesting_info
*next
;
193 hash_map
<tree
, tree
> *field_map
;
194 hash_map
<tree
, tree
> *var_map
;
195 hash_set
<tree
*> *mem_refs
;
196 bitmap suppress_expansion
;
199 tree new_local_var_chain
;
200 tree debug_var_chain
;
208 bool any_parm_remapped
;
209 bool any_tramp_created
;
210 bool any_descr_created
;
211 char static_chain_added
;
215 /* Iterate over the nesting tree, starting with ROOT, depth first. */
217 static inline struct nesting_info
*
218 iter_nestinfo_start (struct nesting_info
*root
)
225 static inline struct nesting_info
*
226 iter_nestinfo_next (struct nesting_info
*node
)
229 return iter_nestinfo_start (node
->next
);
233 #define FOR_EACH_NEST_INFO(I, ROOT) \
234 for ((I) = iter_nestinfo_start (ROOT); (I); (I) = iter_nestinfo_next (I))
236 /* Obstack used for the bitmaps in the struct above. */
237 static struct bitmap_obstack nesting_info_bitmap_obstack
;
240 /* We're working in so many different function contexts simultaneously,
241 that create_tmp_var is dangerous. Prevent mishap. */
242 #define create_tmp_var cant_use_create_tmp_var_here_dummy
244 /* Like create_tmp_var, except record the variable for registration at
245 the given nesting level. */
248 create_tmp_var_for (struct nesting_info
*info
, tree type
, const char *prefix
)
252 /* If the type is of variable size or a type which must be created by the
253 frontend, something is wrong. Note that we explicitly allow
254 incomplete types here, since we create them ourselves here. */
255 gcc_assert (!TREE_ADDRESSABLE (type
));
256 gcc_assert (!TYPE_SIZE_UNIT (type
)
257 || TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
);
259 tmp_var
= create_tmp_var_raw (type
, prefix
);
260 DECL_CONTEXT (tmp_var
) = info
->context
;
261 DECL_CHAIN (tmp_var
) = info
->new_local_var_chain
;
262 DECL_SEEN_IN_BIND_EXPR_P (tmp_var
) = 1;
264 info
->new_local_var_chain
= tmp_var
;
269 /* Like build_simple_mem_ref, but set TREE_THIS_NOTRAP on the result. */
272 build_simple_mem_ref_notrap (tree ptr
)
274 tree t
= build_simple_mem_ref (ptr
);
275 TREE_THIS_NOTRAP (t
) = 1;
279 /* Take the address of EXP to be used within function CONTEXT.
280 Mark it for addressability as necessary. */
283 build_addr (tree exp
)
285 mark_addressable (exp
);
286 return build_fold_addr_expr (exp
);
289 /* Insert FIELD into TYPE, sorted by alignment requirements. */
292 insert_field_into_struct (tree type
, tree field
)
296 DECL_CONTEXT (field
) = type
;
298 for (p
= &TYPE_FIELDS (type
); *p
; p
= &DECL_CHAIN (*p
))
299 if (DECL_ALIGN (field
) >= DECL_ALIGN (*p
))
302 DECL_CHAIN (field
) = *p
;
305 /* Set correct alignment for frame struct type. */
306 if (TYPE_ALIGN (type
) < DECL_ALIGN (field
))
307 SET_TYPE_ALIGN (type
, DECL_ALIGN (field
));
310 /* Build or return the RECORD_TYPE that describes the frame state that is
311 shared between INFO->CONTEXT and its nested functions. This record will
312 not be complete until finalize_nesting_tree; up until that point we'll
313 be adding fields as necessary.
315 We also build the DECL that represents this frame in the function. */
318 get_frame_type (struct nesting_info
*info
)
320 tree type
= info
->frame_type
;
325 type
= make_node (RECORD_TYPE
);
327 name
= concat ("FRAME.",
328 IDENTIFIER_POINTER (DECL_NAME (info
->context
)),
330 TYPE_NAME (type
) = get_identifier (name
);
333 info
->frame_type
= type
;
335 /* Do not put info->frame_decl on info->new_local_var_chain,
336 so that we can declare it in the lexical blocks, which
337 makes sure virtual regs that end up appearing in its RTL
338 expression get substituted in instantiate_virtual_regs. */
339 info
->frame_decl
= create_tmp_var_raw (type
, "FRAME");
340 DECL_CONTEXT (info
->frame_decl
) = info
->context
;
341 DECL_NONLOCAL_FRAME (info
->frame_decl
) = 1;
342 DECL_SEEN_IN_BIND_EXPR_P (info
->frame_decl
) = 1;
344 /* ??? Always make it addressable for now, since it is meant to
345 be pointed to by the static chain pointer. This pessimizes
346 when it turns out that no static chains are needed because
347 the nested functions referencing non-local variables are not
348 reachable, but the true pessimization is to create the non-
349 local frame structure in the first place. */
350 TREE_ADDRESSABLE (info
->frame_decl
) = 1;
356 /* Return true if DECL should be referenced by pointer in the non-local frame
360 use_pointer_in_frame (tree decl
)
362 if (TREE_CODE (decl
) == PARM_DECL
)
364 /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable-
365 sized DECLs, and inefficient to copy large aggregates. Don't bother
366 moving anything but scalar parameters. */
367 return AGGREGATE_TYPE_P (TREE_TYPE (decl
));
371 /* Variable-sized DECLs can only come from OMP clauses at this point
372 since the gimplifier has already turned the regular variables into
373 pointers. Do the same as the gimplifier. */
374 return !DECL_SIZE (decl
) || TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
;
378 /* Given DECL, a non-locally accessed variable, find or create a field
379 in the non-local frame structure for the given nesting context. */
382 lookup_field_for_decl (struct nesting_info
*info
, tree decl
,
383 enum insert_option insert
)
385 gcc_checking_assert (decl_function_context (decl
) == info
->context
);
387 if (insert
== NO_INSERT
)
389 tree
*slot
= info
->field_map
->get (decl
);
390 return slot
? *slot
: NULL_TREE
;
393 tree
*slot
= &info
->field_map
->get_or_insert (decl
);
396 tree type
= get_frame_type (info
);
397 tree field
= make_node (FIELD_DECL
);
398 DECL_NAME (field
) = DECL_NAME (decl
);
400 if (use_pointer_in_frame (decl
))
402 TREE_TYPE (field
) = build_pointer_type (TREE_TYPE (decl
));
403 SET_DECL_ALIGN (field
, TYPE_ALIGN (TREE_TYPE (field
)));
404 DECL_NONADDRESSABLE_P (field
) = 1;
408 TREE_TYPE (field
) = TREE_TYPE (decl
);
409 DECL_SOURCE_LOCATION (field
) = DECL_SOURCE_LOCATION (decl
);
410 SET_DECL_ALIGN (field
, DECL_ALIGN (decl
));
411 DECL_USER_ALIGN (field
) = DECL_USER_ALIGN (decl
);
412 DECL_IGNORED_P (field
) = DECL_IGNORED_P (decl
);
413 DECL_NONADDRESSABLE_P (field
) = !TREE_ADDRESSABLE (decl
);
414 TREE_THIS_VOLATILE (field
) = TREE_THIS_VOLATILE (decl
);
415 copy_warning (field
, decl
);
417 /* Declare the transformation and adjust the original DECL. For a
418 variable or for a parameter when not optimizing, we make it point
419 to the field in the frame directly. For a parameter, we don't do
420 it when optimizing because the variable tracking pass will already
422 if (VAR_P (decl
) || !optimize
)
425 = build3 (COMPONENT_REF
, TREE_TYPE (field
), info
->frame_decl
,
428 /* If the next declaration is a PARM_DECL pointing to the DECL,
429 we need to adjust its VALUE_EXPR directly, since chains of
430 VALUE_EXPRs run afoul of garbage collection. This occurs
431 in Ada for Out parameters that aren't copied in. */
432 tree next
= DECL_CHAIN (decl
);
434 && TREE_CODE (next
) == PARM_DECL
435 && DECL_HAS_VALUE_EXPR_P (next
)
436 && DECL_VALUE_EXPR (next
) == decl
)
437 SET_DECL_VALUE_EXPR (next
, x
);
439 SET_DECL_VALUE_EXPR (decl
, x
);
440 DECL_HAS_VALUE_EXPR_P (decl
) = 1;
444 insert_field_into_struct (type
, field
);
447 if (TREE_CODE (decl
) == PARM_DECL
)
448 info
->any_parm_remapped
= true;
454 /* Build or return the variable that holds the static chain within
455 INFO->CONTEXT. This variable may only be used within INFO->CONTEXT. */
458 get_chain_decl (struct nesting_info
*info
)
460 tree decl
= info
->chain_decl
;
466 type
= get_frame_type (info
->outer
);
467 type
= build_pointer_type (type
);
469 /* Note that this variable is *not* entered into any BIND_EXPR;
470 the construction of this variable is handled specially in
471 expand_function_start and initialize_inlined_parameters.
472 Note also that it's represented as a parameter. This is more
473 close to the truth, since the initial value does come from
475 decl
= build_decl (DECL_SOURCE_LOCATION (info
->context
),
476 PARM_DECL
, create_tmp_var_name ("CHAIN"), type
);
477 DECL_ARTIFICIAL (decl
) = 1;
478 DECL_IGNORED_P (decl
) = 1;
479 TREE_USED (decl
) = 1;
480 DECL_CONTEXT (decl
) = info
->context
;
481 DECL_ARG_TYPE (decl
) = type
;
483 /* Tell tree-inline.c that we never write to this variable, so
484 it can copy-prop the replacement value immediately. */
485 TREE_READONLY (decl
) = 1;
487 info
->chain_decl
= decl
;
490 && (dump_flags
& TDF_DETAILS
)
491 && !DECL_STATIC_CHAIN (info
->context
))
492 fprintf (dump_file
, "Setting static-chain for %s\n",
493 lang_hooks
.decl_printable_name (info
->context
, 2));
495 DECL_STATIC_CHAIN (info
->context
) = 1;
500 /* Build or return the field within the non-local frame state that holds
501 the static chain for INFO->CONTEXT. This is the way to walk back up
502 multiple nesting levels. */
505 get_chain_field (struct nesting_info
*info
)
507 tree field
= info
->chain_field
;
511 tree type
= build_pointer_type (get_frame_type (info
->outer
));
513 field
= make_node (FIELD_DECL
);
514 DECL_NAME (field
) = get_identifier ("__chain");
515 TREE_TYPE (field
) = type
;
516 SET_DECL_ALIGN (field
, TYPE_ALIGN (type
));
517 DECL_NONADDRESSABLE_P (field
) = 1;
519 insert_field_into_struct (get_frame_type (info
), field
);
521 info
->chain_field
= field
;
524 && (dump_flags
& TDF_DETAILS
)
525 && !DECL_STATIC_CHAIN (info
->context
))
526 fprintf (dump_file
, "Setting static-chain for %s\n",
527 lang_hooks
.decl_printable_name (info
->context
, 2));
529 DECL_STATIC_CHAIN (info
->context
) = 1;
534 /* Initialize a new temporary with the GIMPLE_CALL STMT. */
537 init_tmp_var_with_call (struct nesting_info
*info
, gimple_stmt_iterator
*gsi
,
542 t
= create_tmp_var_for (info
, gimple_call_return_type (call
), NULL
);
543 gimple_call_set_lhs (call
, t
);
544 if (! gsi_end_p (*gsi
))
545 gimple_set_location (call
, gimple_location (gsi_stmt (*gsi
)));
546 gsi_insert_before (gsi
, call
, GSI_SAME_STMT
);
552 /* Copy EXP into a temporary. Allocate the temporary in the context of
553 INFO and insert the initialization statement before GSI. */
556 init_tmp_var (struct nesting_info
*info
, tree exp
, gimple_stmt_iterator
*gsi
)
561 t
= create_tmp_var_for (info
, TREE_TYPE (exp
), NULL
);
562 stmt
= gimple_build_assign (t
, exp
);
563 if (! gsi_end_p (*gsi
))
564 gimple_set_location (stmt
, gimple_location (gsi_stmt (*gsi
)));
565 gsi_insert_before_without_update (gsi
, stmt
, GSI_SAME_STMT
);
571 /* Similarly, but only do so to force EXP to satisfy is_gimple_val. */
574 gsi_gimplify_val (struct nesting_info
*info
, tree exp
,
575 gimple_stmt_iterator
*gsi
)
577 if (is_gimple_val (exp
))
580 return init_tmp_var (info
, exp
, gsi
);
583 /* Similarly, but copy from the temporary and insert the statement
584 after the iterator. */
587 save_tmp_var (struct nesting_info
*info
, tree exp
, gimple_stmt_iterator
*gsi
)
592 t
= create_tmp_var_for (info
, TREE_TYPE (exp
), NULL
);
593 stmt
= gimple_build_assign (exp
, t
);
594 if (! gsi_end_p (*gsi
))
595 gimple_set_location (stmt
, gimple_location (gsi_stmt (*gsi
)));
596 gsi_insert_after_without_update (gsi
, stmt
, GSI_SAME_STMT
);
601 /* Build or return the type used to represent a nested function trampoline. */
603 static GTY(()) tree trampoline_type
;
606 get_trampoline_type (struct nesting_info
*info
)
608 unsigned align
, size
;
612 return trampoline_type
;
614 align
= TRAMPOLINE_ALIGNMENT
;
615 size
= TRAMPOLINE_SIZE
;
617 /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
618 then allocate extra space so that we can do dynamic alignment. */
619 if (align
> STACK_BOUNDARY
)
621 size
+= ((align
/BITS_PER_UNIT
) - 1) & -(STACK_BOUNDARY
/BITS_PER_UNIT
);
622 align
= STACK_BOUNDARY
;
625 t
= build_index_type (size_int (size
- 1));
626 t
= build_array_type (char_type_node
, t
);
627 t
= build_decl (DECL_SOURCE_LOCATION (info
->context
),
628 FIELD_DECL
, get_identifier ("__data"), t
);
629 SET_DECL_ALIGN (t
, align
);
630 DECL_USER_ALIGN (t
) = 1;
632 trampoline_type
= make_node (RECORD_TYPE
);
633 TYPE_NAME (trampoline_type
) = get_identifier ("__builtin_trampoline");
634 TYPE_FIELDS (trampoline_type
) = t
;
635 layout_type (trampoline_type
);
636 DECL_CONTEXT (t
) = trampoline_type
;
638 return trampoline_type
;
641 /* Build or return the type used to represent a nested function descriptor. */
643 static GTY(()) tree descriptor_type
;
646 get_descriptor_type (struct nesting_info
*info
)
648 /* The base alignment is that of a function. */
649 const unsigned align
= FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY
);
653 return descriptor_type
;
655 t
= build_index_type (integer_one_node
);
656 t
= build_array_type (ptr_type_node
, t
);
657 t
= build_decl (DECL_SOURCE_LOCATION (info
->context
),
658 FIELD_DECL
, get_identifier ("__data"), t
);
659 SET_DECL_ALIGN (t
, MAX (TYPE_ALIGN (ptr_type_node
), align
));
660 DECL_USER_ALIGN (t
) = 1;
662 descriptor_type
= make_node (RECORD_TYPE
);
663 TYPE_NAME (descriptor_type
) = get_identifier ("__builtin_descriptor");
664 TYPE_FIELDS (descriptor_type
) = t
;
665 layout_type (descriptor_type
);
666 DECL_CONTEXT (t
) = descriptor_type
;
668 return descriptor_type
;
671 /* Given DECL, a nested function, find or create an element in the
672 var map for this function. */
675 lookup_element_for_decl (struct nesting_info
*info
, tree decl
,
676 enum insert_option insert
)
678 if (insert
== NO_INSERT
)
680 tree
*slot
= info
->var_map
->get (decl
);
681 return slot
? *slot
: NULL_TREE
;
684 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
686 *slot
= build_tree_list (NULL_TREE
, NULL_TREE
);
691 /* Given DECL, a nested function, create a field in the non-local
692 frame structure for this function. */
695 create_field_for_decl (struct nesting_info
*info
, tree decl
, tree type
)
697 tree field
= make_node (FIELD_DECL
);
698 DECL_NAME (field
) = DECL_NAME (decl
);
699 TREE_TYPE (field
) = type
;
700 TREE_ADDRESSABLE (field
) = 1;
701 insert_field_into_struct (get_frame_type (info
), field
);
705 /* Given DECL, a nested function, find or create a field in the non-local
706 frame structure for a trampoline for this function. */
709 lookup_tramp_for_decl (struct nesting_info
*info
, tree decl
,
710 enum insert_option insert
)
714 elt
= lookup_element_for_decl (info
, decl
, insert
);
718 field
= TREE_PURPOSE (elt
);
720 if (!field
&& insert
== INSERT
)
722 field
= create_field_for_decl (info
, decl
, get_trampoline_type (info
));
723 TREE_PURPOSE (elt
) = field
;
724 info
->any_tramp_created
= true;
730 /* Given DECL, a nested function, find or create a field in the non-local
731 frame structure for a descriptor for this function. */
734 lookup_descr_for_decl (struct nesting_info
*info
, tree decl
,
735 enum insert_option insert
)
739 elt
= lookup_element_for_decl (info
, decl
, insert
);
743 field
= TREE_VALUE (elt
);
745 if (!field
&& insert
== INSERT
)
747 field
= create_field_for_decl (info
, decl
, get_descriptor_type (info
));
748 TREE_VALUE (elt
) = field
;
749 info
->any_descr_created
= true;
755 /* Build or return the field within the non-local frame state that holds
756 the non-local goto "jmp_buf". The buffer itself is maintained by the
757 rtl middle-end as dynamic stack space is allocated. */
760 get_nl_goto_field (struct nesting_info
*info
)
762 tree field
= info
->nl_goto_field
;
768 /* For __builtin_nonlocal_goto, we need N words. The first is the
769 frame pointer, the rest is for the target's stack pointer save
770 area. The number of words is controlled by STACK_SAVEAREA_MODE;
771 not the best interface, but it'll do for now. */
772 if (Pmode
== ptr_mode
)
773 type
= ptr_type_node
;
775 type
= lang_hooks
.types
.type_for_mode (Pmode
, 1);
778 = as_a
<scalar_int_mode
> (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
));
779 size
= GET_MODE_SIZE (mode
);
780 size
= size
/ GET_MODE_SIZE (Pmode
);
783 type
= build_array_type
784 (type
, build_index_type (size_int (size
)));
786 field
= make_node (FIELD_DECL
);
787 DECL_NAME (field
) = get_identifier ("__nl_goto_buf");
788 TREE_TYPE (field
) = type
;
789 SET_DECL_ALIGN (field
, TYPE_ALIGN (type
));
790 TREE_ADDRESSABLE (field
) = 1;
792 insert_field_into_struct (get_frame_type (info
), field
);
794 info
->nl_goto_field
= field
;
800 /* Invoke CALLBACK on all statements of GIMPLE sequence *PSEQ. */
803 walk_body (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
804 struct nesting_info
*info
, gimple_seq
*pseq
)
806 struct walk_stmt_info wi
;
808 memset (&wi
, 0, sizeof (wi
));
811 walk_gimple_seq_mod (pseq
, callback_stmt
, callback_op
, &wi
);
815 /* Invoke CALLBACK_STMT/CALLBACK_OP on all statements of INFO->CONTEXT. */
818 walk_function (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
819 struct nesting_info
*info
)
821 gimple_seq body
= gimple_body (info
->context
);
822 walk_body (callback_stmt
, callback_op
, info
, &body
);
823 gimple_set_body (info
->context
, body
);
826 /* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body. */
829 walk_gimple_omp_for (gomp_for
*for_stmt
,
830 walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
831 struct nesting_info
*info
)
833 struct walk_stmt_info wi
;
838 walk_body (callback_stmt
, callback_op
, info
, gimple_omp_for_pre_body_ptr (for_stmt
));
841 memset (&wi
, 0, sizeof (wi
));
843 wi
.gsi
= gsi_last (seq
);
845 for (i
= 0; i
< gimple_omp_for_collapse (for_stmt
); i
++)
848 walk_tree (gimple_omp_for_index_ptr (for_stmt
, i
), callback_op
,
852 walk_tree (gimple_omp_for_initial_ptr (for_stmt
, i
), callback_op
,
857 walk_tree (gimple_omp_for_final_ptr (for_stmt
, i
), callback_op
,
860 t
= gimple_omp_for_incr (for_stmt
, i
);
861 gcc_assert (BINARY_CLASS_P (t
));
863 walk_tree (&TREE_OPERAND (t
, 0), callback_op
, &wi
, NULL
);
866 walk_tree (&TREE_OPERAND (t
, 1), callback_op
, &wi
, NULL
);
869 seq
= gsi_seq (wi
.gsi
);
870 if (!gimple_seq_empty_p (seq
))
872 gimple_seq pre_body
= gimple_omp_for_pre_body (for_stmt
);
873 annotate_all_with_location (seq
, gimple_location (for_stmt
));
874 gimple_seq_add_seq (&pre_body
, seq
);
875 gimple_omp_for_set_pre_body (for_stmt
, pre_body
);
879 /* Similarly for ROOT and all functions nested underneath, depth first. */
882 walk_all_functions (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
883 struct nesting_info
*root
)
885 struct nesting_info
*n
;
886 FOR_EACH_NEST_INFO (n
, root
)
887 walk_function (callback_stmt
, callback_op
, n
);
891 /* We have to check for a fairly pathological case. The operands of function
892 nested function are to be interpreted in the context of the enclosing
893 function. So if any are variably-sized, they will get remapped when the
894 enclosing function is inlined. But that remapping would also have to be
895 done in the types of the PARM_DECLs of the nested function, meaning the
896 argument types of that function will disagree with the arguments in the
897 calls to that function. So we'd either have to make a copy of the nested
898 function corresponding to each time the enclosing function was inlined or
899 add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
900 function. The former is not practical. The latter would still require
901 detecting this case to know when to add the conversions. So, for now at
902 least, we don't inline such an enclosing function.
904 We have to do that check recursively, so here return indicating whether
905 FNDECL has such a nested function. ORIG_FN is the function we were
906 trying to inline to use for checking whether any argument is variably
907 modified by anything in it.
909 It would be better to do this in tree-inline.c so that we could give
910 the appropriate warning for why a function can't be inlined, but that's
911 too late since the nesting structure has already been flattened and
912 adding a flag just to record this fact seems a waste of a flag. */
915 check_for_nested_with_variably_modified (tree fndecl
, tree orig_fndecl
)
917 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
920 for (cgn
= first_nested_function (cgn
); cgn
;
921 cgn
= next_nested_function (cgn
))
923 for (arg
= DECL_ARGUMENTS (cgn
->decl
); arg
; arg
= DECL_CHAIN (arg
))
924 if (variably_modified_type_p (TREE_TYPE (arg
), orig_fndecl
))
927 if (check_for_nested_with_variably_modified (cgn
->decl
,
935 /* Construct our local datastructure describing the function nesting
936 tree rooted by CGN. */
938 static struct nesting_info
*
939 create_nesting_tree (struct cgraph_node
*cgn
)
941 struct nesting_info
*info
= XCNEW (struct nesting_info
);
942 info
->field_map
= new hash_map
<tree
, tree
>;
943 info
->var_map
= new hash_map
<tree
, tree
>;
944 info
->mem_refs
= new hash_set
<tree
*>;
945 info
->suppress_expansion
= BITMAP_ALLOC (&nesting_info_bitmap_obstack
);
946 info
->context
= cgn
->decl
;
947 info
->thunk_p
= cgn
->thunk
;
949 for (cgn
= first_nested_function (cgn
); cgn
;
950 cgn
= next_nested_function (cgn
))
952 struct nesting_info
*sub
= create_nesting_tree (cgn
);
954 sub
->next
= info
->inner
;
958 /* See discussion at check_for_nested_with_variably_modified for a
959 discussion of why this has to be here. */
960 if (check_for_nested_with_variably_modified (info
->context
, info
->context
))
961 DECL_UNINLINABLE (info
->context
) = true;
966 /* Return an expression computing the static chain for TARGET_CONTEXT
967 from INFO->CONTEXT. Insert any necessary computations before TSI. */
970 get_static_chain (struct nesting_info
*info
, tree target_context
,
971 gimple_stmt_iterator
*gsi
)
973 struct nesting_info
*i
;
976 if (info
->context
== target_context
)
978 x
= build_addr (info
->frame_decl
);
979 info
->static_chain_added
|= 1;
983 x
= get_chain_decl (info
);
984 info
->static_chain_added
|= 2;
986 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
988 tree field
= get_chain_field (i
);
990 x
= build_simple_mem_ref_notrap (x
);
991 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
992 x
= init_tmp_var (info
, x
, gsi
);
1000 /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
1001 frame as seen from INFO->CONTEXT. Insert any necessary computations
1005 get_frame_field (struct nesting_info
*info
, tree target_context
,
1006 tree field
, gimple_stmt_iterator
*gsi
)
1008 struct nesting_info
*i
;
1011 if (info
->context
== target_context
)
1013 /* Make sure frame_decl gets created. */
1014 (void) get_frame_type (info
);
1015 x
= info
->frame_decl
;
1016 info
->static_chain_added
|= 1;
1020 x
= get_chain_decl (info
);
1021 info
->static_chain_added
|= 2;
1023 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
1025 tree field
= get_chain_field (i
);
1027 x
= build_simple_mem_ref_notrap (x
);
1028 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
1029 x
= init_tmp_var (info
, x
, gsi
);
1032 x
= build_simple_mem_ref_notrap (x
);
1035 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
1036 TREE_THIS_VOLATILE (x
) = TREE_THIS_VOLATILE (field
);
1040 static void note_nonlocal_vla_type (struct nesting_info
*info
, tree type
);
1042 /* A subroutine of convert_nonlocal_reference_op. Create a local variable
1043 in the nested function with DECL_VALUE_EXPR set to reference the true
1044 variable in the parent function. This is used both for debug info
1045 and in OMP lowering. */
1048 get_nonlocal_debug_decl (struct nesting_info
*info
, tree decl
)
1050 tree target_context
;
1051 struct nesting_info
*i
;
1052 tree x
, field
, new_decl
;
1054 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
1059 target_context
= decl_function_context (decl
);
1061 /* A copy of the code in get_frame_field, but without the temporaries. */
1062 if (info
->context
== target_context
)
1064 /* Make sure frame_decl gets created. */
1065 (void) get_frame_type (info
);
1066 x
= info
->frame_decl
;
1068 info
->static_chain_added
|= 1;
1072 x
= get_chain_decl (info
);
1073 info
->static_chain_added
|= 2;
1074 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
1076 field
= get_chain_field (i
);
1077 x
= build_simple_mem_ref_notrap (x
);
1078 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
1080 x
= build_simple_mem_ref_notrap (x
);
1083 field
= lookup_field_for_decl (i
, decl
, INSERT
);
1084 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
1085 if (use_pointer_in_frame (decl
))
1086 x
= build_simple_mem_ref_notrap (x
);
1088 /* ??? We should be remapping types as well, surely. */
1089 new_decl
= build_decl (DECL_SOURCE_LOCATION (decl
),
1090 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
1091 DECL_CONTEXT (new_decl
) = info
->context
;
1092 DECL_ARTIFICIAL (new_decl
) = DECL_ARTIFICIAL (decl
);
1093 DECL_IGNORED_P (new_decl
) = DECL_IGNORED_P (decl
);
1094 TREE_THIS_VOLATILE (new_decl
) = TREE_THIS_VOLATILE (decl
);
1095 TREE_SIDE_EFFECTS (new_decl
) = TREE_SIDE_EFFECTS (decl
);
1096 TREE_READONLY (new_decl
) = TREE_READONLY (decl
);
1097 TREE_ADDRESSABLE (new_decl
) = TREE_ADDRESSABLE (decl
);
1098 DECL_SEEN_IN_BIND_EXPR_P (new_decl
) = 1;
1099 if ((TREE_CODE (decl
) == PARM_DECL
1100 || TREE_CODE (decl
) == RESULT_DECL
1102 && DECL_BY_REFERENCE (decl
))
1103 DECL_BY_REFERENCE (new_decl
) = 1;
1105 SET_DECL_VALUE_EXPR (new_decl
, x
);
1106 DECL_HAS_VALUE_EXPR_P (new_decl
) = 1;
1109 DECL_CHAIN (new_decl
) = info
->debug_var_chain
;
1110 info
->debug_var_chain
= new_decl
;
1113 && info
->context
!= target_context
1114 && variably_modified_type_p (TREE_TYPE (decl
), NULL
))
1115 note_nonlocal_vla_type (info
, TREE_TYPE (decl
));
1121 /* Callback for walk_gimple_stmt, rewrite all references to VAR
1122 and PARM_DECLs that belong to outer functions.
1124 The rewrite will involve some number of structure accesses back up
1125 the static chain. E.g. for a variable FOO up one nesting level it'll
1126 be CHAIN->FOO. For two levels it'll be CHAIN->__chain->FOO. Further
1127 indirections apply to decls for which use_pointer_in_frame is true. */
1130 convert_nonlocal_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
1132 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
1133 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1137 switch (TREE_CODE (t
))
1140 /* Non-automatic variables are never processed. */
1141 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
1147 tree x
, target_context
= decl_function_context (t
);
1149 if (info
->context
== target_context
)
1154 if (bitmap_bit_p (info
->suppress_expansion
, DECL_UID (t
)))
1155 x
= get_nonlocal_debug_decl (info
, t
);
1158 struct nesting_info
*i
= info
;
1159 while (i
&& i
->context
!= target_context
)
1161 /* If none of the outer contexts is the target context, this means
1162 that the VAR or PARM_DECL is referenced in a wrong context. */
1164 internal_error ("%s from %s referenced in %s",
1165 IDENTIFIER_POINTER (DECL_NAME (t
)),
1166 IDENTIFIER_POINTER (DECL_NAME (target_context
)),
1167 IDENTIFIER_POINTER (DECL_NAME (info
->context
)));
1169 x
= lookup_field_for_decl (i
, t
, INSERT
);
1170 x
= get_frame_field (info
, target_context
, x
, &wi
->gsi
);
1171 if (use_pointer_in_frame (t
))
1173 x
= init_tmp_var (info
, x
, &wi
->gsi
);
1174 x
= build_simple_mem_ref_notrap (x
);
1181 x
= save_tmp_var (info
, x
, &wi
->gsi
);
1183 x
= init_tmp_var (info
, x
, &wi
->gsi
);
1191 /* We're taking the address of a label from a parent function, but
1192 this is not itself a non-local goto. Mark the label such that it
1193 will not be deleted, much as we would with a label address in
1195 if (decl_function_context (t
) != info
->context
)
1196 FORCED_LABEL (t
) = 1;
1201 bool save_val_only
= wi
->val_only
;
1203 wi
->val_only
= false;
1205 wi
->changed
= false;
1206 walk_tree (&TREE_OPERAND (t
, 0), convert_nonlocal_reference_op
, wi
, 0);
1207 wi
->val_only
= true;
1213 /* If we changed anything, we might no longer be directly
1214 referencing a decl. */
1215 save_context
= current_function_decl
;
1216 current_function_decl
= info
->context
;
1217 recompute_tree_invariant_for_addr_expr (t
);
1219 /* If the callback converted the address argument in a context
1220 where we only accept variables (and min_invariant, presumably),
1221 then compute the address into a temporary. */
1223 *tp
= gsi_gimplify_val ((struct nesting_info
*) wi
->info
,
1225 current_function_decl
= save_context
;
1234 case ARRAY_RANGE_REF
:
1236 /* Go down this entire nest and just look at the final prefix and
1237 anything that describes the references. Otherwise, we lose track
1238 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1239 wi
->val_only
= true;
1241 for (; handled_component_p (t
); tp
= &TREE_OPERAND (t
, 0), t
= *tp
)
1243 if (TREE_CODE (t
) == COMPONENT_REF
)
1244 walk_tree (&TREE_OPERAND (t
, 2), convert_nonlocal_reference_op
, wi
,
1246 else if (TREE_CODE (t
) == ARRAY_REF
1247 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
1249 walk_tree (&TREE_OPERAND (t
, 1), convert_nonlocal_reference_op
,
1251 walk_tree (&TREE_OPERAND (t
, 2), convert_nonlocal_reference_op
,
1253 walk_tree (&TREE_OPERAND (t
, 3), convert_nonlocal_reference_op
,
1257 wi
->val_only
= false;
1258 walk_tree (tp
, convert_nonlocal_reference_op
, wi
, NULL
);
1261 case VIEW_CONVERT_EXPR
:
1262 /* Just request to look at the subtrees, leaving val_only and lhs
1263 untouched. This might actually be for !val_only + lhs, in which
1264 case we don't want to force a replacement by a temporary. */
1269 if (!IS_TYPE_OR_DECL_P (t
))
1272 wi
->val_only
= true;
1281 static tree
convert_nonlocal_reference_stmt (gimple_stmt_iterator
*, bool *,
1282 struct walk_stmt_info
*);
1284 /* Helper for convert_nonlocal_references, rewrite all references to VAR
1285 and PARM_DECLs that belong to outer functions. */
1288 convert_nonlocal_omp_clauses (tree
*pclauses
, struct walk_stmt_info
*wi
)
1290 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1291 bool need_chain
= false, need_stmts
= false;
1292 tree clause
, decl
, *pdecl
;
1294 bitmap new_suppress
;
1296 new_suppress
= BITMAP_GGC_ALLOC ();
1297 bitmap_copy (new_suppress
, info
->suppress_expansion
);
1299 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1302 switch (OMP_CLAUSE_CODE (clause
))
1304 case OMP_CLAUSE_REDUCTION
:
1305 case OMP_CLAUSE_IN_REDUCTION
:
1306 case OMP_CLAUSE_TASK_REDUCTION
:
1307 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1309 if (TREE_CODE (OMP_CLAUSE_DECL (clause
)) == MEM_REF
)
1311 pdecl
= &TREE_OPERAND (OMP_CLAUSE_DECL (clause
), 0);
1312 if (TREE_CODE (*pdecl
) == POINTER_PLUS_EXPR
)
1313 pdecl
= &TREE_OPERAND (*pdecl
, 0);
1314 if (TREE_CODE (*pdecl
) == INDIRECT_REF
1315 || TREE_CODE (*pdecl
) == ADDR_EXPR
)
1316 pdecl
= &TREE_OPERAND (*pdecl
, 0);
1318 goto do_decl_clause
;
1320 case OMP_CLAUSE_LASTPRIVATE
:
1321 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
))
1323 goto do_decl_clause
;
1325 case OMP_CLAUSE_LINEAR
:
1326 if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
))
1328 wi
->val_only
= true;
1330 convert_nonlocal_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause
),
1332 goto do_decl_clause
;
1334 case OMP_CLAUSE_PRIVATE
:
1335 case OMP_CLAUSE_FIRSTPRIVATE
:
1336 case OMP_CLAUSE_COPYPRIVATE
:
1337 case OMP_CLAUSE_SHARED
:
1338 case OMP_CLAUSE_TO_DECLARE
:
1339 case OMP_CLAUSE_LINK
:
1340 case OMP_CLAUSE_USE_DEVICE_PTR
:
1341 case OMP_CLAUSE_USE_DEVICE_ADDR
:
1342 case OMP_CLAUSE_IS_DEVICE_PTR
:
1343 case OMP_CLAUSE_DETACH
:
1346 pdecl
= &OMP_CLAUSE_DECL (clause
);
1349 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1351 if (decl_function_context (decl
) != info
->context
)
1353 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_SHARED
)
1354 OMP_CLAUSE_SHARED_READONLY (clause
) = 0;
1355 bitmap_set_bit (new_suppress
, DECL_UID (decl
));
1356 *pdecl
= get_nonlocal_debug_decl (info
, decl
);
1357 if (OMP_CLAUSE_CODE (clause
) != OMP_CLAUSE_PRIVATE
)
1362 case OMP_CLAUSE_SCHEDULE
:
1363 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
) == NULL
)
1366 case OMP_CLAUSE_FINAL
:
1368 case OMP_CLAUSE_NUM_THREADS
:
1369 case OMP_CLAUSE_DEPEND
:
1370 case OMP_CLAUSE_DEVICE
:
1371 case OMP_CLAUSE_NUM_TEAMS
:
1372 case OMP_CLAUSE_THREAD_LIMIT
:
1373 case OMP_CLAUSE_SAFELEN
:
1374 case OMP_CLAUSE_SIMDLEN
:
1375 case OMP_CLAUSE_PRIORITY
:
1376 case OMP_CLAUSE_GRAINSIZE
:
1377 case OMP_CLAUSE_NUM_TASKS
:
1378 case OMP_CLAUSE_HINT
:
1379 case OMP_CLAUSE_NUM_GANGS
:
1380 case OMP_CLAUSE_NUM_WORKERS
:
1381 case OMP_CLAUSE_VECTOR_LENGTH
:
1382 case OMP_CLAUSE_GANG
:
1383 case OMP_CLAUSE_WORKER
:
1384 case OMP_CLAUSE_VECTOR
:
1385 case OMP_CLAUSE_ASYNC
:
1386 case OMP_CLAUSE_WAIT
:
1387 /* Several OpenACC clauses have optional arguments. Check if they
1389 if (OMP_CLAUSE_OPERAND (clause
, 0))
1391 wi
->val_only
= true;
1393 convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
1397 /* The gang clause accepts two arguments. */
1398 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_GANG
1399 && OMP_CLAUSE_GANG_STATIC_EXPR (clause
))
1401 wi
->val_only
= true;
1403 convert_nonlocal_reference_op
1404 (&OMP_CLAUSE_GANG_STATIC_EXPR (clause
), &dummy
, wi
);
1408 case OMP_CLAUSE_DIST_SCHEDULE
:
1409 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
) != NULL
)
1411 wi
->val_only
= true;
1413 convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
1418 case OMP_CLAUSE_MAP
:
1420 case OMP_CLAUSE_FROM
:
1421 if (OMP_CLAUSE_SIZE (clause
))
1423 wi
->val_only
= true;
1425 convert_nonlocal_reference_op (&OMP_CLAUSE_SIZE (clause
),
1428 if (DECL_P (OMP_CLAUSE_DECL (clause
)))
1429 goto do_decl_clause
;
1430 wi
->val_only
= true;
1432 walk_tree (&OMP_CLAUSE_DECL (clause
), convert_nonlocal_reference_op
,
1436 case OMP_CLAUSE_ALIGNED
:
1437 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
1439 wi
->val_only
= true;
1441 convert_nonlocal_reference_op
1442 (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
), &dummy
, wi
);
1445 case OMP_CLAUSE_NONTEMPORAL
:
1446 do_decl_clause_no_supp
:
1447 /* Like do_decl_clause, but don't add any suppression. */
1448 decl
= OMP_CLAUSE_DECL (clause
);
1450 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1452 if (decl_function_context (decl
) != info
->context
)
1454 OMP_CLAUSE_DECL (clause
) = get_nonlocal_debug_decl (info
, decl
);
1459 case OMP_CLAUSE_ALLOCATE
:
1460 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
))
1462 wi
->val_only
= true;
1464 convert_nonlocal_reference_op
1465 (&OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
), &dummy
, wi
);
1467 goto do_decl_clause_no_supp
;
1469 case OMP_CLAUSE_NOWAIT
:
1470 case OMP_CLAUSE_ORDERED
:
1471 case OMP_CLAUSE_DEFAULT
:
1472 case OMP_CLAUSE_COPYIN
:
1473 case OMP_CLAUSE_COLLAPSE
:
1474 case OMP_CLAUSE_TILE
:
1475 case OMP_CLAUSE_UNTIED
:
1476 case OMP_CLAUSE_MERGEABLE
:
1477 case OMP_CLAUSE_PROC_BIND
:
1478 case OMP_CLAUSE_NOGROUP
:
1479 case OMP_CLAUSE_THREADS
:
1480 case OMP_CLAUSE_SIMD
:
1481 case OMP_CLAUSE_DEFAULTMAP
:
1482 case OMP_CLAUSE_ORDER
:
1483 case OMP_CLAUSE_SEQ
:
1484 case OMP_CLAUSE_INDEPENDENT
:
1485 case OMP_CLAUSE_AUTO
:
1486 case OMP_CLAUSE_IF_PRESENT
:
1487 case OMP_CLAUSE_FINALIZE
:
1488 case OMP_CLAUSE_BIND
:
1489 case OMP_CLAUSE__CONDTEMP_
:
1490 case OMP_CLAUSE__SCANTEMP_
:
1493 /* The following clause belongs to the OpenACC cache directive, which
1494 is discarded during gimplification. */
1495 case OMP_CLAUSE__CACHE_
:
1496 /* The following clauses are only allowed in the OpenMP declare simd
1497 directive, so not seen here. */
1498 case OMP_CLAUSE_UNIFORM
:
1499 case OMP_CLAUSE_INBRANCH
:
1500 case OMP_CLAUSE_NOTINBRANCH
:
1501 /* The following clauses are only allowed on OpenMP cancel and
1502 cancellation point directives, which at this point have already
1503 been lowered into a function call. */
1504 case OMP_CLAUSE_FOR
:
1505 case OMP_CLAUSE_PARALLEL
:
1506 case OMP_CLAUSE_SECTIONS
:
1507 case OMP_CLAUSE_TASKGROUP
:
1508 /* The following clauses are only added during OMP lowering; nested
1509 function decomposition happens before that. */
1510 case OMP_CLAUSE__LOOPTEMP_
:
1511 case OMP_CLAUSE__REDUCTEMP_
:
1512 case OMP_CLAUSE__SIMDUID_
:
1513 case OMP_CLAUSE__SIMT_
:
1514 /* The following clauses are only allowed on OpenACC 'routine'
1515 directives, not seen here. */
1516 case OMP_CLAUSE_NOHOST
:
1517 /* Anything else. */
1523 info
->suppress_expansion
= new_suppress
;
1526 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1527 switch (OMP_CLAUSE_CODE (clause
))
1529 case OMP_CLAUSE_REDUCTION
:
1530 case OMP_CLAUSE_IN_REDUCTION
:
1531 case OMP_CLAUSE_TASK_REDUCTION
:
1532 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1535 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
));
1536 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1538 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
1539 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
1541 tree save_local_var_chain
= info
->new_local_var_chain
;
1542 info
->new_local_var_chain
= NULL
;
1543 gimple_seq
*seq
= &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause
);
1544 walk_body (convert_nonlocal_reference_stmt
,
1545 convert_nonlocal_reference_op
, info
, seq
);
1546 if (info
->new_local_var_chain
)
1547 declare_vars (info
->new_local_var_chain
,
1548 gimple_seq_first_stmt (*seq
), false);
1549 info
->new_local_var_chain
= NULL
;
1550 seq
= &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause
);
1551 walk_body (convert_nonlocal_reference_stmt
,
1552 convert_nonlocal_reference_op
, info
, seq
);
1553 if (info
->new_local_var_chain
)
1554 declare_vars (info
->new_local_var_chain
,
1555 gimple_seq_first_stmt (*seq
), false);
1556 info
->new_local_var_chain
= save_local_var_chain
;
1557 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1559 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
1560 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
1565 case OMP_CLAUSE_LASTPRIVATE
:
1567 tree save_local_var_chain
= info
->new_local_var_chain
;
1568 info
->new_local_var_chain
= NULL
;
1569 gimple_seq
*seq
= &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
);
1570 walk_body (convert_nonlocal_reference_stmt
,
1571 convert_nonlocal_reference_op
, info
, seq
);
1572 if (info
->new_local_var_chain
)
1573 declare_vars (info
->new_local_var_chain
,
1574 gimple_seq_first_stmt (*seq
), false);
1575 info
->new_local_var_chain
= save_local_var_chain
;
1579 case OMP_CLAUSE_LINEAR
:
1581 tree save_local_var_chain
= info
->new_local_var_chain
;
1582 info
->new_local_var_chain
= NULL
;
1583 gimple_seq
*seq
= &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
);
1584 walk_body (convert_nonlocal_reference_stmt
,
1585 convert_nonlocal_reference_op
, info
, seq
);
1586 if (info
->new_local_var_chain
)
1587 declare_vars (info
->new_local_var_chain
,
1588 gimple_seq_first_stmt (*seq
), false);
1589 info
->new_local_var_chain
= save_local_var_chain
;
1600 /* Create nonlocal debug decls for nonlocal VLA array bounds. */
1603 note_nonlocal_vla_type (struct nesting_info
*info
, tree type
)
1605 while (POINTER_TYPE_P (type
) && !TYPE_NAME (type
))
1606 type
= TREE_TYPE (type
);
1608 if (TYPE_NAME (type
)
1609 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1610 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1611 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1613 while (POINTER_TYPE_P (type
)
1614 || TREE_CODE (type
) == VECTOR_TYPE
1615 || TREE_CODE (type
) == FUNCTION_TYPE
1616 || TREE_CODE (type
) == METHOD_TYPE
)
1617 type
= TREE_TYPE (type
);
1619 if (TREE_CODE (type
) == ARRAY_TYPE
)
1623 note_nonlocal_vla_type (info
, TREE_TYPE (type
));
1624 domain
= TYPE_DOMAIN (type
);
1627 t
= TYPE_MIN_VALUE (domain
);
1628 if (t
&& (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
1629 && decl_function_context (t
) != info
->context
)
1630 get_nonlocal_debug_decl (info
, t
);
1631 t
= TYPE_MAX_VALUE (domain
);
1632 if (t
&& (VAR_P (t
) || TREE_CODE (t
) == PARM_DECL
)
1633 && decl_function_context (t
) != info
->context
)
1634 get_nonlocal_debug_decl (info
, t
);
1639 /* Callback for walk_gimple_stmt. Rewrite all references to VAR and
1640 PARM_DECLs that belong to outer functions. This handles statements
1641 that are not handled via the standard recursion done in
1642 walk_gimple_stmt. STMT is the statement to examine, DATA is as in
1643 convert_nonlocal_reference_op. Set *HANDLED_OPS_P to true if all the
1644 operands of STMT have been handled by this function. */
1647 convert_nonlocal_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
1648 struct walk_stmt_info
*wi
)
1650 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
1651 tree save_local_var_chain
;
1652 bitmap save_suppress
;
1653 gimple
*stmt
= gsi_stmt (*gsi
);
1655 switch (gimple_code (stmt
))
1658 /* Don't walk non-local gotos for now. */
1659 if (TREE_CODE (gimple_goto_dest (stmt
)) != LABEL_DECL
)
1661 wi
->val_only
= true;
1663 *handled_ops_p
= false;
1668 case GIMPLE_OMP_TEAMS
:
1669 if (!gimple_omp_teams_host (as_a
<gomp_teams
*> (stmt
)))
1671 save_suppress
= info
->suppress_expansion
;
1672 convert_nonlocal_omp_clauses (gimple_omp_teams_clauses_ptr (stmt
),
1674 walk_body (convert_nonlocal_reference_stmt
,
1675 convert_nonlocal_reference_op
, info
,
1676 gimple_omp_body_ptr (stmt
));
1677 info
->suppress_expansion
= save_suppress
;
1682 case GIMPLE_OMP_PARALLEL
:
1683 case GIMPLE_OMP_TASK
:
1684 save_suppress
= info
->suppress_expansion
;
1685 if (convert_nonlocal_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt
),
1689 decl
= get_chain_decl (info
);
1690 c
= build_omp_clause (gimple_location (stmt
),
1691 OMP_CLAUSE_FIRSTPRIVATE
);
1692 OMP_CLAUSE_DECL (c
) = decl
;
1693 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
1694 gimple_omp_taskreg_set_clauses (stmt
, c
);
1697 save_local_var_chain
= info
->new_local_var_chain
;
1698 info
->new_local_var_chain
= NULL
;
1700 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1701 info
, gimple_omp_body_ptr (stmt
));
1703 if (info
->new_local_var_chain
)
1704 declare_vars (info
->new_local_var_chain
,
1705 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
1707 info
->new_local_var_chain
= save_local_var_chain
;
1708 info
->suppress_expansion
= save_suppress
;
1711 case GIMPLE_OMP_FOR
:
1712 save_suppress
= info
->suppress_expansion
;
1713 convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt
), wi
);
1714 walk_gimple_omp_for (as_a
<gomp_for
*> (stmt
),
1715 convert_nonlocal_reference_stmt
,
1716 convert_nonlocal_reference_op
, info
);
1717 walk_body (convert_nonlocal_reference_stmt
,
1718 convert_nonlocal_reference_op
, info
, gimple_omp_body_ptr (stmt
));
1719 info
->suppress_expansion
= save_suppress
;
1722 case GIMPLE_OMP_SECTIONS
:
1723 save_suppress
= info
->suppress_expansion
;
1724 convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt
), wi
);
1725 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1726 info
, gimple_omp_body_ptr (stmt
));
1727 info
->suppress_expansion
= save_suppress
;
1730 case GIMPLE_OMP_SINGLE
:
1731 save_suppress
= info
->suppress_expansion
;
1732 convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt
), wi
);
1733 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1734 info
, gimple_omp_body_ptr (stmt
));
1735 info
->suppress_expansion
= save_suppress
;
1738 case GIMPLE_OMP_TASKGROUP
:
1739 save_suppress
= info
->suppress_expansion
;
1740 convert_nonlocal_omp_clauses (gimple_omp_taskgroup_clauses_ptr (stmt
), wi
);
1741 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1742 info
, gimple_omp_body_ptr (stmt
));
1743 info
->suppress_expansion
= save_suppress
;
1746 case GIMPLE_OMP_TARGET
:
1747 if (!is_gimple_omp_offloaded (stmt
))
1749 save_suppress
= info
->suppress_expansion
;
1750 convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt
),
1752 info
->suppress_expansion
= save_suppress
;
1753 walk_body (convert_nonlocal_reference_stmt
,
1754 convert_nonlocal_reference_op
, info
,
1755 gimple_omp_body_ptr (stmt
));
1758 save_suppress
= info
->suppress_expansion
;
1759 if (convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt
),
1763 decl
= get_chain_decl (info
);
1764 c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
1765 OMP_CLAUSE_DECL (c
) = decl
;
1766 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TO
);
1767 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
1768 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
1769 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
), c
);
1772 save_local_var_chain
= info
->new_local_var_chain
;
1773 info
->new_local_var_chain
= NULL
;
1775 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1776 info
, gimple_omp_body_ptr (stmt
));
1778 if (info
->new_local_var_chain
)
1779 declare_vars (info
->new_local_var_chain
,
1780 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
1782 info
->new_local_var_chain
= save_local_var_chain
;
1783 info
->suppress_expansion
= save_suppress
;
1786 case GIMPLE_OMP_SECTION
:
1787 case GIMPLE_OMP_MASTER
:
1788 case GIMPLE_OMP_ORDERED
:
1789 case GIMPLE_OMP_SCAN
:
1790 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1791 info
, gimple_omp_body_ptr (stmt
));
1796 gbind
*bind_stmt
= as_a
<gbind
*> (stmt
);
1798 for (tree var
= gimple_bind_vars (bind_stmt
); var
; var
= DECL_CHAIN (var
))
1799 if (TREE_CODE (var
) == NAMELIST_DECL
)
1801 /* Adjust decls mentioned in NAMELIST_DECL. */
1802 tree decls
= NAMELIST_DECL_ASSOCIATED_DECL (var
);
1806 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls
), i
, decl
)
1809 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1811 if (decl_function_context (decl
) != info
->context
)
1812 CONSTRUCTOR_ELT (decls
, i
)->value
1813 = get_nonlocal_debug_decl (info
, decl
);
1817 *handled_ops_p
= false;
1821 wi
->val_only
= true;
1823 *handled_ops_p
= false;
1827 if (gimple_clobber_p (stmt
))
1829 tree lhs
= gimple_assign_lhs (stmt
);
1831 && !(TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
1832 && decl_function_context (lhs
) != info
->context
)
1834 gsi_replace (gsi
, gimple_build_nop (), true);
1838 *handled_ops_p
= false;
1842 /* For every other statement that we are not interested in
1843 handling here, let the walker traverse the operands. */
1844 *handled_ops_p
= false;
1848 /* We have handled all of STMT operands, no need to traverse the operands. */
1849 *handled_ops_p
= true;
1854 /* A subroutine of convert_local_reference. Create a local variable
1855 in the parent function with DECL_VALUE_EXPR set to reference the
1856 field in FRAME. This is used both for debug info and in OMP
1860 get_local_debug_decl (struct nesting_info
*info
, tree decl
, tree field
)
1864 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
1868 /* Make sure frame_decl gets created. */
1869 (void) get_frame_type (info
);
1870 x
= info
->frame_decl
;
1871 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
1873 new_decl
= build_decl (DECL_SOURCE_LOCATION (decl
),
1874 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
1875 DECL_CONTEXT (new_decl
) = info
->context
;
1876 DECL_ARTIFICIAL (new_decl
) = DECL_ARTIFICIAL (decl
);
1877 DECL_IGNORED_P (new_decl
) = DECL_IGNORED_P (decl
);
1878 TREE_THIS_VOLATILE (new_decl
) = TREE_THIS_VOLATILE (decl
);
1879 TREE_SIDE_EFFECTS (new_decl
) = TREE_SIDE_EFFECTS (decl
);
1880 TREE_READONLY (new_decl
) = TREE_READONLY (decl
);
1881 TREE_ADDRESSABLE (new_decl
) = TREE_ADDRESSABLE (decl
);
1882 DECL_SEEN_IN_BIND_EXPR_P (new_decl
) = 1;
1883 if ((TREE_CODE (decl
) == PARM_DECL
1884 || TREE_CODE (decl
) == RESULT_DECL
1886 && DECL_BY_REFERENCE (decl
))
1887 DECL_BY_REFERENCE (new_decl
) = 1;
1889 SET_DECL_VALUE_EXPR (new_decl
, x
);
1890 DECL_HAS_VALUE_EXPR_P (new_decl
) = 1;
1893 DECL_CHAIN (new_decl
) = info
->debug_var_chain
;
1894 info
->debug_var_chain
= new_decl
;
1896 /* Do not emit debug info twice. */
1897 DECL_IGNORED_P (decl
) = 1;
1903 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1904 and PARM_DECLs that were referenced by inner nested functions.
1905 The rewrite will be a structure reference to the local frame variable. */
1907 static bool convert_local_omp_clauses (tree
*, struct walk_stmt_info
*);
1910 convert_local_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
1912 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
1913 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1914 tree t
= *tp
, field
, x
;
1918 switch (TREE_CODE (t
))
1921 /* Non-automatic variables are never processed. */
1922 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
1927 if (t
!= info
->frame_decl
&& decl_function_context (t
) == info
->context
)
1929 /* If we copied a pointer to the frame, then the original decl
1930 is used unchanged in the parent function. */
1931 if (use_pointer_in_frame (t
))
1934 /* No need to transform anything if no child references the
1936 field
= lookup_field_for_decl (info
, t
, NO_INSERT
);
1941 if (bitmap_bit_p (info
->suppress_expansion
, DECL_UID (t
)))
1942 x
= get_local_debug_decl (info
, t
, field
);
1944 x
= get_frame_field (info
, info
->context
, field
, &wi
->gsi
);
1949 x
= save_tmp_var (info
, x
, &wi
->gsi
);
1951 x
= init_tmp_var (info
, x
, &wi
->gsi
);
1959 save_val_only
= wi
->val_only
;
1960 wi
->val_only
= false;
1962 wi
->changed
= false;
1963 walk_tree (&TREE_OPERAND (t
, 0), convert_local_reference_op
, wi
, NULL
);
1964 wi
->val_only
= save_val_only
;
1966 /* If we converted anything ... */
1971 /* Then the frame decl is now addressable. */
1972 TREE_ADDRESSABLE (info
->frame_decl
) = 1;
1974 save_context
= current_function_decl
;
1975 current_function_decl
= info
->context
;
1976 recompute_tree_invariant_for_addr_expr (t
);
1978 /* If we are in a context where we only accept values, then
1979 compute the address into a temporary. */
1981 *tp
= gsi_gimplify_val ((struct nesting_info
*) wi
->info
,
1983 current_function_decl
= save_context
;
1991 case ARRAY_RANGE_REF
:
1993 /* Go down this entire nest and just look at the final prefix and
1994 anything that describes the references. Otherwise, we lose track
1995 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1996 save_val_only
= wi
->val_only
;
1997 wi
->val_only
= true;
1999 for (; handled_component_p (t
); tp
= &TREE_OPERAND (t
, 0), t
= *tp
)
2001 if (TREE_CODE (t
) == COMPONENT_REF
)
2002 walk_tree (&TREE_OPERAND (t
, 2), convert_local_reference_op
, wi
,
2004 else if (TREE_CODE (t
) == ARRAY_REF
2005 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
2007 walk_tree (&TREE_OPERAND (t
, 1), convert_local_reference_op
, wi
,
2009 walk_tree (&TREE_OPERAND (t
, 2), convert_local_reference_op
, wi
,
2011 walk_tree (&TREE_OPERAND (t
, 3), convert_local_reference_op
, wi
,
2015 wi
->val_only
= false;
2016 walk_tree (tp
, convert_local_reference_op
, wi
, NULL
);
2017 wi
->val_only
= save_val_only
;
2021 save_val_only
= wi
->val_only
;
2022 wi
->val_only
= true;
2024 walk_tree (&TREE_OPERAND (t
, 0), convert_local_reference_op
,
2026 /* We need to re-fold the MEM_REF as component references as
2027 part of a ADDR_EXPR address are not allowed. But we cannot
2028 fold here, as the chain record type is not yet finalized. */
2029 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
2030 && !DECL_P (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)))
2031 info
->mem_refs
->add (tp
);
2032 wi
->val_only
= save_val_only
;
2035 case VIEW_CONVERT_EXPR
:
2036 /* Just request to look at the subtrees, leaving val_only and lhs
2037 untouched. This might actually be for !val_only + lhs, in which
2038 case we don't want to force a replacement by a temporary. */
2043 if (!IS_TYPE_OR_DECL_P (t
))
2046 wi
->val_only
= true;
2055 static tree
convert_local_reference_stmt (gimple_stmt_iterator
*, bool *,
2056 struct walk_stmt_info
*);
2058 /* Helper for convert_local_reference. Convert all the references in
2059 the chain of clauses at *PCLAUSES. WI is as in convert_local_reference. */
2062 convert_local_omp_clauses (tree
*pclauses
, struct walk_stmt_info
*wi
)
2064 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
2065 bool need_frame
= false, need_stmts
= false;
2066 tree clause
, decl
, *pdecl
;
2068 bitmap new_suppress
;
2070 new_suppress
= BITMAP_GGC_ALLOC ();
2071 bitmap_copy (new_suppress
, info
->suppress_expansion
);
2073 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
2076 switch (OMP_CLAUSE_CODE (clause
))
2078 case OMP_CLAUSE_REDUCTION
:
2079 case OMP_CLAUSE_IN_REDUCTION
:
2080 case OMP_CLAUSE_TASK_REDUCTION
:
2081 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
2083 if (TREE_CODE (OMP_CLAUSE_DECL (clause
)) == MEM_REF
)
2085 pdecl
= &TREE_OPERAND (OMP_CLAUSE_DECL (clause
), 0);
2086 if (TREE_CODE (*pdecl
) == POINTER_PLUS_EXPR
)
2087 pdecl
= &TREE_OPERAND (*pdecl
, 0);
2088 if (TREE_CODE (*pdecl
) == INDIRECT_REF
2089 || TREE_CODE (*pdecl
) == ADDR_EXPR
)
2090 pdecl
= &TREE_OPERAND (*pdecl
, 0);
2092 goto do_decl_clause
;
2094 case OMP_CLAUSE_LASTPRIVATE
:
2095 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
))
2097 goto do_decl_clause
;
2099 case OMP_CLAUSE_LINEAR
:
2100 if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
))
2102 wi
->val_only
= true;
2104 convert_local_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause
), &dummy
,
2106 goto do_decl_clause
;
2108 case OMP_CLAUSE_PRIVATE
:
2109 case OMP_CLAUSE_FIRSTPRIVATE
:
2110 case OMP_CLAUSE_COPYPRIVATE
:
2111 case OMP_CLAUSE_SHARED
:
2112 case OMP_CLAUSE_TO_DECLARE
:
2113 case OMP_CLAUSE_LINK
:
2114 case OMP_CLAUSE_USE_DEVICE_PTR
:
2115 case OMP_CLAUSE_USE_DEVICE_ADDR
:
2116 case OMP_CLAUSE_IS_DEVICE_PTR
:
2117 case OMP_CLAUSE_DETACH
:
2120 pdecl
= &OMP_CLAUSE_DECL (clause
);
2123 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
2125 if (decl_function_context (decl
) == info
->context
2126 && !use_pointer_in_frame (decl
))
2128 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
2131 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_SHARED
)
2132 OMP_CLAUSE_SHARED_READONLY (clause
) = 0;
2133 bitmap_set_bit (new_suppress
, DECL_UID (decl
));
2134 *pdecl
= get_local_debug_decl (info
, decl
, field
);
2140 case OMP_CLAUSE_SCHEDULE
:
2141 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
) == NULL
)
2144 case OMP_CLAUSE_FINAL
:
2146 case OMP_CLAUSE_NUM_THREADS
:
2147 case OMP_CLAUSE_DEPEND
:
2148 case OMP_CLAUSE_DEVICE
:
2149 case OMP_CLAUSE_NUM_TEAMS
:
2150 case OMP_CLAUSE_THREAD_LIMIT
:
2151 case OMP_CLAUSE_SAFELEN
:
2152 case OMP_CLAUSE_SIMDLEN
:
2153 case OMP_CLAUSE_PRIORITY
:
2154 case OMP_CLAUSE_GRAINSIZE
:
2155 case OMP_CLAUSE_NUM_TASKS
:
2156 case OMP_CLAUSE_HINT
:
2157 case OMP_CLAUSE_NUM_GANGS
:
2158 case OMP_CLAUSE_NUM_WORKERS
:
2159 case OMP_CLAUSE_VECTOR_LENGTH
:
2160 case OMP_CLAUSE_GANG
:
2161 case OMP_CLAUSE_WORKER
:
2162 case OMP_CLAUSE_VECTOR
:
2163 case OMP_CLAUSE_ASYNC
:
2164 case OMP_CLAUSE_WAIT
:
2165 /* Several OpenACC clauses have optional arguments. Check if they
2167 if (OMP_CLAUSE_OPERAND (clause
, 0))
2169 wi
->val_only
= true;
2171 convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
2175 /* The gang clause accepts two arguments. */
2176 if (OMP_CLAUSE_CODE (clause
) == OMP_CLAUSE_GANG
2177 && OMP_CLAUSE_GANG_STATIC_EXPR (clause
))
2179 wi
->val_only
= true;
2181 convert_nonlocal_reference_op
2182 (&OMP_CLAUSE_GANG_STATIC_EXPR (clause
), &dummy
, wi
);
2186 case OMP_CLAUSE_DIST_SCHEDULE
:
2187 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
) != NULL
)
2189 wi
->val_only
= true;
2191 convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
2196 case OMP_CLAUSE_MAP
:
2198 case OMP_CLAUSE_FROM
:
2199 if (OMP_CLAUSE_SIZE (clause
))
2201 wi
->val_only
= true;
2203 convert_local_reference_op (&OMP_CLAUSE_SIZE (clause
),
2206 if (DECL_P (OMP_CLAUSE_DECL (clause
)))
2207 goto do_decl_clause
;
2208 wi
->val_only
= true;
2210 walk_tree (&OMP_CLAUSE_DECL (clause
), convert_local_reference_op
,
2214 case OMP_CLAUSE_ALIGNED
:
2215 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
2217 wi
->val_only
= true;
2219 convert_local_reference_op
2220 (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
), &dummy
, wi
);
2223 case OMP_CLAUSE_NONTEMPORAL
:
2224 do_decl_clause_no_supp
:
2225 /* Like do_decl_clause, but don't add any suppression. */
2226 decl
= OMP_CLAUSE_DECL (clause
);
2228 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
2230 if (decl_function_context (decl
) == info
->context
2231 && !use_pointer_in_frame (decl
))
2233 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
2236 OMP_CLAUSE_DECL (clause
)
2237 = get_local_debug_decl (info
, decl
, field
);
2243 case OMP_CLAUSE_ALLOCATE
:
2244 if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
))
2246 wi
->val_only
= true;
2248 convert_local_reference_op
2249 (&OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause
), &dummy
, wi
);
2251 goto do_decl_clause_no_supp
;
2253 case OMP_CLAUSE_NOWAIT
:
2254 case OMP_CLAUSE_ORDERED
:
2255 case OMP_CLAUSE_DEFAULT
:
2256 case OMP_CLAUSE_COPYIN
:
2257 case OMP_CLAUSE_COLLAPSE
:
2258 case OMP_CLAUSE_TILE
:
2259 case OMP_CLAUSE_UNTIED
:
2260 case OMP_CLAUSE_MERGEABLE
:
2261 case OMP_CLAUSE_PROC_BIND
:
2262 case OMP_CLAUSE_NOGROUP
:
2263 case OMP_CLAUSE_THREADS
:
2264 case OMP_CLAUSE_SIMD
:
2265 case OMP_CLAUSE_DEFAULTMAP
:
2266 case OMP_CLAUSE_ORDER
:
2267 case OMP_CLAUSE_SEQ
:
2268 case OMP_CLAUSE_INDEPENDENT
:
2269 case OMP_CLAUSE_AUTO
:
2270 case OMP_CLAUSE_IF_PRESENT
:
2271 case OMP_CLAUSE_FINALIZE
:
2272 case OMP_CLAUSE_BIND
:
2273 case OMP_CLAUSE__CONDTEMP_
:
2274 case OMP_CLAUSE__SCANTEMP_
:
2277 /* The following clause belongs to the OpenACC cache directive, which
2278 is discarded during gimplification. */
2279 case OMP_CLAUSE__CACHE_
:
2280 /* The following clauses are only allowed in the OpenMP declare simd
2281 directive, so not seen here. */
2282 case OMP_CLAUSE_UNIFORM
:
2283 case OMP_CLAUSE_INBRANCH
:
2284 case OMP_CLAUSE_NOTINBRANCH
:
2285 /* The following clauses are only allowed on OpenMP cancel and
2286 cancellation point directives, which at this point have already
2287 been lowered into a function call. */
2288 case OMP_CLAUSE_FOR
:
2289 case OMP_CLAUSE_PARALLEL
:
2290 case OMP_CLAUSE_SECTIONS
:
2291 case OMP_CLAUSE_TASKGROUP
:
2292 /* The following clauses are only added during OMP lowering; nested
2293 function decomposition happens before that. */
2294 case OMP_CLAUSE__LOOPTEMP_
:
2295 case OMP_CLAUSE__REDUCTEMP_
:
2296 case OMP_CLAUSE__SIMDUID_
:
2297 case OMP_CLAUSE__SIMT_
:
2298 /* The following clauses are only allowed on OpenACC 'routine'
2299 directives, not seen here. */
2300 case OMP_CLAUSE_NOHOST
:
2301 /* Anything else. */
2307 info
->suppress_expansion
= new_suppress
;
2310 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
2311 switch (OMP_CLAUSE_CODE (clause
))
2313 case OMP_CLAUSE_REDUCTION
:
2314 case OMP_CLAUSE_IN_REDUCTION
:
2315 case OMP_CLAUSE_TASK_REDUCTION
:
2316 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
2319 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
));
2320 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
2322 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
2323 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
2325 walk_body (convert_local_reference_stmt
,
2326 convert_local_reference_op
, info
,
2327 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause
));
2328 walk_body (convert_local_reference_stmt
,
2329 convert_local_reference_op
, info
,
2330 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause
));
2331 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
2333 if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
2334 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause
))
2339 case OMP_CLAUSE_LASTPRIVATE
:
2340 walk_body (convert_local_reference_stmt
,
2341 convert_local_reference_op
, info
,
2342 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
));
2345 case OMP_CLAUSE_LINEAR
:
2346 walk_body (convert_local_reference_stmt
,
2347 convert_local_reference_op
, info
,
2348 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
));
2359 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
2360 and PARM_DECLs that were referenced by inner nested functions.
2361 The rewrite will be a structure reference to the local frame variable. */
2364 convert_local_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2365 struct walk_stmt_info
*wi
)
2367 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
2368 tree save_local_var_chain
;
2369 bitmap save_suppress
;
2370 char save_static_chain_added
;
2371 bool frame_decl_added
;
2372 gimple
*stmt
= gsi_stmt (*gsi
);
2374 switch (gimple_code (stmt
))
2376 case GIMPLE_OMP_TEAMS
:
2377 if (!gimple_omp_teams_host (as_a
<gomp_teams
*> (stmt
)))
2379 save_suppress
= info
->suppress_expansion
;
2380 convert_local_omp_clauses (gimple_omp_teams_clauses_ptr (stmt
), wi
);
2381 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2382 info
, gimple_omp_body_ptr (stmt
));
2383 info
->suppress_expansion
= save_suppress
;
2388 case GIMPLE_OMP_PARALLEL
:
2389 case GIMPLE_OMP_TASK
:
2390 save_suppress
= info
->suppress_expansion
;
2391 frame_decl_added
= false;
2392 if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt
),
2395 tree c
= build_omp_clause (gimple_location (stmt
),
2397 (void) get_frame_type (info
);
2398 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
2399 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2400 gimple_omp_taskreg_set_clauses (stmt
, c
);
2401 info
->static_chain_added
|= 4;
2402 frame_decl_added
= true;
2405 save_local_var_chain
= info
->new_local_var_chain
;
2406 save_static_chain_added
= info
->static_chain_added
;
2407 info
->new_local_var_chain
= NULL
;
2408 info
->static_chain_added
= 0;
2410 walk_body (convert_local_reference_stmt
, convert_local_reference_op
, info
,
2411 gimple_omp_body_ptr (stmt
));
2413 if ((info
->static_chain_added
& 4) != 0 && !frame_decl_added
)
2415 tree c
= build_omp_clause (gimple_location (stmt
),
2417 (void) get_frame_type (info
);
2418 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
2419 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2420 info
->static_chain_added
|= 4;
2421 gimple_omp_taskreg_set_clauses (stmt
, c
);
2423 if (info
->new_local_var_chain
)
2424 declare_vars (info
->new_local_var_chain
,
2425 gimple_seq_first_stmt (gimple_omp_body (stmt
)), false);
2426 info
->new_local_var_chain
= save_local_var_chain
;
2427 info
->suppress_expansion
= save_suppress
;
2428 info
->static_chain_added
|= save_static_chain_added
;
2431 case GIMPLE_OMP_FOR
:
2432 save_suppress
= info
->suppress_expansion
;
2433 convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt
), wi
);
2434 walk_gimple_omp_for (as_a
<gomp_for
*> (stmt
),
2435 convert_local_reference_stmt
,
2436 convert_local_reference_op
, info
);
2437 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2438 info
, gimple_omp_body_ptr (stmt
));
2439 info
->suppress_expansion
= save_suppress
;
2442 case GIMPLE_OMP_SECTIONS
:
2443 save_suppress
= info
->suppress_expansion
;
2444 convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt
), wi
);
2445 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2446 info
, gimple_omp_body_ptr (stmt
));
2447 info
->suppress_expansion
= save_suppress
;
2450 case GIMPLE_OMP_SINGLE
:
2451 save_suppress
= info
->suppress_expansion
;
2452 convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt
), wi
);
2453 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2454 info
, gimple_omp_body_ptr (stmt
));
2455 info
->suppress_expansion
= save_suppress
;
2458 case GIMPLE_OMP_TASKGROUP
:
2459 save_suppress
= info
->suppress_expansion
;
2460 convert_local_omp_clauses (gimple_omp_taskgroup_clauses_ptr (stmt
), wi
);
2461 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2462 info
, gimple_omp_body_ptr (stmt
));
2463 info
->suppress_expansion
= save_suppress
;
2466 case GIMPLE_OMP_TARGET
:
2467 if (!is_gimple_omp_offloaded (stmt
))
2469 save_suppress
= info
->suppress_expansion
;
2470 convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt
), wi
);
2471 info
->suppress_expansion
= save_suppress
;
2472 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2473 info
, gimple_omp_body_ptr (stmt
));
2476 save_suppress
= info
->suppress_expansion
;
2477 frame_decl_added
= false;
2478 if (convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt
), wi
))
2480 tree c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
2481 (void) get_frame_type (info
);
2482 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
2483 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TOFROM
);
2484 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (info
->frame_decl
);
2485 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
2486 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
), c
);
2487 info
->static_chain_added
|= 4;
2488 frame_decl_added
= true;
2491 save_local_var_chain
= info
->new_local_var_chain
;
2492 save_static_chain_added
= info
->static_chain_added
;
2493 info
->new_local_var_chain
= NULL
;
2494 info
->static_chain_added
= 0;
2496 walk_body (convert_local_reference_stmt
, convert_local_reference_op
, info
,
2497 gimple_omp_body_ptr (stmt
));
2499 if ((info
->static_chain_added
& 4) != 0 && !frame_decl_added
)
2501 tree c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
2502 (void) get_frame_type (info
);
2503 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
2504 OMP_CLAUSE_SET_MAP_KIND (c
, GOMP_MAP_TOFROM
);
2505 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (info
->frame_decl
);
2506 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
2507 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
), c
);
2508 info
->static_chain_added
|= 4;
2511 if (info
->new_local_var_chain
)
2512 declare_vars (info
->new_local_var_chain
,
2513 gimple_seq_first_stmt (gimple_omp_body (stmt
)), false);
2514 info
->new_local_var_chain
= save_local_var_chain
;
2515 info
->suppress_expansion
= save_suppress
;
2516 info
->static_chain_added
|= save_static_chain_added
;
2519 case GIMPLE_OMP_SECTION
:
2520 case GIMPLE_OMP_MASTER
:
2521 case GIMPLE_OMP_ORDERED
:
2522 case GIMPLE_OMP_SCAN
:
2523 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
2524 info
, gimple_omp_body_ptr (stmt
));
2528 wi
->val_only
= true;
2530 *handled_ops_p
= false;
2534 if (gimple_clobber_p (stmt
))
2536 tree lhs
= gimple_assign_lhs (stmt
);
2538 && decl_function_context (lhs
) == info
->context
2539 && !use_pointer_in_frame (lhs
)
2540 && lookup_field_for_decl (info
, lhs
, NO_INSERT
))
2542 gsi_replace (gsi
, gimple_build_nop (), true);
2546 *handled_ops_p
= false;
2550 for (tree var
= gimple_bind_vars (as_a
<gbind
*> (stmt
));
2552 var
= DECL_CHAIN (var
))
2553 if (TREE_CODE (var
) == NAMELIST_DECL
)
2555 /* Adjust decls mentioned in NAMELIST_DECL. */
2556 tree decls
= NAMELIST_DECL_ASSOCIATED_DECL (var
);
2560 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls
), i
, decl
)
2563 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
2565 if (decl_function_context (decl
) == info
->context
2566 && !use_pointer_in_frame (decl
))
2568 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
2571 CONSTRUCTOR_ELT (decls
, i
)->value
2572 = get_local_debug_decl (info
, decl
, field
);
2578 *handled_ops_p
= false;
2582 /* For every other statement that we are not interested in
2583 handling here, let the walker traverse the operands. */
2584 *handled_ops_p
= false;
2588 /* Indicate that we have handled all the operands ourselves. */
2589 *handled_ops_p
= true;
2594 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_GOTOs
2595 that reference labels from outer functions. The rewrite will be a
2596 call to __builtin_nonlocal_goto. */
2599 convert_nl_goto_reference (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2600 struct walk_stmt_info
*wi
)
2602 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
, *i
;
2603 tree label
, new_label
, target_context
, x
, field
;
2605 gimple
*stmt
= gsi_stmt (*gsi
);
2607 if (gimple_code (stmt
) != GIMPLE_GOTO
)
2609 *handled_ops_p
= false;
2613 label
= gimple_goto_dest (stmt
);
2614 if (TREE_CODE (label
) != LABEL_DECL
)
2616 *handled_ops_p
= false;
2620 target_context
= decl_function_context (label
);
2621 if (target_context
== info
->context
)
2623 *handled_ops_p
= false;
2627 for (i
= info
->outer
; target_context
!= i
->context
; i
= i
->outer
)
2630 /* The original user label may also be use for a normal goto, therefore
2631 we must create a new label that will actually receive the abnormal
2632 control transfer. This new label will be marked LABEL_NONLOCAL; this
2633 mark will trigger proper behavior in the cfg, as well as cause the
2634 (hairy target-specific) non-local goto receiver code to be generated
2635 when we expand rtl. Enter this association into var_map so that we
2636 can insert the new label into the IL during a second pass. */
2637 tree
*slot
= &i
->var_map
->get_or_insert (label
);
2640 new_label
= create_artificial_label (UNKNOWN_LOCATION
);
2641 DECL_NONLOCAL (new_label
) = 1;
2647 /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field). */
2648 field
= get_nl_goto_field (i
);
2649 x
= get_frame_field (info
, target_context
, field
, gsi
);
2651 x
= gsi_gimplify_val (info
, x
, gsi
);
2652 call
= gimple_build_call (builtin_decl_implicit (BUILT_IN_NONLOCAL_GOTO
),
2653 2, build_addr (new_label
), x
);
2654 gsi_replace (gsi
, call
, false);
2656 /* We have handled all of STMT's operands, no need to keep going. */
2657 *handled_ops_p
= true;
2662 /* Called via walk_function+walk_tree, rewrite all GIMPLE_LABELs whose labels
2663 are referenced via nonlocal goto from a nested function. The rewrite
2664 will involve installing a newly generated DECL_NONLOCAL label, and
2665 (potentially) a branch around the rtl gunk that is assumed to be
2666 attached to such a label. */
2669 convert_nl_goto_receiver (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2670 struct walk_stmt_info
*wi
)
2672 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
2673 tree label
, new_label
;
2674 gimple_stmt_iterator tmp_gsi
;
2675 glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (*gsi
));
2679 *handled_ops_p
= false;
2683 label
= gimple_label_label (stmt
);
2685 tree
*slot
= info
->var_map
->get (label
);
2688 *handled_ops_p
= false;
2692 /* If there's any possibility that the previous statement falls through,
2693 then we must branch around the new non-local label. */
2695 gsi_prev (&tmp_gsi
);
2696 if (gsi_end_p (tmp_gsi
) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi
)))
2698 gimple
*stmt
= gimple_build_goto (label
);
2699 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2702 new_label
= (tree
) *slot
;
2703 stmt
= gimple_build_label (new_label
);
2704 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2706 *handled_ops_p
= true;
2711 /* Called via walk_function+walk_stmt, rewrite all references to addresses
2712 of nested functions that require the use of trampolines. The rewrite
2713 will involve a reference a trampoline generated for the occasion. */
2716 convert_tramp_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
2718 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
2719 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
, *i
;
2720 tree t
= *tp
, decl
, target_context
, x
, builtin
;
2725 switch (TREE_CODE (t
))
2729 T.1 = &CHAIN->tramp;
2730 T.2 = __builtin_adjust_trampoline (T.1);
2731 T.3 = (func_type)T.2;
2734 decl
= TREE_OPERAND (t
, 0);
2735 if (TREE_CODE (decl
) != FUNCTION_DECL
)
2738 /* Only need to process nested functions. */
2739 target_context
= decl_function_context (decl
);
2740 if (!target_context
)
2743 /* If the nested function doesn't use a static chain, then
2744 it doesn't need a trampoline. */
2745 if (!DECL_STATIC_CHAIN (decl
))
2748 /* If we don't want a trampoline, then don't build one. */
2749 if (TREE_NO_TRAMPOLINE (t
))
2752 /* Lookup the immediate parent of the callee, as that's where
2753 we need to insert the trampoline. */
2754 for (i
= info
; i
->context
!= target_context
; i
= i
->outer
)
2757 /* Decide whether to generate a descriptor or a trampoline. */
2758 descr
= FUNC_ADDR_BY_DESCRIPTOR (t
) && !flag_trampolines
;
2761 x
= lookup_descr_for_decl (i
, decl
, INSERT
);
2763 x
= lookup_tramp_for_decl (i
, decl
, INSERT
);
2765 /* Compute the address of the field holding the trampoline. */
2766 x
= get_frame_field (info
, target_context
, x
, &wi
->gsi
);
2768 x
= gsi_gimplify_val (info
, x
, &wi
->gsi
);
2770 /* Do machine-specific ugliness. Normally this will involve
2771 computing extra alignment, but it can really be anything. */
2773 builtin
= builtin_decl_implicit (BUILT_IN_ADJUST_DESCRIPTOR
);
2775 builtin
= builtin_decl_implicit (BUILT_IN_ADJUST_TRAMPOLINE
);
2776 call
= gimple_build_call (builtin
, 1, x
);
2777 x
= init_tmp_var_with_call (info
, &wi
->gsi
, call
);
2779 /* Cast back to the proper function type. */
2780 x
= build1 (NOP_EXPR
, TREE_TYPE (t
), x
);
2781 x
= init_tmp_var (info
, x
, &wi
->gsi
);
2787 if (!IS_TYPE_OR_DECL_P (t
))
2796 /* Called via walk_function+walk_gimple_stmt, rewrite all references
2797 to addresses of nested functions that require the use of
2798 trampolines. The rewrite will involve a reference a trampoline
2799 generated for the occasion. */
2802 convert_tramp_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2803 struct walk_stmt_info
*wi
)
2805 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
2806 gimple
*stmt
= gsi_stmt (*gsi
);
2808 switch (gimple_code (stmt
))
2812 /* Only walk call arguments, lest we generate trampolines for
2814 unsigned long i
, nargs
= gimple_call_num_args (stmt
);
2815 for (i
= 0; i
< nargs
; i
++)
2816 walk_tree (gimple_call_arg_ptr (stmt
, i
), convert_tramp_reference_op
,
2821 case GIMPLE_OMP_TEAMS
:
2822 if (!gimple_omp_teams_host (as_a
<gomp_teams
*> (stmt
)))
2824 *handled_ops_p
= false;
2829 case GIMPLE_OMP_TARGET
:
2830 if (!is_gimple_omp_offloaded (stmt
))
2832 *handled_ops_p
= false;
2836 case GIMPLE_OMP_PARALLEL
:
2837 case GIMPLE_OMP_TASK
:
2840 tree save_local_var_chain
= info
->new_local_var_chain
;
2841 walk_gimple_op (stmt
, convert_tramp_reference_op
, wi
);
2842 info
->new_local_var_chain
= NULL
;
2843 char save_static_chain_added
= info
->static_chain_added
;
2844 info
->static_chain_added
= 0;
2845 walk_body (convert_tramp_reference_stmt
, convert_tramp_reference_op
,
2846 info
, gimple_omp_body_ptr (stmt
));
2847 if (info
->new_local_var_chain
)
2848 declare_vars (info
->new_local_var_chain
,
2849 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
2851 for (int i
= 0; i
< 2; i
++)
2854 if ((info
->static_chain_added
& (1 << i
)) == 0)
2856 decl
= i
? get_chain_decl (info
) : info
->frame_decl
;
2857 /* Don't add CHAIN.* or FRAME.* twice. */
2858 for (c
= gimple_omp_taskreg_clauses (stmt
);
2860 c
= OMP_CLAUSE_CHAIN (c
))
2861 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
2862 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
)
2863 && OMP_CLAUSE_DECL (c
) == decl
)
2865 if (c
== NULL
&& gimple_code (stmt
) != GIMPLE_OMP_TARGET
)
2867 c
= build_omp_clause (gimple_location (stmt
),
2868 i
? OMP_CLAUSE_FIRSTPRIVATE
2869 : OMP_CLAUSE_SHARED
);
2870 OMP_CLAUSE_DECL (c
) = decl
;
2871 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2872 gimple_omp_taskreg_set_clauses (stmt
, c
);
2876 c
= build_omp_clause (gimple_location (stmt
),
2878 OMP_CLAUSE_DECL (c
) = decl
;
2879 OMP_CLAUSE_SET_MAP_KIND (c
,
2880 i
? GOMP_MAP_TO
: GOMP_MAP_TOFROM
);
2881 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
2882 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
2883 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
),
2887 info
->new_local_var_chain
= save_local_var_chain
;
2888 info
->static_chain_added
|= save_static_chain_added
;
2893 *handled_ops_p
= false;
2897 *handled_ops_p
= true;
2903 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_CALLs
2904 that reference nested functions to make sure that the static chain
2905 is set up properly for the call. */
2908 convert_gimple_call (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2909 struct walk_stmt_info
*wi
)
2911 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
2912 tree decl
, target_context
;
2913 char save_static_chain_added
;
2915 gimple
*stmt
= gsi_stmt (*gsi
);
2917 switch (gimple_code (stmt
))
2920 if (gimple_call_chain (stmt
))
2922 decl
= gimple_call_fndecl (stmt
);
2925 target_context
= decl_function_context (decl
);
2926 if (target_context
&& DECL_STATIC_CHAIN (decl
))
2928 struct nesting_info
*i
= info
;
2929 while (i
&& i
->context
!= target_context
)
2931 /* If none of the outer contexts is the target context, this means
2932 that the function is called in a wrong context. */
2934 internal_error ("%s from %s called in %s",
2935 IDENTIFIER_POINTER (DECL_NAME (decl
)),
2936 IDENTIFIER_POINTER (DECL_NAME (target_context
)),
2937 IDENTIFIER_POINTER (DECL_NAME (info
->context
)));
2939 gimple_call_set_chain (as_a
<gcall
*> (stmt
),
2940 get_static_chain (info
, target_context
,
2942 info
->static_chain_added
|= (1 << (info
->context
!= target_context
));
2946 case GIMPLE_OMP_TEAMS
:
2947 if (!gimple_omp_teams_host (as_a
<gomp_teams
*> (stmt
)))
2949 walk_body (convert_gimple_call
, NULL
, info
,
2950 gimple_omp_body_ptr (stmt
));
2955 case GIMPLE_OMP_PARALLEL
:
2956 case GIMPLE_OMP_TASK
:
2957 save_static_chain_added
= info
->static_chain_added
;
2958 info
->static_chain_added
= 0;
2959 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2960 for (i
= 0; i
< 2; i
++)
2963 if ((info
->static_chain_added
& (1 << i
)) == 0)
2965 decl
= i
? get_chain_decl (info
) : info
->frame_decl
;
2966 /* Don't add CHAIN.* or FRAME.* twice. */
2967 for (c
= gimple_omp_taskreg_clauses (stmt
);
2969 c
= OMP_CLAUSE_CHAIN (c
))
2970 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
2971 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
)
2972 && OMP_CLAUSE_DECL (c
) == decl
)
2976 c
= build_omp_clause (gimple_location (stmt
),
2977 i
? OMP_CLAUSE_FIRSTPRIVATE
2978 : OMP_CLAUSE_SHARED
);
2979 OMP_CLAUSE_DECL (c
) = decl
;
2980 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2981 gimple_omp_taskreg_set_clauses (stmt
, c
);
2984 info
->static_chain_added
|= save_static_chain_added
;
2987 case GIMPLE_OMP_TARGET
:
2988 if (!is_gimple_omp_offloaded (stmt
))
2990 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2993 save_static_chain_added
= info
->static_chain_added
;
2994 info
->static_chain_added
= 0;
2995 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2996 for (i
= 0; i
< 2; i
++)
2999 if ((info
->static_chain_added
& (1 << i
)) == 0)
3001 decl
= i
? get_chain_decl (info
) : info
->frame_decl
;
3002 /* Don't add CHAIN.* or FRAME.* twice. */
3003 for (c
= gimple_omp_target_clauses (stmt
);
3005 c
= OMP_CLAUSE_CHAIN (c
))
3006 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
3007 && OMP_CLAUSE_DECL (c
) == decl
)
3011 c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
3012 OMP_CLAUSE_DECL (c
) = decl
;
3013 OMP_CLAUSE_SET_MAP_KIND (c
, i
? GOMP_MAP_TO
: GOMP_MAP_TOFROM
);
3014 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
3015 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
3016 gimple_omp_target_set_clauses (as_a
<gomp_target
*> (stmt
),
3020 info
->static_chain_added
|= save_static_chain_added
;
3023 case GIMPLE_OMP_FOR
:
3024 walk_body (convert_gimple_call
, NULL
, info
,
3025 gimple_omp_for_pre_body_ptr (stmt
));
3027 case GIMPLE_OMP_SECTIONS
:
3028 case GIMPLE_OMP_SECTION
:
3029 case GIMPLE_OMP_SINGLE
:
3030 case GIMPLE_OMP_MASTER
:
3031 case GIMPLE_OMP_TASKGROUP
:
3032 case GIMPLE_OMP_ORDERED
:
3033 case GIMPLE_OMP_SCAN
:
3034 case GIMPLE_OMP_CRITICAL
:
3035 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
3039 /* Keep looking for other operands. */
3040 *handled_ops_p
= false;
3044 *handled_ops_p
= true;
3048 /* Walk the nesting tree starting with ROOT. Convert all trampolines and
3049 call expressions. At the same time, determine if a nested function
3050 actually uses its static chain; if not, remember that. */
3053 convert_all_function_calls (struct nesting_info
*root
)
3055 unsigned int chain_count
= 0, old_chain_count
, iter_count
;
3056 struct nesting_info
*n
;
3058 /* First, optimistically clear static_chain for all decls that haven't
3059 used the static chain already for variable access. But always create
3060 it if not optimizing. This makes it possible to reconstruct the static
3061 nesting tree at run time and thus to resolve up-level references from
3062 within the debugger. */
3063 FOR_EACH_NEST_INFO (n
, root
)
3067 tree decl
= n
->context
;
3071 (void) get_frame_type (n
);
3073 (void) get_chain_decl (n
);
3075 else if (!n
->outer
|| (!n
->chain_decl
&& !n
->chain_field
))
3077 DECL_STATIC_CHAIN (decl
) = 0;
3078 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3079 fprintf (dump_file
, "Guessing no static-chain for %s\n",
3080 lang_hooks
.decl_printable_name (decl
, 2));
3083 DECL_STATIC_CHAIN (decl
) = 1;
3084 chain_count
+= DECL_STATIC_CHAIN (decl
);
3087 FOR_EACH_NEST_INFO (n
, root
)
3090 tree decl
= n
->context
;
3091 tree alias
= thunk_info::get (cgraph_node::get (decl
))->alias
;
3092 DECL_STATIC_CHAIN (decl
) = DECL_STATIC_CHAIN (alias
);
3095 /* Walk the functions and perform transformations. Note that these
3096 transformations can induce new uses of the static chain, which in turn
3097 require re-examining all users of the decl. */
3098 /* ??? It would make sense to try to use the call graph to speed this up,
3099 but the call graph hasn't really been built yet. Even if it did, we
3100 would still need to iterate in this loop since address-of references
3101 wouldn't show up in the callgraph anyway. */
3105 old_chain_count
= chain_count
;
3109 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3110 fputc ('\n', dump_file
);
3112 FOR_EACH_NEST_INFO (n
, root
)
3116 tree decl
= n
->context
;
3117 walk_function (convert_tramp_reference_stmt
,
3118 convert_tramp_reference_op
, n
);
3119 walk_function (convert_gimple_call
, NULL
, n
);
3120 chain_count
+= DECL_STATIC_CHAIN (decl
);
3123 FOR_EACH_NEST_INFO (n
, root
)
3126 tree decl
= n
->context
;
3127 tree alias
= thunk_info::get (cgraph_node::get (decl
))->alias
;
3128 DECL_STATIC_CHAIN (decl
) = DECL_STATIC_CHAIN (alias
);
3131 while (chain_count
!= old_chain_count
);
3133 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
3134 fprintf (dump_file
, "convert_all_function_calls iterations: %u\n\n",
3138 struct nesting_copy_body_data
3141 struct nesting_info
*root
;
3144 /* A helper subroutine for debug_var_chain type remapping. */
3147 nesting_copy_decl (tree decl
, copy_body_data
*id
)
3149 struct nesting_copy_body_data
*nid
= (struct nesting_copy_body_data
*) id
;
3150 tree
*slot
= nid
->root
->var_map
->get (decl
);
3153 return (tree
) *slot
;
3155 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (decl
))
3157 tree new_decl
= copy_decl_no_change (decl
, id
);
3158 DECL_ORIGINAL_TYPE (new_decl
)
3159 = remap_type (DECL_ORIGINAL_TYPE (decl
), id
);
3164 || TREE_CODE (decl
) == PARM_DECL
3165 || TREE_CODE (decl
) == RESULT_DECL
)
3168 return copy_decl_no_change (decl
, id
);
3171 /* A helper function for remap_vla_decls. See if *TP contains
3172 some remapped variables. */
3175 contains_remapped_vars (tree
*tp
, int *walk_subtrees
, void *data
)
3177 struct nesting_info
*root
= (struct nesting_info
*) data
;
3183 tree
*slot
= root
->var_map
->get (t
);
3191 /* Remap VLA decls in BLOCK and subblocks if remapped variables are
3195 remap_vla_decls (tree block
, struct nesting_info
*root
)
3197 tree var
, subblock
, val
, type
;
3198 struct nesting_copy_body_data id
;
3200 for (subblock
= BLOCK_SUBBLOCKS (block
);
3202 subblock
= BLOCK_CHAIN (subblock
))
3203 remap_vla_decls (subblock
, root
);
3205 for (var
= BLOCK_VARS (block
); var
; var
= DECL_CHAIN (var
))
3206 if (VAR_P (var
) && DECL_HAS_VALUE_EXPR_P (var
))
3208 val
= DECL_VALUE_EXPR (var
);
3209 type
= TREE_TYPE (var
);
3211 if (!(TREE_CODE (val
) == INDIRECT_REF
3212 && TREE_CODE (TREE_OPERAND (val
, 0)) == VAR_DECL
3213 && variably_modified_type_p (type
, NULL
)))
3216 if (root
->var_map
->get (TREE_OPERAND (val
, 0))
3217 || walk_tree (&type
, contains_remapped_vars
, root
, NULL
))
3221 if (var
== NULL_TREE
)
3224 memset (&id
, 0, sizeof (id
));
3225 id
.cb
.copy_decl
= nesting_copy_decl
;
3226 id
.cb
.decl_map
= new hash_map
<tree
, tree
>;
3229 for (; var
; var
= DECL_CHAIN (var
))
3230 if (VAR_P (var
) && DECL_HAS_VALUE_EXPR_P (var
))
3232 struct nesting_info
*i
;
3235 val
= DECL_VALUE_EXPR (var
);
3236 type
= TREE_TYPE (var
);
3238 if (!(TREE_CODE (val
) == INDIRECT_REF
3239 && TREE_CODE (TREE_OPERAND (val
, 0)) == VAR_DECL
3240 && variably_modified_type_p (type
, NULL
)))
3243 tree
*slot
= root
->var_map
->get (TREE_OPERAND (val
, 0));
3244 if (!slot
&& !walk_tree (&type
, contains_remapped_vars
, root
, NULL
))
3247 context
= decl_function_context (var
);
3248 for (i
= root
; i
; i
= i
->outer
)
3249 if (i
->context
== context
)
3255 /* Fully expand value expressions. This avoids having debug variables
3256 only referenced from them and that can be swept during GC. */
3259 tree t
= (tree
) *slot
;
3260 gcc_assert (DECL_P (t
) && DECL_HAS_VALUE_EXPR_P (t
));
3261 val
= build1 (INDIRECT_REF
, TREE_TYPE (val
), DECL_VALUE_EXPR (t
));
3264 id
.cb
.src_fn
= i
->context
;
3265 id
.cb
.dst_fn
= i
->context
;
3266 id
.cb
.src_cfun
= DECL_STRUCT_FUNCTION (root
->context
);
3268 TREE_TYPE (var
) = newt
= remap_type (type
, &id
.cb
);
3269 while (POINTER_TYPE_P (newt
) && !TYPE_NAME (newt
))
3271 newt
= TREE_TYPE (newt
);
3272 type
= TREE_TYPE (type
);
3274 if (TYPE_NAME (newt
)
3275 && TREE_CODE (TYPE_NAME (newt
)) == TYPE_DECL
3276 && DECL_ORIGINAL_TYPE (TYPE_NAME (newt
))
3278 && TYPE_NAME (newt
) == TYPE_NAME (type
))
3279 TYPE_NAME (newt
) = remap_decl (TYPE_NAME (newt
), &id
.cb
);
3281 walk_tree (&val
, copy_tree_body_r
, &id
.cb
, NULL
);
3282 if (val
!= DECL_VALUE_EXPR (var
))
3283 SET_DECL_VALUE_EXPR (var
, val
);
3286 delete id
.cb
.decl_map
;
3289 /* Fixup VLA decls in BLOCK and subblocks if remapped variables are
3293 fixup_vla_decls (tree block
)
3295 for (tree var
= BLOCK_VARS (block
); var
; var
= DECL_CHAIN (var
))
3296 if (VAR_P (var
) && DECL_HAS_VALUE_EXPR_P (var
))
3298 tree val
= DECL_VALUE_EXPR (var
);
3300 if (!(TREE_CODE (val
) == INDIRECT_REF
3301 && VAR_P (TREE_OPERAND (val
, 0))
3302 && DECL_HAS_VALUE_EXPR_P (TREE_OPERAND (val
, 0))))
3305 /* Fully expand value expressions. This avoids having debug variables
3306 only referenced from them and that can be swept during GC. */
3307 val
= build1 (INDIRECT_REF
, TREE_TYPE (val
),
3308 DECL_VALUE_EXPR (TREE_OPERAND (val
, 0)));
3309 SET_DECL_VALUE_EXPR (var
, val
);
3312 for (tree sub
= BLOCK_SUBBLOCKS (block
); sub
; sub
= BLOCK_CHAIN (sub
))
3313 fixup_vla_decls (sub
);
3316 /* Fold the MEM_REF *E. */
3318 fold_mem_refs (tree
*const &e
, void *data ATTRIBUTE_UNUSED
)
3320 tree
*ref_p
= CONST_CAST2 (tree
*, const tree
*, (const tree
*)e
);
3321 *ref_p
= fold (*ref_p
);
3325 /* Given DECL, a nested function, build an initialization call for FIELD,
3326 the trampoline or descriptor for DECL, using FUNC as the function. */
3329 build_init_call_stmt (struct nesting_info
*info
, tree decl
, tree field
,
3332 tree arg1
, arg2
, arg3
, x
;
3334 gcc_assert (DECL_STATIC_CHAIN (decl
));
3335 arg3
= build_addr (info
->frame_decl
);
3337 arg2
= build_addr (decl
);
3339 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
),
3340 info
->frame_decl
, field
, NULL_TREE
);
3341 arg1
= build_addr (x
);
3343 return gimple_build_call (func
, 3, arg1
, arg2
, arg3
);
3346 /* Do "everything else" to clean up or complete state collected by the various
3347 walking passes -- create a field to hold the frame base address, lay out the
3348 types and decls, generate code to initialize the frame decl, store critical
3349 expressions in the struct function for rtl to find. */
3352 finalize_nesting_tree_1 (struct nesting_info
*root
)
3354 gimple_seq stmt_list
= NULL
;
3356 tree context
= root
->context
;
3357 struct function
*sf
;
3362 /* If we created a non-local frame type or decl, we need to lay them
3363 out at this time. */
3364 if (root
->frame_type
)
3366 /* Debugging information needs to compute the frame base address of the
3367 parent frame out of the static chain from the nested frame.
3369 The static chain is the address of the FRAME record, so one could
3370 imagine it would be possible to compute the frame base address just
3371 adding a constant offset to this address. Unfortunately, this is not
3372 possible: if the FRAME object has alignment constraints that are
3373 stronger than the stack, then the offset between the frame base and
3374 the FRAME object will be dynamic.
3376 What we do instead is to append a field to the FRAME object that holds
3377 the frame base address: then debug info just has to fetch this
3380 /* Debugging information will refer to the CFA as the frame base
3381 address: we will do the same here. */
3382 const tree frame_addr_fndecl
3383 = builtin_decl_explicit (BUILT_IN_DWARF_CFA
);
3385 /* Create a field in the FRAME record to hold the frame base address for
3386 this stack frame. Since it will be used only by the debugger, put it
3387 at the end of the record in order not to shift all other offsets. */
3388 tree fb_decl
= make_node (FIELD_DECL
);
3390 DECL_NAME (fb_decl
) = get_identifier ("FRAME_BASE.PARENT");
3391 TREE_TYPE (fb_decl
) = ptr_type_node
;
3392 TREE_ADDRESSABLE (fb_decl
) = 1;
3393 DECL_CONTEXT (fb_decl
) = root
->frame_type
;
3394 TYPE_FIELDS (root
->frame_type
) = chainon (TYPE_FIELDS (root
->frame_type
),
3397 /* In some cases the frame type will trigger the -Wpadded warning.
3398 This is not helpful; suppress it. */
3399 int save_warn_padded
= warn_padded
;
3401 layout_type (root
->frame_type
);
3402 warn_padded
= save_warn_padded
;
3403 layout_decl (root
->frame_decl
, 0);
3405 /* Initialize the frame base address field. If the builtin we need is
3406 not available, set it to NULL so that debugging information does not
3408 tree fb_ref
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
3409 root
->frame_decl
, fb_decl
, NULL_TREE
);
3412 if (frame_addr_fndecl
!= NULL_TREE
)
3414 gcall
*fb_gimple
= gimple_build_call (frame_addr_fndecl
, 1,
3416 gimple_stmt_iterator gsi
= gsi_last (stmt_list
);
3418 fb_tmp
= init_tmp_var_with_call (root
, &gsi
, fb_gimple
);
3421 fb_tmp
= build_int_cst (TREE_TYPE (fb_ref
), 0);
3422 gimple_seq_add_stmt (&stmt_list
,
3423 gimple_build_assign (fb_ref
, fb_tmp
));
3425 declare_vars (root
->frame_decl
,
3426 gimple_seq_first_stmt (gimple_body (context
)), true);
3429 /* If any parameters were referenced non-locally, then we need to insert
3430 a copy or a pointer. */
3431 if (root
->any_parm_remapped
)
3434 for (p
= DECL_ARGUMENTS (context
); p
; p
= DECL_CHAIN (p
))
3438 field
= lookup_field_for_decl (root
, p
, NO_INSERT
);
3442 if (use_pointer_in_frame (p
))
3447 /* If the assignment is from a non-register the stmt is
3448 not valid gimple. Make it so by using a temporary instead. */
3449 if (!is_gimple_reg (x
)
3450 && is_gimple_reg_type (TREE_TYPE (x
)))
3452 gimple_stmt_iterator gsi
= gsi_last (stmt_list
);
3453 x
= init_tmp_var (root
, x
, &gsi
);
3456 y
= build3 (COMPONENT_REF
, TREE_TYPE (field
),
3457 root
->frame_decl
, field
, NULL_TREE
);
3458 stmt
= gimple_build_assign (y
, x
);
3459 gimple_seq_add_stmt (&stmt_list
, stmt
);
3463 /* If a chain_field was created, then it needs to be initialized
3465 if (root
->chain_field
)
3467 tree x
= build3 (COMPONENT_REF
, TREE_TYPE (root
->chain_field
),
3468 root
->frame_decl
, root
->chain_field
, NULL_TREE
);
3469 stmt
= gimple_build_assign (x
, get_chain_decl (root
));
3470 gimple_seq_add_stmt (&stmt_list
, stmt
);
3473 /* If trampolines were created, then we need to initialize them. */
3474 if (root
->any_tramp_created
)
3476 struct nesting_info
*i
;
3477 for (i
= root
->inner
; i
; i
= i
->next
)
3481 field
= lookup_tramp_for_decl (root
, i
->context
, NO_INSERT
);
3485 x
= builtin_decl_implicit (BUILT_IN_INIT_TRAMPOLINE
);
3486 stmt
= build_init_call_stmt (root
, i
->context
, field
, x
);
3487 gimple_seq_add_stmt (&stmt_list
, stmt
);
3491 /* If descriptors were created, then we need to initialize them. */
3492 if (root
->any_descr_created
)
3494 struct nesting_info
*i
;
3495 for (i
= root
->inner
; i
; i
= i
->next
)
3499 field
= lookup_descr_for_decl (root
, i
->context
, NO_INSERT
);
3503 x
= builtin_decl_implicit (BUILT_IN_INIT_DESCRIPTOR
);
3504 stmt
= build_init_call_stmt (root
, i
->context
, field
, x
);
3505 gimple_seq_add_stmt (&stmt_list
, stmt
);
3509 /* If we created initialization statements, insert them. */
3513 annotate_all_with_location (stmt_list
, DECL_SOURCE_LOCATION (context
));
3514 bind
= gimple_seq_first_stmt_as_a_bind (gimple_body (context
));
3515 gimple_seq_add_seq (&stmt_list
, gimple_bind_body (bind
));
3516 gimple_bind_set_body (bind
, stmt_list
);
3519 /* If a chain_decl was created, then it needs to be registered with
3520 struct function so that it gets initialized from the static chain
3521 register at the beginning of the function. */
3522 sf
= DECL_STRUCT_FUNCTION (root
->context
);
3523 sf
->static_chain_decl
= root
->chain_decl
;
3525 /* Similarly for the non-local goto save area. */
3526 if (root
->nl_goto_field
)
3528 sf
->nonlocal_goto_save_area
3529 = get_frame_field (root
, context
, root
->nl_goto_field
, NULL
);
3530 sf
->has_nonlocal_label
= 1;
3533 /* Make sure all new local variables get inserted into the
3534 proper BIND_EXPR. */
3535 if (root
->new_local_var_chain
)
3536 declare_vars (root
->new_local_var_chain
,
3537 gimple_seq_first_stmt (gimple_body (root
->context
)),
3540 if (root
->debug_var_chain
)
3545 remap_vla_decls (DECL_INITIAL (root
->context
), root
);
3547 for (debug_var
= root
->debug_var_chain
; debug_var
;
3548 debug_var
= DECL_CHAIN (debug_var
))
3549 if (variably_modified_type_p (TREE_TYPE (debug_var
), NULL
))
3552 /* If there are any debug decls with variable length types,
3553 remap those types using other debug_var_chain variables. */
3556 struct nesting_copy_body_data id
;
3558 memset (&id
, 0, sizeof (id
));
3559 id
.cb
.copy_decl
= nesting_copy_decl
;
3560 id
.cb
.decl_map
= new hash_map
<tree
, tree
>;
3563 for (; debug_var
; debug_var
= DECL_CHAIN (debug_var
))
3564 if (variably_modified_type_p (TREE_TYPE (debug_var
), NULL
))
3566 tree type
= TREE_TYPE (debug_var
);
3567 tree newt
, t
= type
;
3568 struct nesting_info
*i
;
3570 for (i
= root
; i
; i
= i
->outer
)
3571 if (variably_modified_type_p (type
, i
->context
))
3577 id
.cb
.src_fn
= i
->context
;
3578 id
.cb
.dst_fn
= i
->context
;
3579 id
.cb
.src_cfun
= DECL_STRUCT_FUNCTION (root
->context
);
3581 TREE_TYPE (debug_var
) = newt
= remap_type (type
, &id
.cb
);
3582 while (POINTER_TYPE_P (newt
) && !TYPE_NAME (newt
))
3584 newt
= TREE_TYPE (newt
);
3587 if (TYPE_NAME (newt
)
3588 && TREE_CODE (TYPE_NAME (newt
)) == TYPE_DECL
3589 && DECL_ORIGINAL_TYPE (TYPE_NAME (newt
))
3591 && TYPE_NAME (newt
) == TYPE_NAME (t
))
3592 TYPE_NAME (newt
) = remap_decl (TYPE_NAME (newt
), &id
.cb
);
3595 delete id
.cb
.decl_map
;
3598 scope
= gimple_seq_first_stmt_as_a_bind (gimple_body (root
->context
));
3599 if (gimple_bind_block (scope
))
3600 declare_vars (root
->debug_var_chain
, scope
, true);
3602 BLOCK_VARS (DECL_INITIAL (root
->context
))
3603 = chainon (BLOCK_VARS (DECL_INITIAL (root
->context
)),
3604 root
->debug_var_chain
);
3607 fixup_vla_decls (DECL_INITIAL (root
->context
));
3609 /* Fold the rewritten MEM_REF trees. */
3610 root
->mem_refs
->traverse
<void *, fold_mem_refs
> (NULL
);
3612 /* Dump the translated tree function. */
3615 fputs ("\n\n", dump_file
);
3616 dump_function_to_file (root
->context
, dump_file
, dump_flags
);
3621 finalize_nesting_tree (struct nesting_info
*root
)
3623 struct nesting_info
*n
;
3624 FOR_EACH_NEST_INFO (n
, root
)
3625 finalize_nesting_tree_1 (n
);
3628 /* Unnest the nodes and pass them to cgraph. */
3631 unnest_nesting_tree_1 (struct nesting_info
*root
)
3633 struct cgraph_node
*node
= cgraph_node::get (root
->context
);
3635 /* For nested functions update the cgraph to reflect unnesting.
3636 We also delay finalizing of these functions up to this point. */
3637 if (nested_function_info::get (node
)->origin
)
3639 unnest_function (node
);
3641 cgraph_node::finalize_function (root
->context
, true);
3646 unnest_nesting_tree (struct nesting_info
*root
)
3648 struct nesting_info
*n
;
3649 FOR_EACH_NEST_INFO (n
, root
)
3650 unnest_nesting_tree_1 (n
);
3653 /* Free the data structures allocated during this pass. */
3656 free_nesting_tree (struct nesting_info
*root
)
3658 struct nesting_info
*node
, *next
;
3660 node
= iter_nestinfo_start (root
);
3663 next
= iter_nestinfo_next (node
);
3664 delete node
->var_map
;
3665 delete node
->field_map
;
3666 delete node
->mem_refs
;
3673 /* Gimplify a function and all its nested functions. */
3675 gimplify_all_functions (struct cgraph_node
*root
)
3677 struct cgraph_node
*iter
;
3678 if (!gimple_body (root
->decl
))
3679 gimplify_function_tree (root
->decl
);
3680 for (iter
= first_nested_function (root
); iter
;
3681 iter
= next_nested_function (iter
))
3683 gimplify_all_functions (iter
);
3686 /* Main entry point for this pass. Process FNDECL and all of its nested
3687 subroutines and turn them into something less tightly bound. */
3690 lower_nested_functions (tree fndecl
)
3692 struct cgraph_node
*cgn
;
3693 struct nesting_info
*root
;
3695 /* If there are no nested functions, there's nothing to do. */
3696 cgn
= cgraph_node::get (fndecl
);
3697 if (!first_nested_function (cgn
))
3700 gimplify_all_functions (cgn
);
3702 set_dump_file (dump_begin (TDI_nested
, &dump_flags
));
3704 fprintf (dump_file
, "\n;; Function %s\n\n",
3705 lang_hooks
.decl_printable_name (fndecl
, 2));
3707 bitmap_obstack_initialize (&nesting_info_bitmap_obstack
);
3708 root
= create_nesting_tree (cgn
);
3710 walk_all_functions (convert_nonlocal_reference_stmt
,
3711 convert_nonlocal_reference_op
,
3713 walk_all_functions (convert_local_reference_stmt
,
3714 convert_local_reference_op
,
3716 walk_all_functions (convert_nl_goto_reference
, NULL
, root
);
3717 walk_all_functions (convert_nl_goto_receiver
, NULL
, root
);
3719 convert_all_function_calls (root
);
3720 finalize_nesting_tree (root
);
3721 unnest_nesting_tree (root
);
3723 free_nesting_tree (root
);
3724 bitmap_obstack_release (&nesting_info_bitmap_obstack
);
3728 dump_end (TDI_nested
, dump_file
);
3729 set_dump_file (NULL
);
3733 #include "gt-tree-nested.h"