1 /* Nested function decomposition for GIMPLE.
2 Copyright (C) 2004-2014 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"
25 #include "stringpool.h"
26 #include "stor-layout.h"
32 #include "hard-reg-set.h"
35 #include "tree-dump.h"
36 #include "tree-inline.h"
38 #include "basic-block.h"
39 #include "tree-ssa-alias.h"
40 #include "internal-fn.h"
41 #include "gimple-expr.h"
45 #include "gimple-iterator.h"
46 #include "gimple-walk.h"
47 #include "tree-iterator.h"
50 #include "plugin-api.h"
54 #include "expr.h" /* FIXME: For STACK_SAVEAREA_MODE and SAVE_NONLOCAL. */
55 #include "langhooks.h"
56 #include "gimple-low.h"
59 /* The object of this pass is to lower the representation of a set of nested
60 functions in order to expose all of the gory details of the various
61 nonlocal references. We want to do this sooner rather than later, in
62 order to give us more freedom in emitting all of the functions in question.
64 Back in olden times, when gcc was young, we developed an insanely
65 complicated scheme whereby variables which were referenced nonlocally
66 were forced to live in the stack of the declaring function, and then
67 the nested functions magically discovered where these variables were
68 placed. In order for this scheme to function properly, it required
69 that the outer function be partially expanded, then we switch to
70 compiling the inner function, and once done with those we switch back
71 to compiling the outer function. Such delicate ordering requirements
72 makes it difficult to do whole translation unit optimizations
73 involving such functions.
75 The implementation here is much more direct. Everything that can be
76 referenced by an inner function is a member of an explicitly created
77 structure herein called the "nonlocal frame struct". The incoming
78 static chain for a nested function is a pointer to this struct in
79 the parent. In this way, we settle on known offsets from a known
80 base, and so are decoupled from the logic that places objects in the
81 function's stack frame. More importantly, we don't have to wait for
82 that to happen -- since the compilation of the inner function is no
83 longer tied to a real stack frame, the nonlocal frame struct can be
84 allocated anywhere. Which means that the outer function is now
87 Theory of operation here is very simple. Iterate over all the
88 statements in all the functions (depth first) several times,
89 allocating structures and fields on demand. In general we want to
90 examine inner functions first, so that we can avoid making changes
91 to outer functions which are unnecessary.
93 The order of the passes matters a bit, in that later passes will be
94 skipped if it is discovered that the functions don't actually interact
95 at all. That is, they're nested in the lexical sense but could have
96 been written as independent functions without change. */
101 struct nesting_info
*outer
;
102 struct nesting_info
*inner
;
103 struct nesting_info
*next
;
105 hash_map
<tree
, tree
> *field_map
;
106 hash_map
<tree
, tree
> *var_map
;
107 hash_set
<tree
*> *mem_refs
;
108 bitmap suppress_expansion
;
111 tree new_local_var_chain
;
112 tree debug_var_chain
;
119 bool any_parm_remapped
;
120 bool any_tramp_created
;
121 char static_chain_added
;
125 /* Iterate over the nesting tree, starting with ROOT, depth first. */
127 static inline struct nesting_info
*
128 iter_nestinfo_start (struct nesting_info
*root
)
135 static inline struct nesting_info
*
136 iter_nestinfo_next (struct nesting_info
*node
)
139 return iter_nestinfo_start (node
->next
);
143 #define FOR_EACH_NEST_INFO(I, ROOT) \
144 for ((I) = iter_nestinfo_start (ROOT); (I); (I) = iter_nestinfo_next (I))
146 /* Obstack used for the bitmaps in the struct above. */
147 static struct bitmap_obstack nesting_info_bitmap_obstack
;
150 /* We're working in so many different function contexts simultaneously,
151 that create_tmp_var is dangerous. Prevent mishap. */
152 #define create_tmp_var cant_use_create_tmp_var_here_dummy
154 /* Like create_tmp_var, except record the variable for registration at
155 the given nesting level. */
158 create_tmp_var_for (struct nesting_info
*info
, tree type
, const char *prefix
)
162 /* If the type is of variable size or a type which must be created by the
163 frontend, something is wrong. Note that we explicitly allow
164 incomplete types here, since we create them ourselves here. */
165 gcc_assert (!TREE_ADDRESSABLE (type
));
166 gcc_assert (!TYPE_SIZE_UNIT (type
)
167 || TREE_CODE (TYPE_SIZE_UNIT (type
)) == INTEGER_CST
);
169 tmp_var
= create_tmp_var_raw (type
, prefix
);
170 DECL_CONTEXT (tmp_var
) = info
->context
;
171 DECL_CHAIN (tmp_var
) = info
->new_local_var_chain
;
172 DECL_SEEN_IN_BIND_EXPR_P (tmp_var
) = 1;
173 if (TREE_CODE (type
) == COMPLEX_TYPE
174 || TREE_CODE (type
) == VECTOR_TYPE
)
175 DECL_GIMPLE_REG_P (tmp_var
) = 1;
177 info
->new_local_var_chain
= tmp_var
;
182 /* Take the address of EXP to be used within function CONTEXT.
183 Mark it for addressability as necessary. */
186 build_addr (tree exp
, tree context
)
192 while (handled_component_p (base
))
193 base
= TREE_OPERAND (base
, 0);
196 TREE_ADDRESSABLE (base
) = 1;
198 /* Building the ADDR_EXPR will compute a set of properties for
199 that ADDR_EXPR. Those properties are unfortunately context
200 specific, i.e., they are dependent on CURRENT_FUNCTION_DECL.
202 Temporarily set CURRENT_FUNCTION_DECL to the desired context,
203 build the ADDR_EXPR, then restore CURRENT_FUNCTION_DECL. That
204 way the properties are for the ADDR_EXPR are computed properly. */
205 save_context
= current_function_decl
;
206 current_function_decl
= context
;
207 retval
= build_fold_addr_expr (exp
);
208 current_function_decl
= save_context
;
212 /* Insert FIELD into TYPE, sorted by alignment requirements. */
215 insert_field_into_struct (tree type
, tree field
)
219 DECL_CONTEXT (field
) = type
;
221 for (p
= &TYPE_FIELDS (type
); *p
; p
= &DECL_CHAIN (*p
))
222 if (DECL_ALIGN (field
) >= DECL_ALIGN (*p
))
225 DECL_CHAIN (field
) = *p
;
228 /* Set correct alignment for frame struct type. */
229 if (TYPE_ALIGN (type
) < DECL_ALIGN (field
))
230 TYPE_ALIGN (type
) = DECL_ALIGN (field
);
233 /* Build or return the RECORD_TYPE that describes the frame state that is
234 shared between INFO->CONTEXT and its nested functions. This record will
235 not be complete until finalize_nesting_tree; up until that point we'll
236 be adding fields as necessary.
238 We also build the DECL that represents this frame in the function. */
241 get_frame_type (struct nesting_info
*info
)
243 tree type
= info
->frame_type
;
248 type
= make_node (RECORD_TYPE
);
250 name
= concat ("FRAME.",
251 IDENTIFIER_POINTER (DECL_NAME (info
->context
)),
253 TYPE_NAME (type
) = get_identifier (name
);
256 info
->frame_type
= type
;
257 info
->frame_decl
= create_tmp_var_for (info
, type
, "FRAME");
258 DECL_NONLOCAL_FRAME (info
->frame_decl
) = 1;
260 /* ??? Always make it addressable for now, since it is meant to
261 be pointed to by the static chain pointer. This pessimizes
262 when it turns out that no static chains are needed because
263 the nested functions referencing non-local variables are not
264 reachable, but the true pessimization is to create the non-
265 local frame structure in the first place. */
266 TREE_ADDRESSABLE (info
->frame_decl
) = 1;
271 /* Return true if DECL should be referenced by pointer in the non-local
275 use_pointer_in_frame (tree decl
)
277 if (TREE_CODE (decl
) == PARM_DECL
)
279 /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable
280 sized decls, and inefficient to copy large aggregates. Don't bother
281 moving anything but scalar variables. */
282 return AGGREGATE_TYPE_P (TREE_TYPE (decl
));
286 /* Variable sized types make things "interesting" in the frame. */
287 return DECL_SIZE (decl
) == NULL
|| !TREE_CONSTANT (DECL_SIZE (decl
));
291 /* Given DECL, a non-locally accessed variable, find or create a field
292 in the non-local frame structure for the given nesting context. */
295 lookup_field_for_decl (struct nesting_info
*info
, tree decl
,
296 enum insert_option insert
)
298 if (insert
== NO_INSERT
)
300 tree
*slot
= info
->field_map
->get (decl
);
301 return slot
? *slot
: NULL_TREE
;
304 tree
*slot
= &info
->field_map
->get_or_insert (decl
);
307 tree field
= make_node (FIELD_DECL
);
308 DECL_NAME (field
) = DECL_NAME (decl
);
310 if (use_pointer_in_frame (decl
))
312 TREE_TYPE (field
) = build_pointer_type (TREE_TYPE (decl
));
313 DECL_ALIGN (field
) = TYPE_ALIGN (TREE_TYPE (field
));
314 DECL_NONADDRESSABLE_P (field
) = 1;
318 TREE_TYPE (field
) = TREE_TYPE (decl
);
319 DECL_SOURCE_LOCATION (field
) = DECL_SOURCE_LOCATION (decl
);
320 DECL_ALIGN (field
) = DECL_ALIGN (decl
);
321 DECL_USER_ALIGN (field
) = DECL_USER_ALIGN (decl
);
322 TREE_ADDRESSABLE (field
) = TREE_ADDRESSABLE (decl
);
323 DECL_NONADDRESSABLE_P (field
) = !TREE_ADDRESSABLE (decl
);
324 TREE_THIS_VOLATILE (field
) = TREE_THIS_VOLATILE (decl
);
327 insert_field_into_struct (get_frame_type (info
), field
);
330 if (TREE_CODE (decl
) == PARM_DECL
)
331 info
->any_parm_remapped
= true;
337 /* Build or return the variable that holds the static chain within
338 INFO->CONTEXT. This variable may only be used within INFO->CONTEXT. */
341 get_chain_decl (struct nesting_info
*info
)
343 tree decl
= info
->chain_decl
;
349 type
= get_frame_type (info
->outer
);
350 type
= build_pointer_type (type
);
352 /* Note that this variable is *not* entered into any BIND_EXPR;
353 the construction of this variable is handled specially in
354 expand_function_start and initialize_inlined_parameters.
355 Note also that it's represented as a parameter. This is more
356 close to the truth, since the initial value does come from
358 decl
= build_decl (DECL_SOURCE_LOCATION (info
->context
),
359 PARM_DECL
, create_tmp_var_name ("CHAIN"), type
);
360 DECL_ARTIFICIAL (decl
) = 1;
361 DECL_IGNORED_P (decl
) = 1;
362 TREE_USED (decl
) = 1;
363 DECL_CONTEXT (decl
) = info
->context
;
364 DECL_ARG_TYPE (decl
) = type
;
366 /* Tell tree-inline.c that we never write to this variable, so
367 it can copy-prop the replacement value immediately. */
368 TREE_READONLY (decl
) = 1;
370 info
->chain_decl
= decl
;
373 && (dump_flags
& TDF_DETAILS
)
374 && !DECL_STATIC_CHAIN (info
->context
))
375 fprintf (dump_file
, "Setting static-chain for %s\n",
376 lang_hooks
.decl_printable_name (info
->context
, 2));
378 DECL_STATIC_CHAIN (info
->context
) = 1;
383 /* Build or return the field within the non-local frame state that holds
384 the static chain for INFO->CONTEXT. This is the way to walk back up
385 multiple nesting levels. */
388 get_chain_field (struct nesting_info
*info
)
390 tree field
= info
->chain_field
;
394 tree type
= build_pointer_type (get_frame_type (info
->outer
));
396 field
= make_node (FIELD_DECL
);
397 DECL_NAME (field
) = get_identifier ("__chain");
398 TREE_TYPE (field
) = type
;
399 DECL_ALIGN (field
) = TYPE_ALIGN (type
);
400 DECL_NONADDRESSABLE_P (field
) = 1;
402 insert_field_into_struct (get_frame_type (info
), field
);
404 info
->chain_field
= field
;
407 && (dump_flags
& TDF_DETAILS
)
408 && !DECL_STATIC_CHAIN (info
->context
))
409 fprintf (dump_file
, "Setting static-chain for %s\n",
410 lang_hooks
.decl_printable_name (info
->context
, 2));
412 DECL_STATIC_CHAIN (info
->context
) = 1;
417 /* Initialize a new temporary with the GIMPLE_CALL STMT. */
420 init_tmp_var_with_call (struct nesting_info
*info
, gimple_stmt_iterator
*gsi
,
425 t
= create_tmp_var_for (info
, gimple_call_return_type (call
), NULL
);
426 gimple_call_set_lhs (call
, t
);
427 if (! gsi_end_p (*gsi
))
428 gimple_set_location (call
, gimple_location (gsi_stmt (*gsi
)));
429 gsi_insert_before (gsi
, call
, GSI_SAME_STMT
);
435 /* Copy EXP into a temporary. Allocate the temporary in the context of
436 INFO and insert the initialization statement before GSI. */
439 init_tmp_var (struct nesting_info
*info
, tree exp
, gimple_stmt_iterator
*gsi
)
444 t
= create_tmp_var_for (info
, TREE_TYPE (exp
), NULL
);
445 stmt
= gimple_build_assign (t
, exp
);
446 if (! gsi_end_p (*gsi
))
447 gimple_set_location (stmt
, gimple_location (gsi_stmt (*gsi
)));
448 gsi_insert_before_without_update (gsi
, stmt
, GSI_SAME_STMT
);
454 /* Similarly, but only do so to force EXP to satisfy is_gimple_val. */
457 gsi_gimplify_val (struct nesting_info
*info
, tree exp
,
458 gimple_stmt_iterator
*gsi
)
460 if (is_gimple_val (exp
))
463 return init_tmp_var (info
, exp
, gsi
);
466 /* Similarly, but copy from the temporary and insert the statement
467 after the iterator. */
470 save_tmp_var (struct nesting_info
*info
, tree exp
, gimple_stmt_iterator
*gsi
)
475 t
= create_tmp_var_for (info
, TREE_TYPE (exp
), NULL
);
476 stmt
= gimple_build_assign (exp
, t
);
477 if (! gsi_end_p (*gsi
))
478 gimple_set_location (stmt
, gimple_location (gsi_stmt (*gsi
)));
479 gsi_insert_after_without_update (gsi
, stmt
, GSI_SAME_STMT
);
484 /* Build or return the type used to represent a nested function trampoline. */
486 static GTY(()) tree trampoline_type
;
489 get_trampoline_type (struct nesting_info
*info
)
491 unsigned align
, size
;
495 return trampoline_type
;
497 align
= TRAMPOLINE_ALIGNMENT
;
498 size
= TRAMPOLINE_SIZE
;
500 /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
501 then allocate extra space so that we can do dynamic alignment. */
502 if (align
> STACK_BOUNDARY
)
504 size
+= ((align
/BITS_PER_UNIT
) - 1) & -(STACK_BOUNDARY
/BITS_PER_UNIT
);
505 align
= STACK_BOUNDARY
;
508 t
= build_index_type (size_int (size
- 1));
509 t
= build_array_type (char_type_node
, t
);
510 t
= build_decl (DECL_SOURCE_LOCATION (info
->context
),
511 FIELD_DECL
, get_identifier ("__data"), t
);
512 DECL_ALIGN (t
) = align
;
513 DECL_USER_ALIGN (t
) = 1;
515 trampoline_type
= make_node (RECORD_TYPE
);
516 TYPE_NAME (trampoline_type
) = get_identifier ("__builtin_trampoline");
517 TYPE_FIELDS (trampoline_type
) = t
;
518 layout_type (trampoline_type
);
519 DECL_CONTEXT (t
) = trampoline_type
;
521 return trampoline_type
;
524 /* Given DECL, a nested function, find or create a field in the non-local
525 frame structure for a trampoline for this function. */
528 lookup_tramp_for_decl (struct nesting_info
*info
, tree decl
,
529 enum insert_option insert
)
531 if (insert
== NO_INSERT
)
533 tree
*slot
= info
->var_map
->get (decl
);
534 return slot
? *slot
: NULL_TREE
;
537 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
540 tree field
= make_node (FIELD_DECL
);
541 DECL_NAME (field
) = DECL_NAME (decl
);
542 TREE_TYPE (field
) = get_trampoline_type (info
);
543 TREE_ADDRESSABLE (field
) = 1;
545 insert_field_into_struct (get_frame_type (info
), field
);
548 info
->any_tramp_created
= true;
554 /* Build or return the field within the non-local frame state that holds
555 the non-local goto "jmp_buf". The buffer itself is maintained by the
556 rtl middle-end as dynamic stack space is allocated. */
559 get_nl_goto_field (struct nesting_info
*info
)
561 tree field
= info
->nl_goto_field
;
567 /* For __builtin_nonlocal_goto, we need N words. The first is the
568 frame pointer, the rest is for the target's stack pointer save
569 area. The number of words is controlled by STACK_SAVEAREA_MODE;
570 not the best interface, but it'll do for now. */
571 if (Pmode
== ptr_mode
)
572 type
= ptr_type_node
;
574 type
= lang_hooks
.types
.type_for_mode (Pmode
, 1);
576 size
= GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL
));
577 size
= size
/ GET_MODE_SIZE (Pmode
);
580 type
= build_array_type
581 (type
, build_index_type (size_int (size
)));
583 field
= make_node (FIELD_DECL
);
584 DECL_NAME (field
) = get_identifier ("__nl_goto_buf");
585 TREE_TYPE (field
) = type
;
586 DECL_ALIGN (field
) = TYPE_ALIGN (type
);
587 TREE_ADDRESSABLE (field
) = 1;
589 insert_field_into_struct (get_frame_type (info
), field
);
591 info
->nl_goto_field
= field
;
597 /* Invoke CALLBACK on all statements of GIMPLE sequence *PSEQ. */
600 walk_body (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
601 struct nesting_info
*info
, gimple_seq
*pseq
)
603 struct walk_stmt_info wi
;
605 memset (&wi
, 0, sizeof (wi
));
608 walk_gimple_seq_mod (pseq
, callback_stmt
, callback_op
, &wi
);
612 /* Invoke CALLBACK_STMT/CALLBACK_OP on all statements of INFO->CONTEXT. */
615 walk_function (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
616 struct nesting_info
*info
)
618 gimple_seq body
= gimple_body (info
->context
);
619 walk_body (callback_stmt
, callback_op
, info
, &body
);
620 gimple_set_body (info
->context
, body
);
623 /* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body. */
626 walk_gimple_omp_for (gimple for_stmt
,
627 walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
628 struct nesting_info
*info
)
630 struct walk_stmt_info wi
;
635 walk_body (callback_stmt
, callback_op
, info
, gimple_omp_for_pre_body_ptr (for_stmt
));
638 memset (&wi
, 0, sizeof (wi
));
640 wi
.gsi
= gsi_last (seq
);
642 for (i
= 0; i
< gimple_omp_for_collapse (for_stmt
); i
++)
645 walk_tree (gimple_omp_for_index_ptr (for_stmt
, i
), callback_op
,
649 walk_tree (gimple_omp_for_initial_ptr (for_stmt
, i
), callback_op
,
654 walk_tree (gimple_omp_for_final_ptr (for_stmt
, i
), callback_op
,
657 t
= gimple_omp_for_incr (for_stmt
, i
);
658 gcc_assert (BINARY_CLASS_P (t
));
660 walk_tree (&TREE_OPERAND (t
, 0), callback_op
, &wi
, NULL
);
663 walk_tree (&TREE_OPERAND (t
, 1), callback_op
, &wi
, NULL
);
666 seq
= gsi_seq (wi
.gsi
);
667 if (!gimple_seq_empty_p (seq
))
669 gimple_seq pre_body
= gimple_omp_for_pre_body (for_stmt
);
670 annotate_all_with_location (seq
, gimple_location (for_stmt
));
671 gimple_seq_add_seq (&pre_body
, seq
);
672 gimple_omp_for_set_pre_body (for_stmt
, pre_body
);
676 /* Similarly for ROOT and all functions nested underneath, depth first. */
679 walk_all_functions (walk_stmt_fn callback_stmt
, walk_tree_fn callback_op
,
680 struct nesting_info
*root
)
682 struct nesting_info
*n
;
683 FOR_EACH_NEST_INFO (n
, root
)
684 walk_function (callback_stmt
, callback_op
, n
);
688 /* We have to check for a fairly pathological case. The operands of function
689 nested function are to be interpreted in the context of the enclosing
690 function. So if any are variably-sized, they will get remapped when the
691 enclosing function is inlined. But that remapping would also have to be
692 done in the types of the PARM_DECLs of the nested function, meaning the
693 argument types of that function will disagree with the arguments in the
694 calls to that function. So we'd either have to make a copy of the nested
695 function corresponding to each time the enclosing function was inlined or
696 add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
697 function. The former is not practical. The latter would still require
698 detecting this case to know when to add the conversions. So, for now at
699 least, we don't inline such an enclosing function.
701 We have to do that check recursively, so here return indicating whether
702 FNDECL has such a nested function. ORIG_FN is the function we were
703 trying to inline to use for checking whether any argument is variably
704 modified by anything in it.
706 It would be better to do this in tree-inline.c so that we could give
707 the appropriate warning for why a function can't be inlined, but that's
708 too late since the nesting structure has already been flattened and
709 adding a flag just to record this fact seems a waste of a flag. */
712 check_for_nested_with_variably_modified (tree fndecl
, tree orig_fndecl
)
714 struct cgraph_node
*cgn
= cgraph_node::get (fndecl
);
717 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
719 for (arg
= DECL_ARGUMENTS (cgn
->decl
); arg
; arg
= DECL_CHAIN (arg
))
720 if (variably_modified_type_p (TREE_TYPE (arg
), orig_fndecl
))
723 if (check_for_nested_with_variably_modified (cgn
->decl
,
731 /* Construct our local datastructure describing the function nesting
732 tree rooted by CGN. */
734 static struct nesting_info
*
735 create_nesting_tree (struct cgraph_node
*cgn
)
737 struct nesting_info
*info
= XCNEW (struct nesting_info
);
738 info
->field_map
= new hash_map
<tree
, tree
>;
739 info
->var_map
= new hash_map
<tree
, tree
>;
740 info
->mem_refs
= new hash_set
<tree
*>;
741 info
->suppress_expansion
= BITMAP_ALLOC (&nesting_info_bitmap_obstack
);
742 info
->context
= cgn
->decl
;
744 for (cgn
= cgn
->nested
; cgn
; cgn
= cgn
->next_nested
)
746 struct nesting_info
*sub
= create_nesting_tree (cgn
);
748 sub
->next
= info
->inner
;
752 /* See discussion at check_for_nested_with_variably_modified for a
753 discussion of why this has to be here. */
754 if (check_for_nested_with_variably_modified (info
->context
, info
->context
))
755 DECL_UNINLINABLE (info
->context
) = true;
760 /* Return an expression computing the static chain for TARGET_CONTEXT
761 from INFO->CONTEXT. Insert any necessary computations before TSI. */
764 get_static_chain (struct nesting_info
*info
, tree target_context
,
765 gimple_stmt_iterator
*gsi
)
767 struct nesting_info
*i
;
770 if (info
->context
== target_context
)
772 x
= build_addr (info
->frame_decl
, target_context
);
776 x
= get_chain_decl (info
);
778 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
780 tree field
= get_chain_field (i
);
782 x
= build_simple_mem_ref (x
);
783 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
784 x
= init_tmp_var (info
, x
, gsi
);
792 /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
793 frame as seen from INFO->CONTEXT. Insert any necessary computations
797 get_frame_field (struct nesting_info
*info
, tree target_context
,
798 tree field
, gimple_stmt_iterator
*gsi
)
800 struct nesting_info
*i
;
803 if (info
->context
== target_context
)
805 /* Make sure frame_decl gets created. */
806 (void) get_frame_type (info
);
807 x
= info
->frame_decl
;
811 x
= get_chain_decl (info
);
813 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
815 tree field
= get_chain_field (i
);
817 x
= build_simple_mem_ref (x
);
818 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
819 x
= init_tmp_var (info
, x
, gsi
);
822 x
= build_simple_mem_ref (x
);
825 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
829 static void note_nonlocal_vla_type (struct nesting_info
*info
, tree type
);
831 /* A subroutine of convert_nonlocal_reference_op. Create a local variable
832 in the nested function with DECL_VALUE_EXPR set to reference the true
833 variable in the parent function. This is used both for debug info
834 and in OpenMP lowering. */
837 get_nonlocal_debug_decl (struct nesting_info
*info
, tree decl
)
840 struct nesting_info
*i
;
841 tree x
, field
, new_decl
;
843 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
848 target_context
= decl_function_context (decl
);
850 /* A copy of the code in get_frame_field, but without the temporaries. */
851 if (info
->context
== target_context
)
853 /* Make sure frame_decl gets created. */
854 (void) get_frame_type (info
);
855 x
= info
->frame_decl
;
860 x
= get_chain_decl (info
);
861 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
863 field
= get_chain_field (i
);
864 x
= build_simple_mem_ref (x
);
865 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
867 x
= build_simple_mem_ref (x
);
870 field
= lookup_field_for_decl (i
, decl
, INSERT
);
871 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
872 if (use_pointer_in_frame (decl
))
873 x
= build_simple_mem_ref (x
);
875 /* ??? We should be remapping types as well, surely. */
876 new_decl
= build_decl (DECL_SOURCE_LOCATION (decl
),
877 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
878 DECL_CONTEXT (new_decl
) = info
->context
;
879 DECL_ARTIFICIAL (new_decl
) = DECL_ARTIFICIAL (decl
);
880 DECL_IGNORED_P (new_decl
) = DECL_IGNORED_P (decl
);
881 TREE_THIS_VOLATILE (new_decl
) = TREE_THIS_VOLATILE (decl
);
882 TREE_SIDE_EFFECTS (new_decl
) = TREE_SIDE_EFFECTS (decl
);
883 TREE_READONLY (new_decl
) = TREE_READONLY (decl
);
884 TREE_ADDRESSABLE (new_decl
) = TREE_ADDRESSABLE (decl
);
885 DECL_SEEN_IN_BIND_EXPR_P (new_decl
) = 1;
886 if ((TREE_CODE (decl
) == PARM_DECL
887 || TREE_CODE (decl
) == RESULT_DECL
888 || TREE_CODE (decl
) == VAR_DECL
)
889 && DECL_BY_REFERENCE (decl
))
890 DECL_BY_REFERENCE (new_decl
) = 1;
892 SET_DECL_VALUE_EXPR (new_decl
, x
);
893 DECL_HAS_VALUE_EXPR_P (new_decl
) = 1;
896 DECL_CHAIN (new_decl
) = info
->debug_var_chain
;
897 info
->debug_var_chain
= new_decl
;
900 && info
->context
!= target_context
901 && variably_modified_type_p (TREE_TYPE (decl
), NULL
))
902 note_nonlocal_vla_type (info
, TREE_TYPE (decl
));
908 /* Callback for walk_gimple_stmt, rewrite all references to VAR
909 and PARM_DECLs that belong to outer functions.
911 The rewrite will involve some number of structure accesses back up
912 the static chain. E.g. for a variable FOO up one nesting level it'll
913 be CHAIN->FOO. For two levels it'll be CHAIN->__chain->FOO. Further
914 indirections apply to decls for which use_pointer_in_frame is true. */
917 convert_nonlocal_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
919 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
920 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
924 switch (TREE_CODE (t
))
927 /* Non-automatic variables are never processed. */
928 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
933 if (decl_function_context (t
) != info
->context
)
938 x
= get_nonlocal_debug_decl (info
, t
);
939 if (!bitmap_bit_p (info
->suppress_expansion
, DECL_UID (t
)))
941 tree target_context
= decl_function_context (t
);
942 struct nesting_info
*i
;
943 for (i
= info
->outer
; i
->context
!= target_context
; i
= i
->outer
)
945 x
= lookup_field_for_decl (i
, t
, INSERT
);
946 x
= get_frame_field (info
, target_context
, x
, &wi
->gsi
);
947 if (use_pointer_in_frame (t
))
949 x
= init_tmp_var (info
, x
, &wi
->gsi
);
950 x
= build_simple_mem_ref (x
);
957 x
= save_tmp_var (info
, x
, &wi
->gsi
);
959 x
= init_tmp_var (info
, x
, &wi
->gsi
);
967 /* We're taking the address of a label from a parent function, but
968 this is not itself a non-local goto. Mark the label such that it
969 will not be deleted, much as we would with a label address in
971 if (decl_function_context (t
) != info
->context
)
972 FORCED_LABEL (t
) = 1;
977 bool save_val_only
= wi
->val_only
;
979 wi
->val_only
= false;
982 walk_tree (&TREE_OPERAND (t
, 0), convert_nonlocal_reference_op
, wi
, 0);
989 /* If we changed anything, we might no longer be directly
990 referencing a decl. */
991 save_context
= current_function_decl
;
992 current_function_decl
= info
->context
;
993 recompute_tree_invariant_for_addr_expr (t
);
994 current_function_decl
= save_context
;
996 /* If the callback converted the address argument in a context
997 where we only accept variables (and min_invariant, presumably),
998 then compute the address into a temporary. */
1000 *tp
= gsi_gimplify_val ((struct nesting_info
*) wi
->info
,
1010 case ARRAY_RANGE_REF
:
1012 /* Go down this entire nest and just look at the final prefix and
1013 anything that describes the references. Otherwise, we lose track
1014 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1015 wi
->val_only
= true;
1017 for (; handled_component_p (t
); tp
= &TREE_OPERAND (t
, 0), t
= *tp
)
1019 if (TREE_CODE (t
) == COMPONENT_REF
)
1020 walk_tree (&TREE_OPERAND (t
, 2), convert_nonlocal_reference_op
, wi
,
1022 else if (TREE_CODE (t
) == ARRAY_REF
1023 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
1025 walk_tree (&TREE_OPERAND (t
, 1), convert_nonlocal_reference_op
,
1027 walk_tree (&TREE_OPERAND (t
, 2), convert_nonlocal_reference_op
,
1029 walk_tree (&TREE_OPERAND (t
, 3), convert_nonlocal_reference_op
,
1033 wi
->val_only
= false;
1034 walk_tree (tp
, convert_nonlocal_reference_op
, wi
, NULL
);
1037 case VIEW_CONVERT_EXPR
:
1038 /* Just request to look at the subtrees, leaving val_only and lhs
1039 untouched. This might actually be for !val_only + lhs, in which
1040 case we don't want to force a replacement by a temporary. */
1045 if (!IS_TYPE_OR_DECL_P (t
))
1048 wi
->val_only
= true;
1057 static tree
convert_nonlocal_reference_stmt (gimple_stmt_iterator
*, bool *,
1058 struct walk_stmt_info
*);
1060 /* Helper for convert_nonlocal_references, rewrite all references to VAR
1061 and PARM_DECLs that belong to outer functions. */
1064 convert_nonlocal_omp_clauses (tree
*pclauses
, struct walk_stmt_info
*wi
)
1066 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1067 bool need_chain
= false, need_stmts
= false;
1070 bitmap new_suppress
;
1072 new_suppress
= BITMAP_GGC_ALLOC ();
1073 bitmap_copy (new_suppress
, info
->suppress_expansion
);
1075 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1077 switch (OMP_CLAUSE_CODE (clause
))
1079 case OMP_CLAUSE_REDUCTION
:
1080 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1082 goto do_decl_clause
;
1084 case OMP_CLAUSE_LASTPRIVATE
:
1085 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
))
1087 goto do_decl_clause
;
1089 case OMP_CLAUSE_LINEAR
:
1090 if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
))
1092 wi
->val_only
= true;
1094 convert_nonlocal_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause
),
1096 goto do_decl_clause
;
1098 case OMP_CLAUSE_PRIVATE
:
1099 case OMP_CLAUSE_FIRSTPRIVATE
:
1100 case OMP_CLAUSE_COPYPRIVATE
:
1101 case OMP_CLAUSE_SHARED
:
1103 decl
= OMP_CLAUSE_DECL (clause
);
1104 if (TREE_CODE (decl
) == VAR_DECL
1105 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1107 if (decl_function_context (decl
) != info
->context
)
1109 bitmap_set_bit (new_suppress
, DECL_UID (decl
));
1110 OMP_CLAUSE_DECL (clause
) = get_nonlocal_debug_decl (info
, decl
);
1111 if (OMP_CLAUSE_CODE (clause
) != OMP_CLAUSE_PRIVATE
)
1116 case OMP_CLAUSE_SCHEDULE
:
1117 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
) == NULL
)
1120 case OMP_CLAUSE_FINAL
:
1122 case OMP_CLAUSE_NUM_THREADS
:
1123 case OMP_CLAUSE_DEPEND
:
1124 case OMP_CLAUSE_DEVICE
:
1125 case OMP_CLAUSE_NUM_TEAMS
:
1126 case OMP_CLAUSE_THREAD_LIMIT
:
1127 case OMP_CLAUSE_SAFELEN
:
1128 case OMP_CLAUSE__CILK_FOR_COUNT_
:
1129 wi
->val_only
= true;
1131 convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
1135 case OMP_CLAUSE_DIST_SCHEDULE
:
1136 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
) != NULL
)
1138 wi
->val_only
= true;
1140 convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
1145 case OMP_CLAUSE_MAP
:
1147 case OMP_CLAUSE_FROM
:
1148 if (OMP_CLAUSE_SIZE (clause
))
1150 wi
->val_only
= true;
1152 convert_nonlocal_reference_op (&OMP_CLAUSE_SIZE (clause
),
1155 if (DECL_P (OMP_CLAUSE_DECL (clause
)))
1156 goto do_decl_clause
;
1157 wi
->val_only
= true;
1159 walk_tree (&OMP_CLAUSE_DECL (clause
), convert_nonlocal_reference_op
,
1163 case OMP_CLAUSE_ALIGNED
:
1164 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
1166 wi
->val_only
= true;
1168 convert_nonlocal_reference_op
1169 (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
), &dummy
, wi
);
1171 /* Like do_decl_clause, but don't add any suppression. */
1172 decl
= OMP_CLAUSE_DECL (clause
);
1173 if (TREE_CODE (decl
) == VAR_DECL
1174 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1176 if (decl_function_context (decl
) != info
->context
)
1178 OMP_CLAUSE_DECL (clause
) = get_nonlocal_debug_decl (info
, decl
);
1179 if (OMP_CLAUSE_CODE (clause
) != OMP_CLAUSE_PRIVATE
)
1184 case OMP_CLAUSE_NOWAIT
:
1185 case OMP_CLAUSE_ORDERED
:
1186 case OMP_CLAUSE_DEFAULT
:
1187 case OMP_CLAUSE_COPYIN
:
1188 case OMP_CLAUSE_COLLAPSE
:
1189 case OMP_CLAUSE_UNTIED
:
1190 case OMP_CLAUSE_MERGEABLE
:
1191 case OMP_CLAUSE_PROC_BIND
:
1199 info
->suppress_expansion
= new_suppress
;
1202 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1203 switch (OMP_CLAUSE_CODE (clause
))
1205 case OMP_CLAUSE_REDUCTION
:
1206 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1209 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
));
1210 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1212 walk_body (convert_nonlocal_reference_stmt
,
1213 convert_nonlocal_reference_op
, info
,
1214 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause
));
1215 walk_body (convert_nonlocal_reference_stmt
,
1216 convert_nonlocal_reference_op
, info
,
1217 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause
));
1218 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1223 case OMP_CLAUSE_LASTPRIVATE
:
1224 walk_body (convert_nonlocal_reference_stmt
,
1225 convert_nonlocal_reference_op
, info
,
1226 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
));
1229 case OMP_CLAUSE_LINEAR
:
1230 walk_body (convert_nonlocal_reference_stmt
,
1231 convert_nonlocal_reference_op
, info
,
1232 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
));
1242 /* Create nonlocal debug decls for nonlocal VLA array bounds. */
1245 note_nonlocal_vla_type (struct nesting_info
*info
, tree type
)
1247 while (POINTER_TYPE_P (type
) && !TYPE_NAME (type
))
1248 type
= TREE_TYPE (type
);
1250 if (TYPE_NAME (type
)
1251 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1252 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1253 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1255 while (POINTER_TYPE_P (type
)
1256 || TREE_CODE (type
) == VECTOR_TYPE
1257 || TREE_CODE (type
) == FUNCTION_TYPE
1258 || TREE_CODE (type
) == METHOD_TYPE
)
1259 type
= TREE_TYPE (type
);
1261 if (TREE_CODE (type
) == ARRAY_TYPE
)
1265 note_nonlocal_vla_type (info
, TREE_TYPE (type
));
1266 domain
= TYPE_DOMAIN (type
);
1269 t
= TYPE_MIN_VALUE (domain
);
1270 if (t
&& (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == PARM_DECL
)
1271 && decl_function_context (t
) != info
->context
)
1272 get_nonlocal_debug_decl (info
, t
);
1273 t
= TYPE_MAX_VALUE (domain
);
1274 if (t
&& (TREE_CODE (t
) == VAR_DECL
|| TREE_CODE (t
) == PARM_DECL
)
1275 && decl_function_context (t
) != info
->context
)
1276 get_nonlocal_debug_decl (info
, t
);
1281 /* Create nonlocal debug decls for nonlocal VLA array bounds for VLAs
1285 note_nonlocal_block_vlas (struct nesting_info
*info
, tree block
)
1289 for (var
= BLOCK_VARS (block
); var
; var
= DECL_CHAIN (var
))
1290 if (TREE_CODE (var
) == VAR_DECL
1291 && variably_modified_type_p (TREE_TYPE (var
), NULL
)
1292 && DECL_HAS_VALUE_EXPR_P (var
)
1293 && decl_function_context (var
) != info
->context
)
1294 note_nonlocal_vla_type (info
, TREE_TYPE (var
));
1297 /* Callback for walk_gimple_stmt. Rewrite all references to VAR and
1298 PARM_DECLs that belong to outer functions. This handles statements
1299 that are not handled via the standard recursion done in
1300 walk_gimple_stmt. STMT is the statement to examine, DATA is as in
1301 convert_nonlocal_reference_op. Set *HANDLED_OPS_P to true if all the
1302 operands of STMT have been handled by this function. */
1305 convert_nonlocal_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
1306 struct walk_stmt_info
*wi
)
1308 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
1309 tree save_local_var_chain
;
1310 bitmap save_suppress
;
1311 gimple stmt
= gsi_stmt (*gsi
);
1313 switch (gimple_code (stmt
))
1316 /* Don't walk non-local gotos for now. */
1317 if (TREE_CODE (gimple_goto_dest (stmt
)) != LABEL_DECL
)
1319 wi
->val_only
= true;
1321 *handled_ops_p
= true;
1326 case GIMPLE_OMP_PARALLEL
:
1327 case GIMPLE_OMP_TASK
:
1328 save_suppress
= info
->suppress_expansion
;
1329 if (convert_nonlocal_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt
),
1333 decl
= get_chain_decl (info
);
1334 c
= build_omp_clause (gimple_location (stmt
),
1335 OMP_CLAUSE_FIRSTPRIVATE
);
1336 OMP_CLAUSE_DECL (c
) = decl
;
1337 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
1338 gimple_omp_taskreg_set_clauses (stmt
, c
);
1341 save_local_var_chain
= info
->new_local_var_chain
;
1342 info
->new_local_var_chain
= NULL
;
1344 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1345 info
, gimple_omp_body_ptr (stmt
));
1347 if (info
->new_local_var_chain
)
1348 declare_vars (info
->new_local_var_chain
,
1349 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
1351 info
->new_local_var_chain
= save_local_var_chain
;
1352 info
->suppress_expansion
= save_suppress
;
1355 case GIMPLE_OMP_FOR
:
1356 save_suppress
= info
->suppress_expansion
;
1357 convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt
), wi
);
1358 walk_gimple_omp_for (stmt
, convert_nonlocal_reference_stmt
,
1359 convert_nonlocal_reference_op
, info
);
1360 walk_body (convert_nonlocal_reference_stmt
,
1361 convert_nonlocal_reference_op
, info
, gimple_omp_body_ptr (stmt
));
1362 info
->suppress_expansion
= save_suppress
;
1365 case GIMPLE_OMP_SECTIONS
:
1366 save_suppress
= info
->suppress_expansion
;
1367 convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt
), wi
);
1368 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1369 info
, gimple_omp_body_ptr (stmt
));
1370 info
->suppress_expansion
= save_suppress
;
1373 case GIMPLE_OMP_SINGLE
:
1374 save_suppress
= info
->suppress_expansion
;
1375 convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt
), wi
);
1376 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1377 info
, gimple_omp_body_ptr (stmt
));
1378 info
->suppress_expansion
= save_suppress
;
1381 case GIMPLE_OMP_TARGET
:
1382 if (gimple_omp_target_kind (stmt
) != GF_OMP_TARGET_KIND_REGION
)
1384 save_suppress
= info
->suppress_expansion
;
1385 convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt
),
1387 info
->suppress_expansion
= save_suppress
;
1388 walk_body (convert_nonlocal_reference_stmt
,
1389 convert_nonlocal_reference_op
, info
,
1390 gimple_omp_body_ptr (stmt
));
1393 save_suppress
= info
->suppress_expansion
;
1394 if (convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt
),
1398 decl
= get_chain_decl (info
);
1399 c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
1400 OMP_CLAUSE_DECL (c
) = decl
;
1401 OMP_CLAUSE_MAP_KIND (c
) = OMP_CLAUSE_MAP_TO
;
1402 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
1403 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
1404 gimple_omp_target_set_clauses (stmt
, c
);
1407 save_local_var_chain
= info
->new_local_var_chain
;
1408 info
->new_local_var_chain
= NULL
;
1410 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1411 info
, gimple_omp_body_ptr (stmt
));
1413 if (info
->new_local_var_chain
)
1414 declare_vars (info
->new_local_var_chain
,
1415 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
1417 info
->new_local_var_chain
= save_local_var_chain
;
1418 info
->suppress_expansion
= save_suppress
;
1421 case GIMPLE_OMP_TEAMS
:
1422 save_suppress
= info
->suppress_expansion
;
1423 convert_nonlocal_omp_clauses (gimple_omp_teams_clauses_ptr (stmt
), wi
);
1424 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1425 info
, gimple_omp_body_ptr (stmt
));
1426 info
->suppress_expansion
= save_suppress
;
1429 case GIMPLE_OMP_SECTION
:
1430 case GIMPLE_OMP_MASTER
:
1431 case GIMPLE_OMP_TASKGROUP
:
1432 case GIMPLE_OMP_ORDERED
:
1433 walk_body (convert_nonlocal_reference_stmt
, convert_nonlocal_reference_op
,
1434 info
, gimple_omp_body_ptr (stmt
));
1438 if (!optimize
&& gimple_bind_block (stmt
))
1439 note_nonlocal_block_vlas (info
, gimple_bind_block (stmt
));
1441 for (tree var
= gimple_bind_vars (stmt
); var
; var
= DECL_CHAIN (var
))
1442 if (TREE_CODE (var
) == NAMELIST_DECL
)
1444 /* Adjust decls mentioned in NAMELIST_DECL. */
1445 tree decls
= NAMELIST_DECL_ASSOCIATED_DECL (var
);
1449 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls
), i
, decl
)
1451 if (TREE_CODE (decl
) == VAR_DECL
1452 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1454 if (decl_function_context (decl
) != info
->context
)
1455 CONSTRUCTOR_ELT (decls
, i
)->value
1456 = get_nonlocal_debug_decl (info
, decl
);
1460 *handled_ops_p
= false;
1464 wi
->val_only
= true;
1466 *handled_ops_p
= false;
1470 /* For every other statement that we are not interested in
1471 handling here, let the walker traverse the operands. */
1472 *handled_ops_p
= false;
1476 /* We have handled all of STMT operands, no need to traverse the operands. */
1477 *handled_ops_p
= true;
1482 /* A subroutine of convert_local_reference. Create a local variable
1483 in the parent function with DECL_VALUE_EXPR set to reference the
1484 field in FRAME. This is used both for debug info and in OpenMP
1488 get_local_debug_decl (struct nesting_info
*info
, tree decl
, tree field
)
1492 tree
*slot
= &info
->var_map
->get_or_insert (decl
);
1496 /* Make sure frame_decl gets created. */
1497 (void) get_frame_type (info
);
1498 x
= info
->frame_decl
;
1499 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
), x
, field
, NULL_TREE
);
1501 new_decl
= build_decl (DECL_SOURCE_LOCATION (decl
),
1502 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
1503 DECL_CONTEXT (new_decl
) = info
->context
;
1504 DECL_ARTIFICIAL (new_decl
) = DECL_ARTIFICIAL (decl
);
1505 DECL_IGNORED_P (new_decl
) = DECL_IGNORED_P (decl
);
1506 TREE_THIS_VOLATILE (new_decl
) = TREE_THIS_VOLATILE (decl
);
1507 TREE_SIDE_EFFECTS (new_decl
) = TREE_SIDE_EFFECTS (decl
);
1508 TREE_READONLY (new_decl
) = TREE_READONLY (decl
);
1509 TREE_ADDRESSABLE (new_decl
) = TREE_ADDRESSABLE (decl
);
1510 DECL_SEEN_IN_BIND_EXPR_P (new_decl
) = 1;
1511 if ((TREE_CODE (decl
) == PARM_DECL
1512 || TREE_CODE (decl
) == RESULT_DECL
1513 || TREE_CODE (decl
) == VAR_DECL
)
1514 && DECL_BY_REFERENCE (decl
))
1515 DECL_BY_REFERENCE (new_decl
) = 1;
1517 SET_DECL_VALUE_EXPR (new_decl
, x
);
1518 DECL_HAS_VALUE_EXPR_P (new_decl
) = 1;
1521 DECL_CHAIN (new_decl
) = info
->debug_var_chain
;
1522 info
->debug_var_chain
= new_decl
;
1524 /* Do not emit debug info twice. */
1525 DECL_IGNORED_P (decl
) = 1;
1531 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1532 and PARM_DECLs that were referenced by inner nested functions.
1533 The rewrite will be a structure reference to the local frame variable. */
1535 static bool convert_local_omp_clauses (tree
*, struct walk_stmt_info
*);
1538 convert_local_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
1540 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
1541 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1542 tree t
= *tp
, field
, x
;
1546 switch (TREE_CODE (t
))
1549 /* Non-automatic variables are never processed. */
1550 if (TREE_STATIC (t
) || DECL_EXTERNAL (t
))
1555 if (decl_function_context (t
) == info
->context
)
1557 /* If we copied a pointer to the frame, then the original decl
1558 is used unchanged in the parent function. */
1559 if (use_pointer_in_frame (t
))
1562 /* No need to transform anything if no child references the
1564 field
= lookup_field_for_decl (info
, t
, NO_INSERT
);
1569 x
= get_local_debug_decl (info
, t
, field
);
1570 if (!bitmap_bit_p (info
->suppress_expansion
, DECL_UID (t
)))
1571 x
= get_frame_field (info
, info
->context
, field
, &wi
->gsi
);
1576 x
= save_tmp_var (info
, x
, &wi
->gsi
);
1578 x
= init_tmp_var (info
, x
, &wi
->gsi
);
1586 save_val_only
= wi
->val_only
;
1587 wi
->val_only
= false;
1589 wi
->changed
= false;
1590 walk_tree (&TREE_OPERAND (t
, 0), convert_local_reference_op
, wi
, NULL
);
1591 wi
->val_only
= save_val_only
;
1593 /* If we converted anything ... */
1598 /* Then the frame decl is now addressable. */
1599 TREE_ADDRESSABLE (info
->frame_decl
) = 1;
1601 save_context
= current_function_decl
;
1602 current_function_decl
= info
->context
;
1603 recompute_tree_invariant_for_addr_expr (t
);
1604 current_function_decl
= save_context
;
1606 /* If we are in a context where we only accept values, then
1607 compute the address into a temporary. */
1609 *tp
= gsi_gimplify_val ((struct nesting_info
*) wi
->info
,
1618 case ARRAY_RANGE_REF
:
1620 /* Go down this entire nest and just look at the final prefix and
1621 anything that describes the references. Otherwise, we lose track
1622 of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1623 save_val_only
= wi
->val_only
;
1624 wi
->val_only
= true;
1626 for (; handled_component_p (t
); tp
= &TREE_OPERAND (t
, 0), t
= *tp
)
1628 if (TREE_CODE (t
) == COMPONENT_REF
)
1629 walk_tree (&TREE_OPERAND (t
, 2), convert_local_reference_op
, wi
,
1631 else if (TREE_CODE (t
) == ARRAY_REF
1632 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
1634 walk_tree (&TREE_OPERAND (t
, 1), convert_local_reference_op
, wi
,
1636 walk_tree (&TREE_OPERAND (t
, 2), convert_local_reference_op
, wi
,
1638 walk_tree (&TREE_OPERAND (t
, 3), convert_local_reference_op
, wi
,
1642 wi
->val_only
= false;
1643 walk_tree (tp
, convert_local_reference_op
, wi
, NULL
);
1644 wi
->val_only
= save_val_only
;
1648 save_val_only
= wi
->val_only
;
1649 wi
->val_only
= true;
1651 walk_tree (&TREE_OPERAND (t
, 0), convert_local_reference_op
,
1653 /* We need to re-fold the MEM_REF as component references as
1654 part of a ADDR_EXPR address are not allowed. But we cannot
1655 fold here, as the chain record type is not yet finalized. */
1656 if (TREE_CODE (TREE_OPERAND (t
, 0)) == ADDR_EXPR
1657 && !DECL_P (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)))
1658 info
->mem_refs
->add (tp
);
1659 wi
->val_only
= save_val_only
;
1662 case VIEW_CONVERT_EXPR
:
1663 /* Just request to look at the subtrees, leaving val_only and lhs
1664 untouched. This might actually be for !val_only + lhs, in which
1665 case we don't want to force a replacement by a temporary. */
1670 if (!IS_TYPE_OR_DECL_P (t
))
1673 wi
->val_only
= true;
1682 static tree
convert_local_reference_stmt (gimple_stmt_iterator
*, bool *,
1683 struct walk_stmt_info
*);
1685 /* Helper for convert_local_reference. Convert all the references in
1686 the chain of clauses at *PCLAUSES. WI is as in convert_local_reference. */
1689 convert_local_omp_clauses (tree
*pclauses
, struct walk_stmt_info
*wi
)
1691 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
1692 bool need_frame
= false, need_stmts
= false;
1695 bitmap new_suppress
;
1697 new_suppress
= BITMAP_GGC_ALLOC ();
1698 bitmap_copy (new_suppress
, info
->suppress_expansion
);
1700 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1702 switch (OMP_CLAUSE_CODE (clause
))
1704 case OMP_CLAUSE_REDUCTION
:
1705 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1707 goto do_decl_clause
;
1709 case OMP_CLAUSE_LASTPRIVATE
:
1710 if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
))
1712 goto do_decl_clause
;
1714 case OMP_CLAUSE_LINEAR
:
1715 if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
))
1717 wi
->val_only
= true;
1719 convert_local_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause
), &dummy
,
1721 goto do_decl_clause
;
1723 case OMP_CLAUSE_PRIVATE
:
1724 case OMP_CLAUSE_FIRSTPRIVATE
:
1725 case OMP_CLAUSE_COPYPRIVATE
:
1726 case OMP_CLAUSE_SHARED
:
1728 decl
= OMP_CLAUSE_DECL (clause
);
1729 if (TREE_CODE (decl
) == VAR_DECL
1730 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1732 if (decl_function_context (decl
) == info
->context
1733 && !use_pointer_in_frame (decl
))
1735 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
1738 bitmap_set_bit (new_suppress
, DECL_UID (decl
));
1739 OMP_CLAUSE_DECL (clause
)
1740 = get_local_debug_decl (info
, decl
, field
);
1746 case OMP_CLAUSE_SCHEDULE
:
1747 if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause
) == NULL
)
1750 case OMP_CLAUSE_FINAL
:
1752 case OMP_CLAUSE_NUM_THREADS
:
1753 case OMP_CLAUSE_DEPEND
:
1754 case OMP_CLAUSE_DEVICE
:
1755 case OMP_CLAUSE_NUM_TEAMS
:
1756 case OMP_CLAUSE_THREAD_LIMIT
:
1757 case OMP_CLAUSE_SAFELEN
:
1758 case OMP_CLAUSE__CILK_FOR_COUNT_
:
1759 wi
->val_only
= true;
1761 convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0), &dummy
,
1765 case OMP_CLAUSE_DIST_SCHEDULE
:
1766 if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause
) != NULL
)
1768 wi
->val_only
= true;
1770 convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause
, 0),
1775 case OMP_CLAUSE_MAP
:
1777 case OMP_CLAUSE_FROM
:
1778 if (OMP_CLAUSE_SIZE (clause
))
1780 wi
->val_only
= true;
1782 convert_local_reference_op (&OMP_CLAUSE_SIZE (clause
),
1785 if (DECL_P (OMP_CLAUSE_DECL (clause
)))
1786 goto do_decl_clause
;
1787 wi
->val_only
= true;
1789 walk_tree (&OMP_CLAUSE_DECL (clause
), convert_local_reference_op
,
1793 case OMP_CLAUSE_ALIGNED
:
1794 if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
))
1796 wi
->val_only
= true;
1798 convert_local_reference_op
1799 (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause
), &dummy
, wi
);
1801 /* Like do_decl_clause, but don't add any suppression. */
1802 decl
= OMP_CLAUSE_DECL (clause
);
1803 if (TREE_CODE (decl
) == VAR_DECL
1804 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
1806 if (decl_function_context (decl
) == info
->context
1807 && !use_pointer_in_frame (decl
))
1809 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
1812 OMP_CLAUSE_DECL (clause
)
1813 = get_local_debug_decl (info
, decl
, field
);
1819 case OMP_CLAUSE_NOWAIT
:
1820 case OMP_CLAUSE_ORDERED
:
1821 case OMP_CLAUSE_DEFAULT
:
1822 case OMP_CLAUSE_COPYIN
:
1823 case OMP_CLAUSE_COLLAPSE
:
1824 case OMP_CLAUSE_UNTIED
:
1825 case OMP_CLAUSE_MERGEABLE
:
1826 case OMP_CLAUSE_PROC_BIND
:
1834 info
->suppress_expansion
= new_suppress
;
1837 for (clause
= *pclauses
; clause
; clause
= OMP_CLAUSE_CHAIN (clause
))
1838 switch (OMP_CLAUSE_CODE (clause
))
1840 case OMP_CLAUSE_REDUCTION
:
1841 if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1844 = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
));
1845 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1847 walk_body (convert_local_reference_stmt
,
1848 convert_local_reference_op
, info
,
1849 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause
));
1850 walk_body (convert_local_reference_stmt
,
1851 convert_local_reference_op
, info
,
1852 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause
));
1853 DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause
))
1858 case OMP_CLAUSE_LASTPRIVATE
:
1859 walk_body (convert_local_reference_stmt
,
1860 convert_local_reference_op
, info
,
1861 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause
));
1864 case OMP_CLAUSE_LINEAR
:
1865 walk_body (convert_local_reference_stmt
,
1866 convert_local_reference_op
, info
,
1867 &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause
));
1878 /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1879 and PARM_DECLs that were referenced by inner nested functions.
1880 The rewrite will be a structure reference to the local frame variable. */
1883 convert_local_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
1884 struct walk_stmt_info
*wi
)
1886 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
1887 tree save_local_var_chain
;
1888 bitmap save_suppress
;
1889 gimple stmt
= gsi_stmt (*gsi
);
1891 switch (gimple_code (stmt
))
1893 case GIMPLE_OMP_PARALLEL
:
1894 case GIMPLE_OMP_TASK
:
1895 save_suppress
= info
->suppress_expansion
;
1896 if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt
),
1900 (void) get_frame_type (info
);
1901 c
= build_omp_clause (gimple_location (stmt
),
1903 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
1904 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
1905 gimple_omp_taskreg_set_clauses (stmt
, c
);
1908 save_local_var_chain
= info
->new_local_var_chain
;
1909 info
->new_local_var_chain
= NULL
;
1911 walk_body (convert_local_reference_stmt
, convert_local_reference_op
, info
,
1912 gimple_omp_body_ptr (stmt
));
1914 if (info
->new_local_var_chain
)
1915 declare_vars (info
->new_local_var_chain
,
1916 gimple_seq_first_stmt (gimple_omp_body (stmt
)), false);
1917 info
->new_local_var_chain
= save_local_var_chain
;
1918 info
->suppress_expansion
= save_suppress
;
1921 case GIMPLE_OMP_FOR
:
1922 save_suppress
= info
->suppress_expansion
;
1923 convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt
), wi
);
1924 walk_gimple_omp_for (stmt
, convert_local_reference_stmt
,
1925 convert_local_reference_op
, info
);
1926 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
1927 info
, gimple_omp_body_ptr (stmt
));
1928 info
->suppress_expansion
= save_suppress
;
1931 case GIMPLE_OMP_SECTIONS
:
1932 save_suppress
= info
->suppress_expansion
;
1933 convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt
), wi
);
1934 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
1935 info
, gimple_omp_body_ptr (stmt
));
1936 info
->suppress_expansion
= save_suppress
;
1939 case GIMPLE_OMP_SINGLE
:
1940 save_suppress
= info
->suppress_expansion
;
1941 convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt
), wi
);
1942 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
1943 info
, gimple_omp_body_ptr (stmt
));
1944 info
->suppress_expansion
= save_suppress
;
1947 case GIMPLE_OMP_TARGET
:
1948 if (gimple_omp_target_kind (stmt
) != GF_OMP_TARGET_KIND_REGION
)
1950 save_suppress
= info
->suppress_expansion
;
1951 convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt
), wi
);
1952 info
->suppress_expansion
= save_suppress
;
1953 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
1954 info
, gimple_omp_body_ptr (stmt
));
1957 save_suppress
= info
->suppress_expansion
;
1958 if (convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt
), wi
))
1961 (void) get_frame_type (info
);
1962 c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
1963 OMP_CLAUSE_DECL (c
) = info
->frame_decl
;
1964 OMP_CLAUSE_MAP_KIND (c
) = OMP_CLAUSE_MAP_TOFROM
;
1965 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (info
->frame_decl
);
1966 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
1967 gimple_omp_target_set_clauses (stmt
, c
);
1970 save_local_var_chain
= info
->new_local_var_chain
;
1971 info
->new_local_var_chain
= NULL
;
1973 walk_body (convert_local_reference_stmt
, convert_local_reference_op
, info
,
1974 gimple_omp_body_ptr (stmt
));
1976 if (info
->new_local_var_chain
)
1977 declare_vars (info
->new_local_var_chain
,
1978 gimple_seq_first_stmt (gimple_omp_body (stmt
)), false);
1979 info
->new_local_var_chain
= save_local_var_chain
;
1980 info
->suppress_expansion
= save_suppress
;
1983 case GIMPLE_OMP_TEAMS
:
1984 save_suppress
= info
->suppress_expansion
;
1985 convert_local_omp_clauses (gimple_omp_teams_clauses_ptr (stmt
), wi
);
1986 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
1987 info
, gimple_omp_body_ptr (stmt
));
1988 info
->suppress_expansion
= save_suppress
;
1991 case GIMPLE_OMP_SECTION
:
1992 case GIMPLE_OMP_MASTER
:
1993 case GIMPLE_OMP_TASKGROUP
:
1994 case GIMPLE_OMP_ORDERED
:
1995 walk_body (convert_local_reference_stmt
, convert_local_reference_op
,
1996 info
, gimple_omp_body_ptr (stmt
));
2000 wi
->val_only
= true;
2002 *handled_ops_p
= false;
2006 if (gimple_clobber_p (stmt
))
2008 tree lhs
= gimple_assign_lhs (stmt
);
2009 if (!use_pointer_in_frame (lhs
)
2010 && lookup_field_for_decl (info
, lhs
, NO_INSERT
))
2012 gsi_replace (gsi
, gimple_build_nop (), true);
2016 *handled_ops_p
= false;
2020 for (tree var
= gimple_bind_vars (stmt
); var
; var
= DECL_CHAIN (var
))
2021 if (TREE_CODE (var
) == NAMELIST_DECL
)
2023 /* Adjust decls mentioned in NAMELIST_DECL. */
2024 tree decls
= NAMELIST_DECL_ASSOCIATED_DECL (var
);
2028 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls
), i
, decl
)
2030 if (TREE_CODE (decl
) == VAR_DECL
2031 && (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
)))
2033 if (decl_function_context (decl
) == info
->context
2034 && !use_pointer_in_frame (decl
))
2036 tree field
= lookup_field_for_decl (info
, decl
, NO_INSERT
);
2039 CONSTRUCTOR_ELT (decls
, i
)->value
2040 = get_local_debug_decl (info
, decl
, field
);
2046 *handled_ops_p
= false;
2050 /* For every other statement that we are not interested in
2051 handling here, let the walker traverse the operands. */
2052 *handled_ops_p
= false;
2056 /* Indicate that we have handled all the operands ourselves. */
2057 *handled_ops_p
= true;
2062 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_GOTOs
2063 that reference labels from outer functions. The rewrite will be a
2064 call to __builtin_nonlocal_goto. */
2067 convert_nl_goto_reference (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2068 struct walk_stmt_info
*wi
)
2070 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
, *i
;
2071 tree label
, new_label
, target_context
, x
, field
;
2073 gimple stmt
= gsi_stmt (*gsi
);
2075 if (gimple_code (stmt
) != GIMPLE_GOTO
)
2077 *handled_ops_p
= false;
2081 label
= gimple_goto_dest (stmt
);
2082 if (TREE_CODE (label
) != LABEL_DECL
)
2084 *handled_ops_p
= false;
2088 target_context
= decl_function_context (label
);
2089 if (target_context
== info
->context
)
2091 *handled_ops_p
= false;
2095 for (i
= info
->outer
; target_context
!= i
->context
; i
= i
->outer
)
2098 /* The original user label may also be use for a normal goto, therefore
2099 we must create a new label that will actually receive the abnormal
2100 control transfer. This new label will be marked LABEL_NONLOCAL; this
2101 mark will trigger proper behavior in the cfg, as well as cause the
2102 (hairy target-specific) non-local goto receiver code to be generated
2103 when we expand rtl. Enter this association into var_map so that we
2104 can insert the new label into the IL during a second pass. */
2105 tree
*slot
= &i
->var_map
->get_or_insert (label
);
2108 new_label
= create_artificial_label (UNKNOWN_LOCATION
);
2109 DECL_NONLOCAL (new_label
) = 1;
2115 /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field). */
2116 field
= get_nl_goto_field (i
);
2117 x
= get_frame_field (info
, target_context
, field
, gsi
);
2118 x
= build_addr (x
, target_context
);
2119 x
= gsi_gimplify_val (info
, x
, gsi
);
2120 call
= gimple_build_call (builtin_decl_implicit (BUILT_IN_NONLOCAL_GOTO
),
2121 2, build_addr (new_label
, target_context
), x
);
2122 gsi_replace (gsi
, call
, false);
2124 /* We have handled all of STMT's operands, no need to keep going. */
2125 *handled_ops_p
= true;
2130 /* Called via walk_function+walk_tree, rewrite all GIMPLE_LABELs whose labels
2131 are referenced via nonlocal goto from a nested function. The rewrite
2132 will involve installing a newly generated DECL_NONLOCAL label, and
2133 (potentially) a branch around the rtl gunk that is assumed to be
2134 attached to such a label. */
2137 convert_nl_goto_receiver (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2138 struct walk_stmt_info
*wi
)
2140 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
2141 tree label
, new_label
;
2142 gimple_stmt_iterator tmp_gsi
;
2143 gimple stmt
= gsi_stmt (*gsi
);
2145 if (gimple_code (stmt
) != GIMPLE_LABEL
)
2147 *handled_ops_p
= false;
2151 label
= gimple_label_label (stmt
);
2153 tree
*slot
= info
->var_map
->get (label
);
2156 *handled_ops_p
= false;
2160 /* If there's any possibility that the previous statement falls through,
2161 then we must branch around the new non-local label. */
2163 gsi_prev (&tmp_gsi
);
2164 if (gsi_end_p (tmp_gsi
) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi
)))
2166 gimple stmt
= gimple_build_goto (label
);
2167 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2170 new_label
= (tree
) *slot
;
2171 stmt
= gimple_build_label (new_label
);
2172 gsi_insert_before (gsi
, stmt
, GSI_SAME_STMT
);
2174 *handled_ops_p
= true;
2179 /* Called via walk_function+walk_stmt, rewrite all references to addresses
2180 of nested functions that require the use of trampolines. The rewrite
2181 will involve a reference a trampoline generated for the occasion. */
2184 convert_tramp_reference_op (tree
*tp
, int *walk_subtrees
, void *data
)
2186 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
2187 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
, *i
;
2188 tree t
= *tp
, decl
, target_context
, x
, builtin
;
2192 switch (TREE_CODE (t
))
2196 T.1 = &CHAIN->tramp;
2197 T.2 = __builtin_adjust_trampoline (T.1);
2198 T.3 = (func_type)T.2;
2201 decl
= TREE_OPERAND (t
, 0);
2202 if (TREE_CODE (decl
) != FUNCTION_DECL
)
2205 /* Only need to process nested functions. */
2206 target_context
= decl_function_context (decl
);
2207 if (!target_context
)
2210 /* If the nested function doesn't use a static chain, then
2211 it doesn't need a trampoline. */
2212 if (!DECL_STATIC_CHAIN (decl
))
2215 /* If we don't want a trampoline, then don't build one. */
2216 if (TREE_NO_TRAMPOLINE (t
))
2219 /* Lookup the immediate parent of the callee, as that's where
2220 we need to insert the trampoline. */
2221 for (i
= info
; i
->context
!= target_context
; i
= i
->outer
)
2223 x
= lookup_tramp_for_decl (i
, decl
, INSERT
);
2225 /* Compute the address of the field holding the trampoline. */
2226 x
= get_frame_field (info
, target_context
, x
, &wi
->gsi
);
2227 x
= build_addr (x
, target_context
);
2228 x
= gsi_gimplify_val (info
, x
, &wi
->gsi
);
2230 /* Do machine-specific ugliness. Normally this will involve
2231 computing extra alignment, but it can really be anything. */
2232 builtin
= builtin_decl_implicit (BUILT_IN_ADJUST_TRAMPOLINE
);
2233 call
= gimple_build_call (builtin
, 1, x
);
2234 x
= init_tmp_var_with_call (info
, &wi
->gsi
, call
);
2236 /* Cast back to the proper function type. */
2237 x
= build1 (NOP_EXPR
, TREE_TYPE (t
), x
);
2238 x
= init_tmp_var (info
, x
, &wi
->gsi
);
2244 if (!IS_TYPE_OR_DECL_P (t
))
2253 /* Called via walk_function+walk_gimple_stmt, rewrite all references
2254 to addresses of nested functions that require the use of
2255 trampolines. The rewrite will involve a reference a trampoline
2256 generated for the occasion. */
2259 convert_tramp_reference_stmt (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2260 struct walk_stmt_info
*wi
)
2262 struct nesting_info
*info
= (struct nesting_info
*) wi
->info
;
2263 gimple stmt
= gsi_stmt (*gsi
);
2265 switch (gimple_code (stmt
))
2269 /* Only walk call arguments, lest we generate trampolines for
2271 unsigned long i
, nargs
= gimple_call_num_args (stmt
);
2272 for (i
= 0; i
< nargs
; i
++)
2273 walk_tree (gimple_call_arg_ptr (stmt
, i
), convert_tramp_reference_op
,
2278 case GIMPLE_OMP_TARGET
:
2279 if (gimple_omp_target_kind (stmt
) != GF_OMP_TARGET_KIND_REGION
)
2281 *handled_ops_p
= false;
2285 case GIMPLE_OMP_PARALLEL
:
2286 case GIMPLE_OMP_TASK
:
2288 tree save_local_var_chain
;
2289 walk_gimple_op (stmt
, convert_tramp_reference_op
, wi
);
2290 save_local_var_chain
= info
->new_local_var_chain
;
2291 info
->new_local_var_chain
= NULL
;
2292 walk_body (convert_tramp_reference_stmt
, convert_tramp_reference_op
,
2293 info
, gimple_omp_body_ptr (stmt
));
2294 if (info
->new_local_var_chain
)
2295 declare_vars (info
->new_local_var_chain
,
2296 gimple_seq_first_stmt (gimple_omp_body (stmt
)),
2298 info
->new_local_var_chain
= save_local_var_chain
;
2303 *handled_ops_p
= false;
2307 *handled_ops_p
= true;
2313 /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_CALLs
2314 that reference nested functions to make sure that the static chain
2315 is set up properly for the call. */
2318 convert_gimple_call (gimple_stmt_iterator
*gsi
, bool *handled_ops_p
,
2319 struct walk_stmt_info
*wi
)
2321 struct nesting_info
*const info
= (struct nesting_info
*) wi
->info
;
2322 tree decl
, target_context
;
2323 char save_static_chain_added
;
2325 gimple stmt
= gsi_stmt (*gsi
);
2327 switch (gimple_code (stmt
))
2330 if (gimple_call_chain (stmt
))
2332 decl
= gimple_call_fndecl (stmt
);
2335 target_context
= decl_function_context (decl
);
2336 if (target_context
&& DECL_STATIC_CHAIN (decl
))
2338 gimple_call_set_chain (stmt
, get_static_chain (info
, target_context
,
2340 info
->static_chain_added
|= (1 << (info
->context
!= target_context
));
2344 case GIMPLE_OMP_PARALLEL
:
2345 case GIMPLE_OMP_TASK
:
2346 save_static_chain_added
= info
->static_chain_added
;
2347 info
->static_chain_added
= 0;
2348 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2349 for (i
= 0; i
< 2; i
++)
2352 if ((info
->static_chain_added
& (1 << i
)) == 0)
2354 decl
= i
? get_chain_decl (info
) : info
->frame_decl
;
2355 /* Don't add CHAIN.* or FRAME.* twice. */
2356 for (c
= gimple_omp_taskreg_clauses (stmt
);
2358 c
= OMP_CLAUSE_CHAIN (c
))
2359 if ((OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_FIRSTPRIVATE
2360 || OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_SHARED
)
2361 && OMP_CLAUSE_DECL (c
) == decl
)
2365 c
= build_omp_clause (gimple_location (stmt
),
2366 i
? OMP_CLAUSE_FIRSTPRIVATE
2367 : OMP_CLAUSE_SHARED
);
2368 OMP_CLAUSE_DECL (c
) = decl
;
2369 OMP_CLAUSE_CHAIN (c
) = gimple_omp_taskreg_clauses (stmt
);
2370 gimple_omp_taskreg_set_clauses (stmt
, c
);
2373 info
->static_chain_added
|= save_static_chain_added
;
2376 case GIMPLE_OMP_TARGET
:
2377 if (gimple_omp_target_kind (stmt
) != GF_OMP_TARGET_KIND_REGION
)
2379 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2382 save_static_chain_added
= info
->static_chain_added
;
2383 info
->static_chain_added
= 0;
2384 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2385 for (i
= 0; i
< 2; i
++)
2388 if ((info
->static_chain_added
& (1 << i
)) == 0)
2390 decl
= i
? get_chain_decl (info
) : info
->frame_decl
;
2391 /* Don't add CHAIN.* or FRAME.* twice. */
2392 for (c
= gimple_omp_target_clauses (stmt
);
2394 c
= OMP_CLAUSE_CHAIN (c
))
2395 if (OMP_CLAUSE_CODE (c
) == OMP_CLAUSE_MAP
2396 && OMP_CLAUSE_DECL (c
) == decl
)
2400 c
= build_omp_clause (gimple_location (stmt
), OMP_CLAUSE_MAP
);
2401 OMP_CLAUSE_DECL (c
) = decl
;
2402 OMP_CLAUSE_MAP_KIND (c
)
2403 = i
? OMP_CLAUSE_MAP_TO
: OMP_CLAUSE_MAP_TOFROM
;
2404 OMP_CLAUSE_SIZE (c
) = DECL_SIZE_UNIT (decl
);
2405 OMP_CLAUSE_CHAIN (c
) = gimple_omp_target_clauses (stmt
);
2406 gimple_omp_target_set_clauses (stmt
, c
);
2409 info
->static_chain_added
|= save_static_chain_added
;
2412 case GIMPLE_OMP_FOR
:
2413 walk_body (convert_gimple_call
, NULL
, info
,
2414 gimple_omp_for_pre_body_ptr (stmt
));
2416 case GIMPLE_OMP_SECTIONS
:
2417 case GIMPLE_OMP_SECTION
:
2418 case GIMPLE_OMP_SINGLE
:
2419 case GIMPLE_OMP_TEAMS
:
2420 case GIMPLE_OMP_MASTER
:
2421 case GIMPLE_OMP_TASKGROUP
:
2422 case GIMPLE_OMP_ORDERED
:
2423 case GIMPLE_OMP_CRITICAL
:
2424 walk_body (convert_gimple_call
, NULL
, info
, gimple_omp_body_ptr (stmt
));
2428 /* Keep looking for other operands. */
2429 *handled_ops_p
= false;
2433 *handled_ops_p
= true;
2437 /* Walk the nesting tree starting with ROOT. Convert all trampolines and
2438 call expressions. At the same time, determine if a nested function
2439 actually uses its static chain; if not, remember that. */
2442 convert_all_function_calls (struct nesting_info
*root
)
2444 unsigned int chain_count
= 0, old_chain_count
, iter_count
;
2445 struct nesting_info
*n
;
2447 /* First, optimistically clear static_chain for all decls that haven't
2448 used the static chain already for variable access. But always create
2449 it if not optimizing. This makes it possible to reconstruct the static
2450 nesting tree at run time and thus to resolve up-level references from
2451 within the debugger. */
2452 FOR_EACH_NEST_INFO (n
, root
)
2454 tree decl
= n
->context
;
2458 (void) get_frame_type (n
);
2460 (void) get_chain_decl (n
);
2462 else if (!n
->outer
|| (!n
->chain_decl
&& !n
->chain_field
))
2464 DECL_STATIC_CHAIN (decl
) = 0;
2465 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2466 fprintf (dump_file
, "Guessing no static-chain for %s\n",
2467 lang_hooks
.decl_printable_name (decl
, 2));
2470 DECL_STATIC_CHAIN (decl
) = 1;
2471 chain_count
+= DECL_STATIC_CHAIN (decl
);
2474 /* Walk the functions and perform transformations. Note that these
2475 transformations can induce new uses of the static chain, which in turn
2476 require re-examining all users of the decl. */
2477 /* ??? It would make sense to try to use the call graph to speed this up,
2478 but the call graph hasn't really been built yet. Even if it did, we
2479 would still need to iterate in this loop since address-of references
2480 wouldn't show up in the callgraph anyway. */
2484 old_chain_count
= chain_count
;
2488 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2489 fputc ('\n', dump_file
);
2491 FOR_EACH_NEST_INFO (n
, root
)
2493 tree decl
= n
->context
;
2494 walk_function (convert_tramp_reference_stmt
,
2495 convert_tramp_reference_op
, n
);
2496 walk_function (convert_gimple_call
, NULL
, n
);
2497 chain_count
+= DECL_STATIC_CHAIN (decl
);
2500 while (chain_count
!= old_chain_count
);
2502 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2503 fprintf (dump_file
, "convert_all_function_calls iterations: %u\n\n",
2507 struct nesting_copy_body_data
2510 struct nesting_info
*root
;
2513 /* A helper subroutine for debug_var_chain type remapping. */
2516 nesting_copy_decl (tree decl
, copy_body_data
*id
)
2518 struct nesting_copy_body_data
*nid
= (struct nesting_copy_body_data
*) id
;
2519 tree
*slot
= nid
->root
->var_map
->get (decl
);
2522 return (tree
) *slot
;
2524 if (TREE_CODE (decl
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (decl
))
2526 tree new_decl
= copy_decl_no_change (decl
, id
);
2527 DECL_ORIGINAL_TYPE (new_decl
)
2528 = remap_type (DECL_ORIGINAL_TYPE (decl
), id
);
2532 if (TREE_CODE (decl
) == VAR_DECL
2533 || TREE_CODE (decl
) == PARM_DECL
2534 || TREE_CODE (decl
) == RESULT_DECL
)
2537 return copy_decl_no_change (decl
, id
);
2540 /* A helper function for remap_vla_decls. See if *TP contains
2541 some remapped variables. */
2544 contains_remapped_vars (tree
*tp
, int *walk_subtrees
, void *data
)
2546 struct nesting_info
*root
= (struct nesting_info
*) data
;
2552 tree
*slot
= root
->var_map
->get (t
);
2560 /* Remap VLA decls in BLOCK and subblocks if remapped variables are
2564 remap_vla_decls (tree block
, struct nesting_info
*root
)
2566 tree var
, subblock
, val
, type
;
2567 struct nesting_copy_body_data id
;
2569 for (subblock
= BLOCK_SUBBLOCKS (block
);
2571 subblock
= BLOCK_CHAIN (subblock
))
2572 remap_vla_decls (subblock
, root
);
2574 for (var
= BLOCK_VARS (block
); var
; var
= DECL_CHAIN (var
))
2575 if (TREE_CODE (var
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (var
))
2577 val
= DECL_VALUE_EXPR (var
);
2578 type
= TREE_TYPE (var
);
2580 if (!(TREE_CODE (val
) == INDIRECT_REF
2581 && TREE_CODE (TREE_OPERAND (val
, 0)) == VAR_DECL
2582 && variably_modified_type_p (type
, NULL
)))
2585 if (root
->var_map
->get (TREE_OPERAND (val
, 0))
2586 || walk_tree (&type
, contains_remapped_vars
, root
, NULL
))
2590 if (var
== NULL_TREE
)
2593 memset (&id
, 0, sizeof (id
));
2594 id
.cb
.copy_decl
= nesting_copy_decl
;
2595 id
.cb
.decl_map
= new hash_map
<tree
, tree
>;
2598 for (; var
; var
= DECL_CHAIN (var
))
2599 if (TREE_CODE (var
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (var
))
2601 struct nesting_info
*i
;
2604 val
= DECL_VALUE_EXPR (var
);
2605 type
= TREE_TYPE (var
);
2607 if (!(TREE_CODE (val
) == INDIRECT_REF
2608 && TREE_CODE (TREE_OPERAND (val
, 0)) == VAR_DECL
2609 && variably_modified_type_p (type
, NULL
)))
2612 tree
*slot
= root
->var_map
->get (TREE_OPERAND (val
, 0));
2613 if (!slot
&& !walk_tree (&type
, contains_remapped_vars
, root
, NULL
))
2616 context
= decl_function_context (var
);
2617 for (i
= root
; i
; i
= i
->outer
)
2618 if (i
->context
== context
)
2624 /* Fully expand value expressions. This avoids having debug variables
2625 only referenced from them and that can be swept during GC. */
2628 tree t
= (tree
) *slot
;
2629 gcc_assert (DECL_P (t
) && DECL_HAS_VALUE_EXPR_P (t
));
2630 val
= build1 (INDIRECT_REF
, TREE_TYPE (val
), DECL_VALUE_EXPR (t
));
2633 id
.cb
.src_fn
= i
->context
;
2634 id
.cb
.dst_fn
= i
->context
;
2635 id
.cb
.src_cfun
= DECL_STRUCT_FUNCTION (root
->context
);
2637 TREE_TYPE (var
) = newt
= remap_type (type
, &id
.cb
);
2638 while (POINTER_TYPE_P (newt
) && !TYPE_NAME (newt
))
2640 newt
= TREE_TYPE (newt
);
2641 type
= TREE_TYPE (type
);
2643 if (TYPE_NAME (newt
)
2644 && TREE_CODE (TYPE_NAME (newt
)) == TYPE_DECL
2645 && DECL_ORIGINAL_TYPE (TYPE_NAME (newt
))
2647 && TYPE_NAME (newt
) == TYPE_NAME (type
))
2648 TYPE_NAME (newt
) = remap_decl (TYPE_NAME (newt
), &id
.cb
);
2650 walk_tree (&val
, copy_tree_body_r
, &id
.cb
, NULL
);
2651 if (val
!= DECL_VALUE_EXPR (var
))
2652 SET_DECL_VALUE_EXPR (var
, val
);
2655 delete id
.cb
.decl_map
;
2658 /* Fold the MEM_REF *E. */
2660 fold_mem_refs (tree
*const &e
, void *data ATTRIBUTE_UNUSED
)
2662 tree
*ref_p
= CONST_CAST2 (tree
*, const tree
*, (const tree
*)e
);
2663 *ref_p
= fold (*ref_p
);
2667 /* Do "everything else" to clean up or complete state collected by the
2668 various walking passes -- lay out the types and decls, generate code
2669 to initialize the frame decl, store critical expressions in the
2670 struct function for rtl to find. */
2673 finalize_nesting_tree_1 (struct nesting_info
*root
)
2675 gimple_seq stmt_list
;
2677 tree context
= root
->context
;
2678 struct function
*sf
;
2682 /* If we created a non-local frame type or decl, we need to lay them
2683 out at this time. */
2684 if (root
->frame_type
)
2686 /* In some cases the frame type will trigger the -Wpadded warning.
2687 This is not helpful; suppress it. */
2688 int save_warn_padded
= warn_padded
;
2692 layout_type (root
->frame_type
);
2693 warn_padded
= save_warn_padded
;
2694 layout_decl (root
->frame_decl
, 0);
2696 /* Remove root->frame_decl from root->new_local_var_chain, so
2697 that we can declare it also in the lexical blocks, which
2698 helps ensure virtual regs that end up appearing in its RTL
2699 expression get substituted in instantiate_virtual_regs(). */
2700 for (adjust
= &root
->new_local_var_chain
;
2701 *adjust
!= root
->frame_decl
;
2702 adjust
= &DECL_CHAIN (*adjust
))
2703 gcc_assert (DECL_CHAIN (*adjust
));
2704 *adjust
= DECL_CHAIN (*adjust
);
2706 DECL_CHAIN (root
->frame_decl
) = NULL_TREE
;
2707 declare_vars (root
->frame_decl
,
2708 gimple_seq_first_stmt (gimple_body (context
)), true);
2711 /* If any parameters were referenced non-locally, then we need to
2712 insert a copy. Likewise, if any variables were referenced by
2713 pointer, we need to initialize the address. */
2714 if (root
->any_parm_remapped
)
2717 for (p
= DECL_ARGUMENTS (context
); p
; p
= DECL_CHAIN (p
))
2721 field
= lookup_field_for_decl (root
, p
, NO_INSERT
);
2725 if (use_pointer_in_frame (p
))
2726 x
= build_addr (p
, context
);
2730 /* If the assignment is from a non-register the stmt is
2731 not valid gimple. Make it so by using a temporary instead. */
2732 if (!is_gimple_reg (x
)
2733 && is_gimple_reg_type (TREE_TYPE (x
)))
2735 gimple_stmt_iterator gsi
= gsi_last (stmt_list
);
2736 x
= init_tmp_var (root
, x
, &gsi
);
2739 y
= build3 (COMPONENT_REF
, TREE_TYPE (field
),
2740 root
->frame_decl
, field
, NULL_TREE
);
2741 stmt
= gimple_build_assign (y
, x
);
2742 gimple_seq_add_stmt (&stmt_list
, stmt
);
2746 /* If a chain_field was created, then it needs to be initialized
2748 if (root
->chain_field
)
2750 tree x
= build3 (COMPONENT_REF
, TREE_TYPE (root
->chain_field
),
2751 root
->frame_decl
, root
->chain_field
, NULL_TREE
);
2752 stmt
= gimple_build_assign (x
, get_chain_decl (root
));
2753 gimple_seq_add_stmt (&stmt_list
, stmt
);
2756 /* If trampolines were created, then we need to initialize them. */
2757 if (root
->any_tramp_created
)
2759 struct nesting_info
*i
;
2760 for (i
= root
->inner
; i
; i
= i
->next
)
2762 tree arg1
, arg2
, arg3
, x
, field
;
2764 field
= lookup_tramp_for_decl (root
, i
->context
, NO_INSERT
);
2768 gcc_assert (DECL_STATIC_CHAIN (i
->context
));
2769 arg3
= build_addr (root
->frame_decl
, context
);
2771 arg2
= build_addr (i
->context
, context
);
2773 x
= build3 (COMPONENT_REF
, TREE_TYPE (field
),
2774 root
->frame_decl
, field
, NULL_TREE
);
2775 arg1
= build_addr (x
, context
);
2777 x
= builtin_decl_implicit (BUILT_IN_INIT_TRAMPOLINE
);
2778 stmt
= gimple_build_call (x
, 3, arg1
, arg2
, arg3
);
2779 gimple_seq_add_stmt (&stmt_list
, stmt
);
2783 /* If we created initialization statements, insert them. */
2787 annotate_all_with_location (stmt_list
, DECL_SOURCE_LOCATION (context
));
2788 bind
= gimple_seq_first_stmt (gimple_body (context
));
2789 gimple_seq_add_seq (&stmt_list
, gimple_bind_body (bind
));
2790 gimple_bind_set_body (bind
, stmt_list
);
2793 /* If a chain_decl was created, then it needs to be registered with
2794 struct function so that it gets initialized from the static chain
2795 register at the beginning of the function. */
2796 sf
= DECL_STRUCT_FUNCTION (root
->context
);
2797 sf
->static_chain_decl
= root
->chain_decl
;
2799 /* Similarly for the non-local goto save area. */
2800 if (root
->nl_goto_field
)
2802 sf
->nonlocal_goto_save_area
2803 = get_frame_field (root
, context
, root
->nl_goto_field
, NULL
);
2804 sf
->has_nonlocal_label
= 1;
2807 /* Make sure all new local variables get inserted into the
2808 proper BIND_EXPR. */
2809 if (root
->new_local_var_chain
)
2810 declare_vars (root
->new_local_var_chain
,
2811 gimple_seq_first_stmt (gimple_body (root
->context
)),
2814 if (root
->debug_var_chain
)
2819 remap_vla_decls (DECL_INITIAL (root
->context
), root
);
2821 for (debug_var
= root
->debug_var_chain
; debug_var
;
2822 debug_var
= DECL_CHAIN (debug_var
))
2823 if (variably_modified_type_p (TREE_TYPE (debug_var
), NULL
))
2826 /* If there are any debug decls with variable length types,
2827 remap those types using other debug_var_chain variables. */
2830 struct nesting_copy_body_data id
;
2832 memset (&id
, 0, sizeof (id
));
2833 id
.cb
.copy_decl
= nesting_copy_decl
;
2834 id
.cb
.decl_map
= new hash_map
<tree
, tree
>;
2837 for (; debug_var
; debug_var
= DECL_CHAIN (debug_var
))
2838 if (variably_modified_type_p (TREE_TYPE (debug_var
), NULL
))
2840 tree type
= TREE_TYPE (debug_var
);
2841 tree newt
, t
= type
;
2842 struct nesting_info
*i
;
2844 for (i
= root
; i
; i
= i
->outer
)
2845 if (variably_modified_type_p (type
, i
->context
))
2851 id
.cb
.src_fn
= i
->context
;
2852 id
.cb
.dst_fn
= i
->context
;
2853 id
.cb
.src_cfun
= DECL_STRUCT_FUNCTION (root
->context
);
2855 TREE_TYPE (debug_var
) = newt
= remap_type (type
, &id
.cb
);
2856 while (POINTER_TYPE_P (newt
) && !TYPE_NAME (newt
))
2858 newt
= TREE_TYPE (newt
);
2861 if (TYPE_NAME (newt
)
2862 && TREE_CODE (TYPE_NAME (newt
)) == TYPE_DECL
2863 && DECL_ORIGINAL_TYPE (TYPE_NAME (newt
))
2865 && TYPE_NAME (newt
) == TYPE_NAME (t
))
2866 TYPE_NAME (newt
) = remap_decl (TYPE_NAME (newt
), &id
.cb
);
2869 delete id
.cb
.decl_map
;
2872 scope
= gimple_seq_first_stmt (gimple_body (root
->context
));
2873 if (gimple_bind_block (scope
))
2874 declare_vars (root
->debug_var_chain
, scope
, true);
2876 BLOCK_VARS (DECL_INITIAL (root
->context
))
2877 = chainon (BLOCK_VARS (DECL_INITIAL (root
->context
)),
2878 root
->debug_var_chain
);
2881 /* Fold the rewritten MEM_REF trees. */
2882 root
->mem_refs
->traverse
<void *, fold_mem_refs
> (NULL
);
2884 /* Dump the translated tree function. */
2887 fputs ("\n\n", dump_file
);
2888 dump_function_to_file (root
->context
, dump_file
, dump_flags
);
2893 finalize_nesting_tree (struct nesting_info
*root
)
2895 struct nesting_info
*n
;
2896 FOR_EACH_NEST_INFO (n
, root
)
2897 finalize_nesting_tree_1 (n
);
2900 /* Unnest the nodes and pass them to cgraph. */
2903 unnest_nesting_tree_1 (struct nesting_info
*root
)
2905 struct cgraph_node
*node
= cgraph_node::get (root
->context
);
2907 /* For nested functions update the cgraph to reflect unnesting.
2908 We also delay finalizing of these functions up to this point. */
2912 cgraph_node::finalize_function (root
->context
, true);
2917 unnest_nesting_tree (struct nesting_info
*root
)
2919 struct nesting_info
*n
;
2920 FOR_EACH_NEST_INFO (n
, root
)
2921 unnest_nesting_tree_1 (n
);
2924 /* Free the data structures allocated during this pass. */
2927 free_nesting_tree (struct nesting_info
*root
)
2929 struct nesting_info
*node
, *next
;
2931 node
= iter_nestinfo_start (root
);
2934 next
= iter_nestinfo_next (node
);
2935 delete node
->var_map
;
2936 delete node
->field_map
;
2937 delete node
->mem_refs
;
2944 /* Gimplify a function and all its nested functions. */
2946 gimplify_all_functions (struct cgraph_node
*root
)
2948 struct cgraph_node
*iter
;
2949 if (!gimple_body (root
->decl
))
2950 gimplify_function_tree (root
->decl
);
2951 for (iter
= root
->nested
; iter
; iter
= iter
->next_nested
)
2952 gimplify_all_functions (iter
);
2955 /* Main entry point for this pass. Process FNDECL and all of its nested
2956 subroutines and turn them into something less tightly bound. */
2959 lower_nested_functions (tree fndecl
)
2961 struct cgraph_node
*cgn
;
2962 struct nesting_info
*root
;
2964 /* If there are no nested functions, there's nothing to do. */
2965 cgn
= cgraph_node::get (fndecl
);
2969 gimplify_all_functions (cgn
);
2971 dump_file
= dump_begin (TDI_nested
, &dump_flags
);
2973 fprintf (dump_file
, "\n;; Function %s\n\n",
2974 lang_hooks
.decl_printable_name (fndecl
, 2));
2976 bitmap_obstack_initialize (&nesting_info_bitmap_obstack
);
2977 root
= create_nesting_tree (cgn
);
2979 walk_all_functions (convert_nonlocal_reference_stmt
,
2980 convert_nonlocal_reference_op
,
2982 walk_all_functions (convert_local_reference_stmt
,
2983 convert_local_reference_op
,
2985 walk_all_functions (convert_nl_goto_reference
, NULL
, root
);
2986 walk_all_functions (convert_nl_goto_receiver
, NULL
, root
);
2988 convert_all_function_calls (root
);
2989 finalize_nesting_tree (root
);
2990 unnest_nesting_tree (root
);
2992 free_nesting_tree (root
);
2993 bitmap_obstack_release (&nesting_info_bitmap_obstack
);
2997 dump_end (TDI_nested
, dump_file
);
3002 #include "gt-tree-nested.h"