Branch data Line data Source code
1 : : /* Nested function decomposition for GIMPLE.
2 : : Copyright (C) 2004-2024 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
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)
9 : : any later version.
10 : :
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.
15 : :
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/>. */
19 : :
20 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "backend.h"
24 : : #include "target.h"
25 : : #include "rtl.h"
26 : : #include "tree.h"
27 : : #include "gimple.h"
28 : : #include "memmodel.h"
29 : : #include "tm_p.h"
30 : : #include "stringpool.h"
31 : : #include "cgraph.h"
32 : : #include "fold-const.h"
33 : : #include "stor-layout.h"
34 : : #include "dumpfile.h"
35 : : #include "tree-inline.h"
36 : : #include "gimplify.h"
37 : : #include "gimple-iterator.h"
38 : : #include "gimple-walk.h"
39 : : #include "tree-cfg.h"
40 : : #include "explow.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"
49 : : #include "attribs.h"
50 : :
51 : : /* Summary of nested functions. */
52 : : static function_summary <nested_function_info *>
53 : : *nested_function_sum = NULL;
54 : :
55 : : /* Return nested_function_info, if available. */
56 : : nested_function_info *
57 : 133094823 : nested_function_info::get (cgraph_node *node)
58 : : {
59 : 133094823 : if (!nested_function_sum)
60 : : return NULL;
61 : 618974 : return nested_function_sum->get (node);
62 : : }
63 : :
64 : : /* Return nested_function_info possibly creating new one. */
65 : : nested_function_info *
66 : 45556 : nested_function_info::get_create (cgraph_node *node)
67 : : {
68 : 45556 : if (!nested_function_sum)
69 : : {
70 : 16960 : nested_function_sum = new function_summary <nested_function_info *>
71 : 8480 : (symtab);
72 : 8480 : nested_function_sum->disable_insertion_hook ();
73 : : }
74 : 45556 : return nested_function_sum->get_create (node);
75 : : }
76 : :
77 : : /* cgraph_node is no longer nested function; update cgraph accordingly. */
78 : : void
79 : 22527 : unnest_function (cgraph_node *node)
80 : : {
81 : 22527 : nested_function_info *info = nested_function_info::get (node);
82 : 22527 : cgraph_node **node2 = &nested_function_info::get
83 : 22527 : (nested_function_origin (node))->nested;
84 : :
85 : 22527 : gcc_checking_assert (info->origin);
86 : 107352 : while (*node2 != node)
87 : 84825 : node2 = &nested_function_info::get (*node2)->next_nested;
88 : 22527 : *node2 = info->next_nested;
89 : 22527 : info->next_nested = NULL;
90 : 22527 : info->origin = NULL;
91 : 22527 : nested_function_sum->remove (node);
92 : 22527 : }
93 : :
94 : : /* Destructor: unlink function from nested function lists. */
95 : 31791 : nested_function_info::~nested_function_info ()
96 : : {
97 : 31791 : cgraph_node *next;
98 : 31895 : for (cgraph_node *n = nested; n; n = next)
99 : : {
100 : 104 : nested_function_info *info = nested_function_info::get (n);
101 : 104 : next = info->next_nested;
102 : 104 : info->origin = NULL;
103 : 104 : info->next_nested = NULL;
104 : : }
105 : 31791 : nested = NULL;
106 : 31791 : if (origin)
107 : : {
108 : 147 : cgraph_node **node2
109 : 147 : = &nested_function_info::get (origin)->nested;
110 : :
111 : 147 : nested_function_info *info;
112 : 147 : while ((info = nested_function_info::get (*node2)) != this && info)
113 : 0 : node2 = &info->next_nested;
114 : 147 : *node2 = next_nested;
115 : : }
116 : 31791 : }
117 : :
118 : : /* Free nested function info summaries. */
119 : : void
120 : 501816 : nested_function_info::release ()
121 : : {
122 : 501816 : if (nested_function_sum)
123 : 8476 : delete (nested_function_sum);
124 : 501816 : nested_function_sum = NULL;
125 : 501816 : }
126 : :
127 : : /* If NODE is nested function, record it. */
128 : : void
129 : 91704981 : maybe_record_nested_function (cgraph_node *node)
130 : : {
131 : : /* All nested functions gets lowered during the construction of symtab. */
132 : 91704981 : if (symtab->state > CONSTRUCTION)
133 : : return;
134 : 91595080 : if (DECL_CONTEXT (node->decl)
135 : 91595080 : && TREE_CODE (DECL_CONTEXT (node->decl)) == FUNCTION_DECL)
136 : : {
137 : 22778 : cgraph_node *origin = cgraph_node::get_create (DECL_CONTEXT (node->decl));
138 : 22778 : nested_function_info *info = nested_function_info::get_create (node);
139 : 22778 : nested_function_info *origin_info
140 : 22778 : = nested_function_info::get_create (origin);
141 : :
142 : 22778 : info->origin = origin;
143 : 22778 : info->next_nested = origin_info->nested;
144 : 22778 : origin_info->nested = node;
145 : : }
146 : : }
147 : :
148 : : /* The object of this pass is to lower the representation of a set of nested
149 : : functions in order to expose all of the gory details of the various
150 : : nonlocal references. We want to do this sooner rather than later, in
151 : : order to give us more freedom in emitting all of the functions in question.
152 : :
153 : : Back in olden times, when gcc was young, we developed an insanely
154 : : complicated scheme whereby variables which were referenced nonlocally
155 : : were forced to live in the stack of the declaring function, and then
156 : : the nested functions magically discovered where these variables were
157 : : placed. In order for this scheme to function properly, it required
158 : : that the outer function be partially expanded, then we switch to
159 : : compiling the inner function, and once done with those we switch back
160 : : to compiling the outer function. Such delicate ordering requirements
161 : : makes it difficult to do whole translation unit optimizations
162 : : involving such functions.
163 : :
164 : : The implementation here is much more direct. Everything that can be
165 : : referenced by an inner function is a member of an explicitly created
166 : : structure herein called the "nonlocal frame struct". The incoming
167 : : static chain for a nested function is a pointer to this struct in
168 : : the parent. In this way, we settle on known offsets from a known
169 : : base, and so are decoupled from the logic that places objects in the
170 : : function's stack frame. More importantly, we don't have to wait for
171 : : that to happen -- since the compilation of the inner function is no
172 : : longer tied to a real stack frame, the nonlocal frame struct can be
173 : : allocated anywhere. Which means that the outer function is now
174 : : inlinable.
175 : :
176 : : Theory of operation here is very simple. Iterate over all the
177 : : statements in all the functions (depth first) several times,
178 : : allocating structures and fields on demand. In general we want to
179 : : examine inner functions first, so that we can avoid making changes
180 : : to outer functions which are unnecessary.
181 : :
182 : : The order of the passes matters a bit, in that later passes will be
183 : : skipped if it is discovered that the functions don't actually interact
184 : : at all. That is, they're nested in the lexical sense but could have
185 : : been written as independent functions without change. */
186 : :
187 : :
188 : : struct nesting_info
189 : : {
190 : : struct nesting_info *outer;
191 : : struct nesting_info *inner;
192 : : struct nesting_info *next;
193 : :
194 : : hash_map<tree, tree> *field_map;
195 : : hash_map<tree, tree> *var_map;
196 : : hash_set<tree *> *mem_refs;
197 : : bitmap suppress_expansion;
198 : :
199 : : tree context;
200 : : tree new_local_var_chain;
201 : : tree debug_var_chain;
202 : : tree frame_type;
203 : : tree frame_decl;
204 : : tree chain_field;
205 : : tree chain_decl;
206 : : tree nl_goto_field;
207 : :
208 : : bool thunk_p;
209 : : bool any_parm_remapped;
210 : : bool any_tramp_created;
211 : : bool any_descr_created;
212 : : char static_chain_added;
213 : : };
214 : :
215 : :
216 : : /* Iterate over the nesting tree, starting with ROOT, depth first. */
217 : :
218 : : static inline struct nesting_info *
219 : 80453 : iter_nestinfo_start (struct nesting_info *root)
220 : : {
221 : 346598 : while (root->inner)
222 : : root = root->inner;
223 : : return root;
224 : : }
225 : :
226 : : static inline struct nesting_info *
227 : 346598 : iter_nestinfo_next (struct nesting_info *node)
228 : : {
229 : 346598 : if (node->next)
230 : : return iter_nestinfo_start (node->next);
231 : 198115 : return node->outer;
232 : : }
233 : :
234 : : #define FOR_EACH_NEST_INFO(I, ROOT) \
235 : : for ((I) = iter_nestinfo_start (ROOT); (I); (I) = iter_nestinfo_next (I))
236 : :
237 : : /* Obstack used for the bitmaps in the struct above. */
238 : : static struct bitmap_obstack nesting_info_bitmap_obstack;
239 : :
240 : :
241 : : /* We're working in so many different function contexts simultaneously,
242 : : that create_tmp_var is dangerous. Prevent mishap. */
243 : : #define create_tmp_var cant_use_create_tmp_var_here_dummy
244 : :
245 : : /* Like create_tmp_var, except record the variable for registration at
246 : : the given nesting level. */
247 : :
248 : : static tree
249 : 18225 : create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix)
250 : : {
251 : 18225 : tree tmp_var;
252 : :
253 : : /* If the type is of variable size or a type which must be created by the
254 : : frontend, something is wrong. Note that we explicitly allow
255 : : incomplete types here, since we create them ourselves here. */
256 : 18225 : gcc_assert (!TREE_ADDRESSABLE (type));
257 : 18225 : gcc_assert (!TYPE_SIZE_UNIT (type)
258 : : || TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
259 : :
260 : 18225 : tmp_var = create_tmp_var_raw (type, prefix);
261 : 18225 : DECL_CONTEXT (tmp_var) = info->context;
262 : 18225 : DECL_CHAIN (tmp_var) = info->new_local_var_chain;
263 : 18225 : DECL_SEEN_IN_BIND_EXPR_P (tmp_var) = 1;
264 : :
265 : 18225 : info->new_local_var_chain = tmp_var;
266 : :
267 : 18225 : return tmp_var;
268 : : }
269 : :
270 : : /* Like build_simple_mem_ref, but set TREE_THIS_NOTRAP on the result. */
271 : :
272 : : static tree
273 : 21071 : build_simple_mem_ref_notrap (tree ptr)
274 : : {
275 : 21071 : tree t = build_simple_mem_ref (ptr);
276 : 21071 : TREE_THIS_NOTRAP (t) = 1;
277 : 21071 : return t;
278 : : }
279 : :
280 : : /* Take the address of EXP to be used within function CONTEXT.
281 : : Mark it for addressability as necessary. */
282 : :
283 : : tree
284 : 35603 : build_addr (tree exp)
285 : : {
286 : 35603 : mark_addressable (exp);
287 : 35603 : return build_fold_addr_expr (exp);
288 : : }
289 : :
290 : : /* Insert FIELD into TYPE, sorted by alignment requirements. */
291 : :
292 : : void
293 : 167920 : insert_field_into_struct (tree type, tree field)
294 : : {
295 : 167920 : tree *p;
296 : :
297 : 167920 : DECL_CONTEXT (field) = type;
298 : :
299 : 208459 : for (p = &TYPE_FIELDS (type); *p ; p = &DECL_CHAIN (*p))
300 : 151236 : if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
301 : : break;
302 : :
303 : 167920 : DECL_CHAIN (field) = *p;
304 : 167920 : *p = field;
305 : :
306 : : /* Set correct alignment for frame struct type. */
307 : 167920 : if (TYPE_ALIGN (type) < DECL_ALIGN (field))
308 : 55140 : SET_TYPE_ALIGN (type, DECL_ALIGN (field));
309 : 167920 : }
310 : :
311 : : /* Build or return the RECORD_TYPE that describes the frame state that is
312 : : shared between INFO->CONTEXT and its nested functions. This record will
313 : : not be complete until finalize_nesting_tree; up until that point we'll
314 : : be adding fields as necessary.
315 : :
316 : : We also build the DECL that represents this frame in the function. */
317 : :
318 : : static tree
319 : 33472 : get_frame_type (struct nesting_info *info)
320 : : {
321 : 33472 : tree type = info->frame_type;
322 : 33472 : if (!type)
323 : : {
324 : 3309 : char *name;
325 : :
326 : 3309 : type = make_node (RECORD_TYPE);
327 : :
328 : 9927 : name = concat ("FRAME.",
329 : 3309 : IDENTIFIER_POINTER (DECL_NAME (info->context)),
330 : : NULL);
331 : 3309 : TYPE_NAME (type) = get_identifier (name);
332 : 3309 : free (name);
333 : :
334 : 3309 : info->frame_type = type;
335 : :
336 : : /* Do not put info->frame_decl on info->new_local_var_chain,
337 : : so that we can declare it in the lexical blocks, which
338 : : makes sure virtual regs that end up appearing in its RTL
339 : : expression get substituted in instantiate_virtual_regs. */
340 : 3309 : info->frame_decl = create_tmp_var_raw (type, "FRAME");
341 : 3309 : DECL_CONTEXT (info->frame_decl) = info->context;
342 : 3309 : DECL_NONLOCAL_FRAME (info->frame_decl) = 1;
343 : 3309 : DECL_SEEN_IN_BIND_EXPR_P (info->frame_decl) = 1;
344 : :
345 : : /* ??? Always make it addressable for now, since it is meant to
346 : : be pointed to by the static chain pointer. This pessimizes
347 : : when it turns out that no static chains are needed because
348 : : the nested functions referencing non-local variables are not
349 : : reachable, but the true pessimization is to create the non-
350 : : local frame structure in the first place. */
351 : 3309 : TREE_ADDRESSABLE (info->frame_decl) = 1;
352 : : }
353 : :
354 : 33472 : return type;
355 : : }
356 : :
357 : : /* Return true if DECL should be referenced by pointer in the non-local frame
358 : : structure. */
359 : :
360 : : static bool
361 : 4038092 : use_pointer_in_frame (tree decl)
362 : : {
363 : 4038092 : if (TREE_CODE (decl) == PARM_DECL)
364 : : {
365 : : /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable-
366 : : sized DECLs, and inefficient to copy large aggregates. Don't bother
367 : : moving anything but scalar parameters. */
368 : 167131 : return AGGREGATE_TYPE_P (TREE_TYPE (decl));
369 : : }
370 : : else
371 : : {
372 : : /* Variable-sized DECLs can only come from OMP clauses at this point
373 : : since the gimplifier has already turned the regular variables into
374 : : pointers. Do the same as the gimplifier. */
375 : 3870961 : return !DECL_SIZE (decl) || TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST;
376 : : }
377 : : }
378 : :
379 : : /* Given DECL, a non-locally accessed variable, find or create a field
380 : : in the non-local frame structure for the given nesting context. */
381 : :
382 : : static tree
383 : 4034732 : lookup_field_for_decl (struct nesting_info *info, tree decl,
384 : : enum insert_option insert)
385 : : {
386 : 4034732 : gcc_checking_assert (decl_function_context (decl) == info->context);
387 : :
388 : 4034732 : if (insert == NO_INSERT)
389 : : {
390 : 4014378 : tree *slot = info->field_map->get (decl);
391 : 4014378 : return slot ? *slot : NULL_TREE;
392 : : }
393 : :
394 : 20354 : tree *slot = &info->field_map->get_or_insert (decl);
395 : 20354 : if (!*slot)
396 : : {
397 : 3252 : tree type = get_frame_type (info);
398 : 3252 : tree field = make_node (FIELD_DECL);
399 : 3252 : DECL_NAME (field) = DECL_NAME (decl);
400 : :
401 : 3252 : if (use_pointer_in_frame (decl))
402 : : {
403 : 27 : TREE_TYPE (field) = build_pointer_type (TREE_TYPE (decl));
404 : 27 : SET_DECL_ALIGN (field, TYPE_ALIGN (TREE_TYPE (field)));
405 : 27 : DECL_NONADDRESSABLE_P (field) = 1;
406 : : }
407 : : else
408 : : {
409 : 3225 : TREE_TYPE (field) = TREE_TYPE (decl);
410 : 3225 : DECL_SOURCE_LOCATION (field) = DECL_SOURCE_LOCATION (decl);
411 : 3225 : SET_DECL_ALIGN (field, DECL_ALIGN (decl));
412 : 3225 : DECL_USER_ALIGN (field) = DECL_USER_ALIGN (decl);
413 : 3225 : DECL_IGNORED_P (field) = DECL_IGNORED_P (decl);
414 : 3225 : DECL_NONADDRESSABLE_P (field) = !TREE_ADDRESSABLE (decl);
415 : 3225 : TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (decl);
416 : 3225 : copy_warning (field, decl);
417 : :
418 : : /* Declare the transformation and adjust the original DECL. For a
419 : : variable or for a parameter when not optimizing, we make it point
420 : : to the field in the frame directly. For a parameter, we don't do
421 : : it when optimizing because the variable tracking pass will already
422 : : do the job, */
423 : 3225 : if (VAR_P (decl) || !optimize)
424 : : {
425 : 3040 : tree x
426 : 3040 : = build3 (COMPONENT_REF, TREE_TYPE (field), info->frame_decl,
427 : : field, NULL_TREE);
428 : :
429 : : /* If the next declaration is a PARM_DECL pointing to the DECL,
430 : : we need to adjust its VALUE_EXPR directly, since chains of
431 : : VALUE_EXPRs run afoul of garbage collection. This occurs
432 : : in Ada for Out parameters that aren't copied in. */
433 : 3040 : tree next = DECL_CHAIN (decl);
434 : 3040 : if (next
435 : 2543 : && TREE_CODE (next) == PARM_DECL
436 : 9 : && DECL_HAS_VALUE_EXPR_P (next)
437 : 3044 : && DECL_VALUE_EXPR (next) == decl)
438 : 0 : SET_DECL_VALUE_EXPR (next, x);
439 : :
440 : 3040 : SET_DECL_VALUE_EXPR (decl, x);
441 : 3040 : DECL_HAS_VALUE_EXPR_P (decl) = 1;
442 : : }
443 : : }
444 : :
445 : 3252 : insert_field_into_struct (type, field);
446 : 3252 : *slot = field;
447 : :
448 : 3252 : if (TREE_CODE (decl) == PARM_DECL)
449 : 250 : info->any_parm_remapped = true;
450 : : }
451 : :
452 : 20354 : return *slot;
453 : : }
454 : :
455 : : /* Build or return the variable that holds the static chain within
456 : : INFO->CONTEXT. This variable may only be used within INFO->CONTEXT. */
457 : :
458 : : static tree
459 : 27085 : get_chain_decl (struct nesting_info *info)
460 : : {
461 : 27085 : tree decl = info->chain_decl;
462 : :
463 : 27085 : if (!decl)
464 : : {
465 : 6432 : tree type;
466 : :
467 : 6432 : type = get_frame_type (info->outer);
468 : 6432 : type = build_pointer_type (type);
469 : :
470 : : /* Note that this variable is *not* entered into any BIND_EXPR;
471 : : the construction of this variable is handled specially in
472 : : expand_function_start and initialize_inlined_parameters.
473 : : Note also that it's represented as a parameter. This is more
474 : : close to the truth, since the initial value does come from
475 : : the caller. */
476 : 6432 : decl = build_decl (DECL_SOURCE_LOCATION (info->context),
477 : : PARM_DECL, create_tmp_var_name ("CHAIN"), type);
478 : 6432 : DECL_ARTIFICIAL (decl) = 1;
479 : 6432 : DECL_IGNORED_P (decl) = 1;
480 : 6432 : TREE_USED (decl) = 1;
481 : 6432 : DECL_CONTEXT (decl) = info->context;
482 : 6432 : DECL_ARG_TYPE (decl) = type;
483 : :
484 : : /* Tell tree-inline.cc that we never write to this variable, so
485 : : it can copy-prop the replacement value immediately. */
486 : 6432 : TREE_READONLY (decl) = 1;
487 : :
488 : 6432 : info->chain_decl = decl;
489 : :
490 : 6432 : if (dump_file
491 : 0 : && (dump_flags & TDF_DETAILS)
492 : 6432 : && !DECL_STATIC_CHAIN (info->context))
493 : 0 : fprintf (dump_file, "Setting static-chain for %s\n",
494 : 0 : lang_hooks.decl_printable_name (info->context, 2));
495 : :
496 : 6432 : DECL_STATIC_CHAIN (info->context) = 1;
497 : : }
498 : 27085 : return decl;
499 : : }
500 : :
501 : : /* Build or return the field within the non-local frame state that holds
502 : : the static chain for INFO->CONTEXT. This is the way to walk back up
503 : : multiple nesting levels. */
504 : :
505 : : static tree
506 : 146 : get_chain_field (struct nesting_info *info)
507 : : {
508 : 146 : tree field = info->chain_field;
509 : :
510 : 146 : if (!field)
511 : : {
512 : 77 : tree type = build_pointer_type (get_frame_type (info->outer));
513 : :
514 : 77 : field = make_node (FIELD_DECL);
515 : 77 : DECL_NAME (field) = get_identifier ("__chain");
516 : 77 : TREE_TYPE (field) = type;
517 : 77 : SET_DECL_ALIGN (field, TYPE_ALIGN (type));
518 : 77 : DECL_NONADDRESSABLE_P (field) = 1;
519 : :
520 : 77 : insert_field_into_struct (get_frame_type (info), field);
521 : :
522 : 77 : info->chain_field = field;
523 : :
524 : 77 : if (dump_file
525 : 0 : && (dump_flags & TDF_DETAILS)
526 : 77 : && !DECL_STATIC_CHAIN (info->context))
527 : 0 : fprintf (dump_file, "Setting static-chain for %s\n",
528 : 0 : lang_hooks.decl_printable_name (info->context, 2));
529 : :
530 : 77 : DECL_STATIC_CHAIN (info->context) = 1;
531 : : }
532 : 146 : return field;
533 : : }
534 : :
535 : : /* Initialize a new temporary with the GIMPLE_CALL STMT. */
536 : :
537 : : static tree
538 : 1311 : init_tmp_var_with_call (struct nesting_info *info, gimple_stmt_iterator *gsi,
539 : : gcall *call)
540 : : {
541 : 1311 : tree t;
542 : :
543 : 1311 : t = create_tmp_var_for (info, gimple_call_return_type (call), NULL);
544 : 1311 : gimple_call_set_lhs (call, t);
545 : 1311 : if (! gsi_end_p (*gsi))
546 : 279 : gimple_set_location (call, gimple_location (gsi_stmt (*gsi)));
547 : 1311 : gsi_insert_before (gsi, call, GSI_SAME_STMT);
548 : :
549 : 1311 : return t;
550 : : }
551 : :
552 : :
553 : : /* Copy EXP into a temporary. Allocate the temporary in the context of
554 : : INFO and insert the initialization statement before GSI. */
555 : :
556 : : static tree
557 : 12308 : init_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
558 : : {
559 : 12308 : tree t;
560 : 12308 : gimple *stmt;
561 : :
562 : 12308 : t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
563 : 12308 : stmt = gimple_build_assign (t, exp);
564 : 12308 : if (! gsi_end_p (*gsi))
565 : 12290 : gimple_set_location (stmt, gimple_location (gsi_stmt (*gsi)));
566 : 12308 : gsi_insert_before_without_update (gsi, stmt, GSI_SAME_STMT);
567 : :
568 : 12308 : return t;
569 : : }
570 : :
571 : :
572 : : /* Similarly, but only do so to force EXP to satisfy is_gimple_val. */
573 : :
574 : : static tree
575 : 3734 : gsi_gimplify_val (struct nesting_info *info, tree exp,
576 : : gimple_stmt_iterator *gsi)
577 : : {
578 : 3734 : if (is_gimple_val (exp))
579 : : return exp;
580 : : else
581 : 548 : return init_tmp_var (info, exp, gsi);
582 : : }
583 : :
584 : : /* Similarly, but copy from the temporary and insert the statement
585 : : after the iterator. */
586 : :
587 : : static tree
588 : 4606 : save_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
589 : : {
590 : 4606 : tree t;
591 : 4606 : gimple *stmt;
592 : :
593 : 4606 : t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
594 : 4606 : stmt = gimple_build_assign (exp, t);
595 : 4606 : if (! gsi_end_p (*gsi))
596 : 4606 : gimple_set_location (stmt, gimple_location (gsi_stmt (*gsi)));
597 : 4606 : gsi_insert_after_without_update (gsi, stmt, GSI_SAME_STMT);
598 : :
599 : 4606 : return t;
600 : : }
601 : :
602 : : /* Build or return the type used to represent a nested function trampoline. */
603 : :
604 : : static GTY(()) tree trampoline_type;
605 : :
606 : : static tree
607 : 262 : get_trampoline_type (struct nesting_info *info)
608 : : {
609 : 262 : unsigned align, size;
610 : 262 : tree t;
611 : :
612 : 262 : if (trampoline_type)
613 : : return trampoline_type;
614 : :
615 : : /* When trampolines are created off-stack then the only thing we need in the
616 : : local frame is a single pointer. */
617 : 230 : if (flag_trampoline_impl == TRAMPOLINE_IMPL_HEAP)
618 : : {
619 : 1 : trampoline_type = build_pointer_type (void_type_node);
620 : 1 : return trampoline_type;
621 : : }
622 : :
623 : 229 : align = TRAMPOLINE_ALIGNMENT;
624 : 229 : size = TRAMPOLINE_SIZE;
625 : :
626 : : /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
627 : : then allocate extra space so that we can do dynamic alignment. */
628 : 229 : if (align > STACK_BOUNDARY)
629 : : {
630 : 0 : size += ((align/BITS_PER_UNIT) - 1) & -(STACK_BOUNDARY/BITS_PER_UNIT);
631 : 0 : align = STACK_BOUNDARY;
632 : : }
633 : :
634 : 229 : t = build_index_type (size_int (size - 1));
635 : 229 : t = build_array_type (char_type_node, t);
636 : 229 : t = build_decl (DECL_SOURCE_LOCATION (info->context),
637 : : FIELD_DECL, get_identifier ("__data"), t);
638 : 229 : SET_DECL_ALIGN (t, align);
639 : 229 : DECL_USER_ALIGN (t) = 1;
640 : :
641 : 229 : trampoline_type = make_node (RECORD_TYPE);
642 : 229 : TYPE_NAME (trampoline_type) = get_identifier ("__builtin_trampoline");
643 : 229 : TYPE_FIELDS (trampoline_type) = t;
644 : 229 : layout_type (trampoline_type);
645 : 229 : DECL_CONTEXT (t) = trampoline_type;
646 : :
647 : 229 : return trampoline_type;
648 : : }
649 : :
650 : : /* Build or return the type used to represent a nested function descriptor. */
651 : :
652 : : static GTY(()) tree descriptor_type;
653 : :
654 : : static tree
655 : 0 : get_descriptor_type (struct nesting_info *info)
656 : : {
657 : : /* The base alignment is that of a function. */
658 : 0 : const unsigned align = FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY);
659 : 0 : tree t;
660 : :
661 : 0 : if (descriptor_type)
662 : : return descriptor_type;
663 : :
664 : 0 : t = build_index_type (integer_one_node);
665 : 0 : t = build_array_type (ptr_type_node, t);
666 : 0 : t = build_decl (DECL_SOURCE_LOCATION (info->context),
667 : : FIELD_DECL, get_identifier ("__data"), t);
668 : 0 : SET_DECL_ALIGN (t, MAX (TYPE_ALIGN (ptr_type_node), align));
669 : 0 : DECL_USER_ALIGN (t) = 1;
670 : :
671 : 0 : descriptor_type = make_node (RECORD_TYPE);
672 : 0 : TYPE_NAME (descriptor_type) = get_identifier ("__builtin_descriptor");
673 : 0 : TYPE_FIELDS (descriptor_type) = t;
674 : 0 : layout_type (descriptor_type);
675 : 0 : DECL_CONTEXT (t) = descriptor_type;
676 : :
677 : 0 : return descriptor_type;
678 : : }
679 : :
680 : : /* Given DECL, a nested function, find or create an element in the
681 : : var map for this function. */
682 : :
683 : : static tree
684 : 619 : lookup_element_for_decl (struct nesting_info *info, tree decl,
685 : : enum insert_option insert)
686 : : {
687 : 619 : if (insert == NO_INSERT)
688 : : {
689 : 337 : tree *slot = info->var_map->get (decl);
690 : 337 : return slot ? *slot : NULL_TREE;
691 : : }
692 : :
693 : 282 : tree *slot = &info->var_map->get_or_insert (decl);
694 : 282 : if (!*slot)
695 : 262 : *slot = build_tree_list (NULL_TREE, NULL_TREE);
696 : :
697 : 282 : return (tree) *slot;
698 : : }
699 : :
700 : : /* Given DECL, a nested function, create a field in the non-local
701 : : frame structure for this function. */
702 : :
703 : : static tree
704 : 262 : create_field_for_decl (struct nesting_info *info, tree decl, tree type)
705 : : {
706 : 262 : tree field = make_node (FIELD_DECL);
707 : 262 : DECL_NAME (field) = DECL_NAME (decl);
708 : 262 : TREE_TYPE (field) = type;
709 : 262 : TREE_ADDRESSABLE (field) = 1;
710 : 262 : insert_field_into_struct (get_frame_type (info), field);
711 : 262 : return field;
712 : : }
713 : :
714 : : /* Given DECL, a nested function, find or create a field in the non-local
715 : : frame structure for a trampoline for this function. */
716 : :
717 : : static tree
718 : 619 : lookup_tramp_for_decl (struct nesting_info *info, tree decl,
719 : : enum insert_option insert)
720 : : {
721 : 619 : tree elt, field;
722 : :
723 : 619 : elt = lookup_element_for_decl (info, decl, insert);
724 : 619 : if (!elt)
725 : : return NULL_TREE;
726 : :
727 : 544 : field = TREE_PURPOSE (elt);
728 : :
729 : 544 : if (!field && insert == INSERT)
730 : : {
731 : 262 : field = create_field_for_decl (info, decl, get_trampoline_type (info));
732 : 262 : TREE_PURPOSE (elt) = field;
733 : 262 : info->any_tramp_created = true;
734 : : }
735 : :
736 : : return field;
737 : : }
738 : :
739 : : /* Given DECL, a nested function, find or create a field in the non-local
740 : : frame structure for a descriptor for this function. */
741 : :
742 : : static tree
743 : 0 : lookup_descr_for_decl (struct nesting_info *info, tree decl,
744 : : enum insert_option insert)
745 : : {
746 : 0 : tree elt, field;
747 : :
748 : 0 : elt = lookup_element_for_decl (info, decl, insert);
749 : 0 : if (!elt)
750 : : return NULL_TREE;
751 : :
752 : 0 : field = TREE_VALUE (elt);
753 : :
754 : 0 : if (!field && insert == INSERT)
755 : : {
756 : 0 : field = create_field_for_decl (info, decl, get_descriptor_type (info));
757 : 0 : TREE_VALUE (elt) = field;
758 : 0 : info->any_descr_created = true;
759 : : }
760 : :
761 : : return field;
762 : : }
763 : :
764 : : /* Build or return the field within the non-local frame state that holds
765 : : the non-local goto "jmp_buf". The buffer itself is maintained by the
766 : : rtl middle-end as dynamic stack space is allocated. */
767 : :
768 : : static tree
769 : 519 : get_nl_goto_field (struct nesting_info *info)
770 : : {
771 : 519 : tree field = info->nl_goto_field;
772 : 519 : if (!field)
773 : : {
774 : 373 : unsigned size;
775 : 373 : tree type;
776 : :
777 : : /* For __builtin_nonlocal_goto, we need N words. The first is the
778 : : frame pointer, the rest is for the target's stack pointer save
779 : : area. The number of words is controlled by STACK_SAVEAREA_MODE;
780 : : not the best interface, but it'll do for now. */
781 : 373 : if (Pmode == ptr_mode)
782 : 373 : type = ptr_type_node;
783 : : else
784 : 0 : type = lang_hooks.types.type_for_mode (Pmode, 1);
785 : :
786 : 373 : fixed_size_mode mode
787 : 373 : = as_a <fixed_size_mode> (STACK_SAVEAREA_MODE (SAVE_NONLOCAL));
788 : 373 : size = GET_MODE_SIZE (mode);
789 : 373 : size = size / GET_MODE_SIZE (Pmode);
790 : 373 : size = size + 1;
791 : :
792 : 373 : type = build_array_type
793 : 373 : (type, build_index_type (size_int (size)));
794 : :
795 : 373 : field = make_node (FIELD_DECL);
796 : 373 : DECL_NAME (field) = get_identifier ("__nl_goto_buf");
797 : 373 : TREE_TYPE (field) = type;
798 : 373 : SET_DECL_ALIGN (field, TYPE_ALIGN (type));
799 : 373 : TREE_ADDRESSABLE (field) = 1;
800 : :
801 : 373 : insert_field_into_struct (get_frame_type (info), field);
802 : :
803 : 373 : info->nl_goto_field = field;
804 : : }
805 : :
806 : 519 : return field;
807 : : }
808 : :
809 : : /* Invoke CALLBACK on all statements of GIMPLE sequence *PSEQ. */
810 : :
811 : : static void
812 : 214232 : walk_body (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
813 : : struct nesting_info *info, gimple_seq *pseq)
814 : : {
815 : 214232 : struct walk_stmt_info wi;
816 : :
817 : 214232 : memset (&wi, 0, sizeof (wi));
818 : 214232 : wi.info = info;
819 : 214232 : wi.val_only = true;
820 : 214232 : walk_gimple_seq_mod (pseq, callback_stmt, callback_op, &wi);
821 : 214232 : }
822 : :
823 : :
824 : : /* Invoke CALLBACK_STMT/CALLBACK_OP on all statements of INFO->CONTEXT. */
825 : :
826 : : static inline void
827 : 189298 : walk_function (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
828 : : struct nesting_info *info)
829 : : {
830 : 189298 : gimple_seq body = gimple_body (info->context);
831 : 189298 : walk_body (callback_stmt, callback_op, info, &body);
832 : 189298 : gimple_set_body (info->context, body);
833 : 189298 : }
834 : :
835 : : /* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body. */
836 : :
837 : : static void
838 : 3012 : walk_gimple_omp_for (gomp_for *for_stmt,
839 : : walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
840 : : struct nesting_info *info)
841 : : {
842 : 3012 : struct walk_stmt_info wi;
843 : 3012 : gimple_seq seq;
844 : 3012 : tree t;
845 : 3012 : size_t i;
846 : :
847 : 3012 : walk_body (callback_stmt, callback_op, info, gimple_omp_for_pre_body_ptr (for_stmt));
848 : :
849 : 3012 : seq = NULL;
850 : 3012 : memset (&wi, 0, sizeof (wi));
851 : 3012 : wi.info = info;
852 : 3012 : wi.gsi = gsi_last (seq);
853 : :
854 : 6942 : for (i = 0; i < gimple_omp_for_collapse (for_stmt); i++)
855 : : {
856 : 3930 : wi.val_only = false;
857 : 3930 : walk_tree (gimple_omp_for_index_ptr (for_stmt, i), callback_op,
858 : : &wi, NULL);
859 : 3930 : wi.val_only = true;
860 : 3930 : wi.is_lhs = false;
861 : 3930 : walk_tree (gimple_omp_for_initial_ptr (for_stmt, i), callback_op,
862 : : &wi, NULL);
863 : :
864 : 3930 : wi.val_only = true;
865 : 3930 : wi.is_lhs = false;
866 : 3930 : walk_tree (gimple_omp_for_final_ptr (for_stmt, i), callback_op,
867 : : &wi, NULL);
868 : :
869 : 3930 : t = gimple_omp_for_incr (for_stmt, i);
870 : 3930 : gcc_assert (BINARY_CLASS_P (t));
871 : 3930 : wi.val_only = false;
872 : 3930 : walk_tree (&TREE_OPERAND (t, 0), callback_op, &wi, NULL);
873 : 3930 : wi.val_only = true;
874 : 3930 : wi.is_lhs = false;
875 : 3930 : walk_tree (&TREE_OPERAND (t, 1), callback_op, &wi, NULL);
876 : : }
877 : :
878 : 3012 : seq = gsi_seq (wi.gsi);
879 : 3012 : if (!gimple_seq_empty_p (seq))
880 : : {
881 : 9 : gimple_seq pre_body = gimple_omp_for_pre_body (for_stmt);
882 : 9 : annotate_all_with_location (seq, gimple_location (for_stmt));
883 : 9 : gimple_seq_add_seq (&pre_body, seq);
884 : 9 : gimple_omp_for_set_pre_body (for_stmt, pre_body);
885 : : }
886 : 3012 : }
887 : :
888 : : /* Similarly for ROOT and all functions nested underneath, depth first. */
889 : :
890 : : static void
891 : 35732 : walk_all_functions (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
892 : : struct nesting_info *root)
893 : : {
894 : 35732 : struct nesting_info *n;
895 : 323144 : FOR_EACH_NEST_INFO (n, root)
896 : 125840 : walk_function (callback_stmt, callback_op, n);
897 : 35732 : }
898 : :
899 : :
900 : : /* We have to check for a fairly pathological case. The operands of function
901 : : nested function are to be interpreted in the context of the enclosing
902 : : function. So if any are variably-sized, they will get remapped when the
903 : : enclosing function is inlined. But that remapping would also have to be
904 : : done in the types of the PARM_DECLs of the nested function, meaning the
905 : : argument types of that function will disagree with the arguments in the
906 : : calls to that function. So we'd either have to make a copy of the nested
907 : : function corresponding to each time the enclosing function was inlined or
908 : : add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
909 : : function. The former is not practical. The latter would still require
910 : : detecting this case to know when to add the conversions. So, for now at
911 : : least, we don't inline such an enclosing function. A similar issue
912 : : applies if the nested function has a variably modified return type, and
913 : : is not inlined, but the enclosing function is inlined and so the type of
914 : : the return slot as used in the enclosing function is remapped, so also
915 : : avoid inlining in that case.
916 : :
917 : : We have to do that check recursively, so here return indicating whether
918 : : FNDECL has such a nested function. ORIG_FN is the function we were
919 : : trying to inline to use for checking whether any argument is variably
920 : : modified by anything in it.
921 : :
922 : : It would be better to do this in tree-inline.cc so that we could give
923 : : the appropriate warning for why a function can't be inlined, but that's
924 : : too late since the nesting structure has already been flattened and
925 : : adding a flag just to record this fact seems a waste of a flag. */
926 : :
927 : : static bool
928 : 53262 : check_for_nested_with_variably_modified (tree fndecl, tree orig_fndecl)
929 : : {
930 : 53262 : struct cgraph_node *cgn = cgraph_node::get (fndecl);
931 : 53262 : tree arg;
932 : :
933 : 150128 : for (cgn = first_nested_function (cgn); cgn;
934 : 21802 : cgn = next_nested_function (cgn))
935 : : {
936 : 22159 : if (variably_modified_type_p (TREE_TYPE (TREE_TYPE (cgn->decl)),
937 : : orig_fndecl))
938 : : return true;
939 : 55069 : for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = DECL_CHAIN (arg))
940 : 33267 : if (variably_modified_type_p (TREE_TYPE (arg), orig_fndecl))
941 : : return true;
942 : :
943 : 21802 : if (check_for_nested_with_variably_modified (cgn->decl,
944 : : orig_fndecl))
945 : : return true;
946 : : }
947 : :
948 : : return false;
949 : : }
950 : :
951 : : /* Construct our local datastructure describing the function nesting
952 : : tree rooted by CGN. */
953 : :
954 : : static struct nesting_info *
955 : 31460 : create_nesting_tree (struct cgraph_node *cgn)
956 : : {
957 : 31460 : struct nesting_info *info = XCNEW (struct nesting_info);
958 : 31460 : info->field_map = new hash_map<tree, tree>;
959 : 31460 : info->var_map = new hash_map<tree, tree>;
960 : 31460 : info->mem_refs = new hash_set<tree *>;
961 : 31460 : info->suppress_expansion = BITMAP_ALLOC (&nesting_info_bitmap_obstack);
962 : 31460 : info->context = cgn->decl;
963 : 31460 : info->thunk_p = cgn->thunk;
964 : :
965 : 85447 : for (cgn = first_nested_function (cgn); cgn;
966 : 22527 : cgn = next_nested_function (cgn))
967 : : {
968 : 22527 : struct nesting_info *sub = create_nesting_tree (cgn);
969 : 22527 : sub->outer = info;
970 : 22527 : sub->next = info->inner;
971 : 22527 : info->inner = sub;
972 : : }
973 : :
974 : : /* See discussion at check_for_nested_with_variably_modified for a
975 : : discussion of why this has to be here. */
976 : 31460 : if (check_for_nested_with_variably_modified (info->context, info->context))
977 : : {
978 : 357 : DECL_UNINLINABLE (info->context) = true;
979 : 357 : tree attrs = DECL_ATTRIBUTES (info->context);
980 : 357 : if (lookup_attribute ("noclone", attrs) == NULL)
981 : 356 : DECL_ATTRIBUTES (info->context)
982 : 712 : = tree_cons (get_identifier ("noclone"), NULL, attrs);
983 : : }
984 : :
985 : 31460 : return info;
986 : : }
987 : :
988 : : /* Return an expression computing the static chain for TARGET_CONTEXT
989 : : from INFO->CONTEXT. Insert any necessary computations before TSI. */
990 : :
991 : : static tree
992 : 15817 : get_static_chain (struct nesting_info *info, tree target_context,
993 : : gimple_stmt_iterator *gsi)
994 : : {
995 : 15817 : struct nesting_info *i;
996 : 15817 : tree x;
997 : :
998 : 15817 : if (info->context == target_context)
999 : : {
1000 : 13682 : x = build_addr (info->frame_decl);
1001 : 13682 : info->static_chain_added |= 1;
1002 : : }
1003 : : else
1004 : : {
1005 : 2135 : x = get_chain_decl (info);
1006 : 2135 : info->static_chain_added |= 2;
1007 : :
1008 : 2175 : for (i = info->outer; i->context != target_context; i = i->outer)
1009 : : {
1010 : 40 : tree field = get_chain_field (i);
1011 : :
1012 : 40 : x = build_simple_mem_ref_notrap (x);
1013 : 40 : x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1014 : 40 : x = init_tmp_var (info, x, gsi);
1015 : : }
1016 : : }
1017 : :
1018 : 15817 : return x;
1019 : : }
1020 : :
1021 : :
1022 : : /* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
1023 : : frame as seen from INFO->CONTEXT. Insert any necessary computations
1024 : : before GSI. */
1025 : :
1026 : : static tree
1027 : 41609 : get_frame_field (struct nesting_info *info, tree target_context,
1028 : : tree field, gimple_stmt_iterator *gsi)
1029 : : {
1030 : 41609 : struct nesting_info *i;
1031 : 41609 : tree x;
1032 : :
1033 : 41609 : if (info->context == target_context)
1034 : : {
1035 : : /* Make sure frame_decl gets created. */
1036 : 21349 : (void) get_frame_type (info);
1037 : 21349 : x = info->frame_decl;
1038 : 21349 : info->static_chain_added |= 1;
1039 : : }
1040 : : else
1041 : : {
1042 : 20260 : x = get_chain_decl (info);
1043 : 20260 : info->static_chain_added |= 2;
1044 : :
1045 : 20366 : for (i = info->outer; i->context != target_context; i = i->outer)
1046 : : {
1047 : 106 : tree field = get_chain_field (i);
1048 : :
1049 : 106 : x = build_simple_mem_ref_notrap (x);
1050 : 106 : x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1051 : 106 : x = init_tmp_var (info, x, gsi);
1052 : : }
1053 : :
1054 : 20260 : x = build_simple_mem_ref_notrap (x);
1055 : : }
1056 : :
1057 : 41609 : x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1058 : 41609 : TREE_THIS_VOLATILE (x) = TREE_THIS_VOLATILE (field);
1059 : 41609 : return x;
1060 : : }
1061 : :
1062 : : static void note_nonlocal_vla_type (struct nesting_info *info, tree type);
1063 : :
1064 : : /* Helper for get_nonlocal_debug_decl and get_local_debug_decl. */
1065 : :
1066 : : static tree
1067 : 703 : get_debug_decl (tree decl)
1068 : : {
1069 : 703 : tree new_decl
1070 : 703 : = build_decl (DECL_SOURCE_LOCATION (decl),
1071 : 703 : VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
1072 : 703 : DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
1073 : 703 : DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
1074 : 703 : TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
1075 : 703 : TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
1076 : 703 : TREE_READONLY (new_decl) = TREE_READONLY (decl);
1077 : 703 : TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
1078 : 703 : DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
1079 : 703 : if ((TREE_CODE (decl) == PARM_DECL
1080 : : || TREE_CODE (decl) == RESULT_DECL
1081 : : || VAR_P (decl))
1082 : 697 : && DECL_BY_REFERENCE (decl))
1083 : 8 : DECL_BY_REFERENCE (new_decl) = 1;
1084 : : /* Copy DECL_LANG_SPECIFIC and DECL_LANG_FLAG_* for OpenMP langhook
1085 : : purposes. */
1086 : 703 : DECL_LANG_SPECIFIC (new_decl) = DECL_LANG_SPECIFIC (decl);
1087 : : #define COPY_DLF(n) DECL_LANG_FLAG_##n (new_decl) = DECL_LANG_FLAG_##n (decl)
1088 : 703 : COPY_DLF (0); COPY_DLF (1); COPY_DLF (2); COPY_DLF (3);
1089 : 703 : COPY_DLF (4); COPY_DLF (5); COPY_DLF (6); COPY_DLF (7);
1090 : 703 : COPY_DLF (8);
1091 : : #undef COPY_DLF
1092 : 703 : return new_decl;
1093 : : }
1094 : :
1095 : : /* A subroutine of convert_nonlocal_reference_op. Create a local variable
1096 : : in the nested function with DECL_VALUE_EXPR set to reference the true
1097 : : variable in the parent function. This is used both for debug info
1098 : : and in OMP lowering. */
1099 : :
1100 : : static tree
1101 : 3578 : get_nonlocal_debug_decl (struct nesting_info *info, tree decl)
1102 : : {
1103 : 3578 : tree target_context;
1104 : 3578 : struct nesting_info *i;
1105 : 3578 : tree x, field, new_decl;
1106 : :
1107 : 3578 : tree *slot = &info->var_map->get_or_insert (decl);
1108 : :
1109 : 3578 : if (*slot)
1110 : : return *slot;
1111 : :
1112 : 638 : target_context = decl_function_context (decl);
1113 : :
1114 : : /* A copy of the code in get_frame_field, but without the temporaries. */
1115 : 638 : if (info->context == target_context)
1116 : : {
1117 : : /* Make sure frame_decl gets created. */
1118 : 0 : (void) get_frame_type (info);
1119 : 0 : x = info->frame_decl;
1120 : 0 : i = info;
1121 : 0 : info->static_chain_added |= 1;
1122 : : }
1123 : : else
1124 : : {
1125 : 638 : x = get_chain_decl (info);
1126 : 638 : info->static_chain_added |= 2;
1127 : 638 : for (i = info->outer; i->context != target_context; i = i->outer)
1128 : : {
1129 : 0 : field = get_chain_field (i);
1130 : 0 : x = build_simple_mem_ref_notrap (x);
1131 : 0 : x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1132 : : }
1133 : 638 : x = build_simple_mem_ref_notrap (x);
1134 : : }
1135 : :
1136 : 638 : field = lookup_field_for_decl (i, decl, INSERT);
1137 : 638 : x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1138 : 638 : if (use_pointer_in_frame (decl))
1139 : 6 : x = build_simple_mem_ref_notrap (x);
1140 : :
1141 : : /* ??? We should be remapping types as well, surely. */
1142 : 638 : new_decl = get_debug_decl (decl);
1143 : 638 : DECL_CONTEXT (new_decl) = info->context;
1144 : :
1145 : 638 : SET_DECL_VALUE_EXPR (new_decl, x);
1146 : 638 : DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
1147 : :
1148 : 638 : *slot = new_decl;
1149 : 638 : DECL_CHAIN (new_decl) = info->debug_var_chain;
1150 : 638 : info->debug_var_chain = new_decl;
1151 : :
1152 : 638 : if (!optimize
1153 : 119 : && info->context != target_context
1154 : 757 : && variably_modified_type_p (TREE_TYPE (decl), NULL))
1155 : 1 : note_nonlocal_vla_type (info, TREE_TYPE (decl));
1156 : :
1157 : : return new_decl;
1158 : : }
1159 : :
1160 : :
1161 : : /* Callback for walk_gimple_stmt, rewrite all references to VAR
1162 : : and PARM_DECLs that belong to outer functions.
1163 : :
1164 : : The rewrite will involve some number of structure accesses back up
1165 : : the static chain. E.g. for a variable FOO up one nesting level it'll
1166 : : be CHAIN->FOO. For two levels it'll be CHAIN->__chain->FOO. Further
1167 : : indirections apply to decls for which use_pointer_in_frame is true. */
1168 : :
1169 : : static tree
1170 : 14599422 : convert_nonlocal_reference_op (tree *tp, int *walk_subtrees, void *data)
1171 : : {
1172 : 14599422 : struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1173 : 14599422 : struct nesting_info *const info = (struct nesting_info *) wi->info;
1174 : 14599422 : tree t = *tp;
1175 : :
1176 : 14599422 : *walk_subtrees = 0;
1177 : 14599422 : switch (TREE_CODE (t))
1178 : : {
1179 : 3868952 : case VAR_DECL:
1180 : : /* Non-automatic variables are never processed. */
1181 : 3868952 : if (TREE_STATIC (t) || DECL_EXTERNAL (t))
1182 : : break;
1183 : : /* FALLTHRU */
1184 : :
1185 : 3860343 : case PARM_DECL:
1186 : 3860343 : {
1187 : 3860343 : tree x, target_context = decl_function_context (t);
1188 : :
1189 : 3860343 : if (info->context == target_context)
1190 : : break;
1191 : :
1192 : 22123 : wi->changed = true;
1193 : :
1194 : 22123 : if (bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
1195 : 2407 : x = get_nonlocal_debug_decl (info, t);
1196 : : else
1197 : : {
1198 : : struct nesting_info *i = info;
1199 : 39538 : while (i && i->context != target_context)
1200 : 19822 : i = i->outer;
1201 : : /* If none of the outer contexts is the target context, this means
1202 : : that the VAR or PARM_DECL is referenced in a wrong context. */
1203 : 19716 : if (!i)
1204 : 0 : internal_error ("%s from %s referenced in %s",
1205 : 0 : IDENTIFIER_POINTER (DECL_NAME (t)),
1206 : 0 : IDENTIFIER_POINTER (DECL_NAME (target_context)),
1207 : 0 : IDENTIFIER_POINTER (DECL_NAME (info->context)));
1208 : :
1209 : 19716 : x = lookup_field_for_decl (i, t, INSERT);
1210 : 19716 : x = get_frame_field (info, target_context, x, &wi->gsi);
1211 : 19716 : if (use_pointer_in_frame (t))
1212 : : {
1213 : 21 : x = init_tmp_var (info, x, &wi->gsi);
1214 : 21 : x = build_simple_mem_ref_notrap (x);
1215 : : }
1216 : : }
1217 : :
1218 : 22123 : if (wi->val_only)
1219 : : {
1220 : 7783 : if (wi->is_lhs)
1221 : 1943 : x = save_tmp_var (info, x, &wi->gsi);
1222 : : else
1223 : 5840 : x = init_tmp_var (info, x, &wi->gsi);
1224 : : }
1225 : :
1226 : 22123 : *tp = x;
1227 : : }
1228 : 22123 : break;
1229 : :
1230 : 1572788 : case LABEL_DECL:
1231 : : /* We're taking the address of a label from a parent function, but
1232 : : this is not itself a non-local goto. Mark the label such that it
1233 : : will not be deleted, much as we would with a label address in
1234 : : static storage. */
1235 : 1572788 : if (decl_function_context (t) != info->context)
1236 : 79 : FORCED_LABEL (t) = 1;
1237 : : break;
1238 : :
1239 : 644725 : case ADDR_EXPR:
1240 : 644725 : {
1241 : 644725 : bool save_val_only = wi->val_only;
1242 : :
1243 : 644725 : wi->val_only = false;
1244 : 644725 : wi->is_lhs = false;
1245 : 644725 : wi->changed = false;
1246 : 644725 : walk_tree (&TREE_OPERAND (t, 0), convert_nonlocal_reference_op, wi, 0);
1247 : 644725 : wi->val_only = true;
1248 : :
1249 : 644725 : if (wi->changed)
1250 : : {
1251 : 2697 : tree save_context;
1252 : :
1253 : : /* If we changed anything, we might no longer be directly
1254 : : referencing a decl. */
1255 : 2697 : save_context = current_function_decl;
1256 : 2697 : current_function_decl = info->context;
1257 : 2697 : recompute_tree_invariant_for_addr_expr (t);
1258 : :
1259 : : /* If the callback converted the address argument in a context
1260 : : where we only accept variables (and min_invariant, presumably),
1261 : : then compute the address into a temporary. */
1262 : 2697 : if (save_val_only)
1263 : 0 : *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
1264 : : t, &wi->gsi);
1265 : 2697 : current_function_decl = save_context;
1266 : : }
1267 : : }
1268 : : break;
1269 : :
1270 : 1723939 : case REALPART_EXPR:
1271 : 1723939 : case IMAGPART_EXPR:
1272 : 1723939 : case COMPONENT_REF:
1273 : 1723939 : case ARRAY_REF:
1274 : 1723939 : case ARRAY_RANGE_REF:
1275 : 1723939 : case BIT_FIELD_REF:
1276 : : /* Go down this entire nest and just look at the final prefix and
1277 : : anything that describes the references. Otherwise, we lose track
1278 : : of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
1279 : 1723939 : wi->val_only = true;
1280 : 1723939 : wi->is_lhs = false;
1281 : 5037823 : for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1282 : : {
1283 : 3313884 : if (TREE_CODE (t) == COMPONENT_REF)
1284 : 2486684 : walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op, wi,
1285 : : NULL);
1286 : 827200 : else if (TREE_CODE (t) == ARRAY_REF
1287 : 827200 : || TREE_CODE (t) == ARRAY_RANGE_REF)
1288 : : {
1289 : 826552 : walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference_op,
1290 : : wi, NULL);
1291 : 826552 : walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op,
1292 : : wi, NULL);
1293 : 826552 : walk_tree (&TREE_OPERAND (t, 3), convert_nonlocal_reference_op,
1294 : : wi, NULL);
1295 : : }
1296 : : }
1297 : 1723939 : wi->val_only = false;
1298 : 1723939 : walk_tree (tp, convert_nonlocal_reference_op, wi, NULL);
1299 : 1723939 : break;
1300 : :
1301 : 851 : case VIEW_CONVERT_EXPR:
1302 : : /* Just request to look at the subtrees, leaving val_only and lhs
1303 : : untouched. This might actually be for !val_only + lhs, in which
1304 : : case we don't want to force a replacement by a temporary. */
1305 : 851 : *walk_subtrees = 1;
1306 : 851 : break;
1307 : :
1308 : 6643049 : default:
1309 : 6643049 : if (!IS_TYPE_OR_DECL_P (t))
1310 : : {
1311 : 6306833 : *walk_subtrees = 1;
1312 : 6306833 : wi->val_only = true;
1313 : 6306833 : wi->is_lhs = false;
1314 : : }
1315 : : break;
1316 : : }
1317 : :
1318 : 14599422 : return NULL_TREE;
1319 : : }
1320 : :
1321 : : static tree convert_nonlocal_reference_stmt (gimple_stmt_iterator *, bool *,
1322 : : struct walk_stmt_info *);
1323 : :
1324 : : /* Helper for convert_nonlocal_references, rewrite all references to VAR
1325 : : and PARM_DECLs that belong to outer functions. */
1326 : :
1327 : : static bool
1328 : 4885 : convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1329 : : {
1330 : 4885 : struct nesting_info *const info = (struct nesting_info *) wi->info;
1331 : 4885 : bool need_chain = false, need_stmts = false;
1332 : 4885 : tree clause, decl, *pdecl;
1333 : 4885 : int dummy;
1334 : 4885 : bitmap new_suppress;
1335 : :
1336 : 4885 : new_suppress = BITMAP_GGC_ALLOC ();
1337 : 4885 : bitmap_copy (new_suppress, info->suppress_expansion);
1338 : :
1339 : 29056 : for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1340 : : {
1341 : 24171 : pdecl = NULL;
1342 : 24171 : switch (OMP_CLAUSE_CODE (clause))
1343 : : {
1344 : 663 : case OMP_CLAUSE_REDUCTION:
1345 : 663 : case OMP_CLAUSE_IN_REDUCTION:
1346 : 663 : case OMP_CLAUSE_TASK_REDUCTION:
1347 : 663 : if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1348 : 37 : need_stmts = true;
1349 : 663 : if (TREE_CODE (OMP_CLAUSE_DECL (clause)) == MEM_REF)
1350 : : {
1351 : 6 : pdecl = &TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0);
1352 : 6 : if (TREE_CODE (*pdecl) == POINTER_PLUS_EXPR)
1353 : 0 : pdecl = &TREE_OPERAND (*pdecl, 0);
1354 : 6 : if (INDIRECT_REF_P (*pdecl)
1355 : 6 : || TREE_CODE (*pdecl) == ADDR_EXPR)
1356 : 4 : pdecl = &TREE_OPERAND (*pdecl, 0);
1357 : : }
1358 : 663 : goto do_decl_clause;
1359 : :
1360 : 1152 : case OMP_CLAUSE_LASTPRIVATE:
1361 : 1152 : if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
1362 : 250 : need_stmts = true;
1363 : 1152 : goto do_decl_clause;
1364 : :
1365 : 391 : case OMP_CLAUSE_LINEAR:
1366 : 391 : if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause))
1367 : 74 : need_stmts = true;
1368 : 391 : wi->val_only = true;
1369 : 391 : wi->is_lhs = false;
1370 : 391 : convert_nonlocal_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause),
1371 : : &dummy, wi);
1372 : 391 : goto do_decl_clause;
1373 : :
1374 : 5637 : case OMP_CLAUSE_PRIVATE:
1375 : 5637 : case OMP_CLAUSE_FIRSTPRIVATE:
1376 : 5637 : case OMP_CLAUSE_COPYPRIVATE:
1377 : 5637 : case OMP_CLAUSE_SHARED:
1378 : 5637 : case OMP_CLAUSE_ENTER:
1379 : 5637 : case OMP_CLAUSE_LINK:
1380 : 5637 : case OMP_CLAUSE_USE_DEVICE_PTR:
1381 : 5637 : case OMP_CLAUSE_USE_DEVICE_ADDR:
1382 : 5637 : case OMP_CLAUSE_HAS_DEVICE_ADDR:
1383 : 5637 : case OMP_CLAUSE_IS_DEVICE_PTR:
1384 : 5637 : case OMP_CLAUSE_DETACH:
1385 : 5637 : do_decl_clause:
1386 : 2206 : if (pdecl == NULL)
1387 : 16612 : pdecl = &OMP_CLAUSE_DECL (clause);
1388 : 16618 : decl = *pdecl;
1389 : 16618 : if (VAR_P (decl)
1390 : 16618 : && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1391 : : break;
1392 : 16172 : if (decl_function_context (decl) != info->context)
1393 : : {
1394 : 1157 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_SHARED)
1395 : 356 : OMP_CLAUSE_SHARED_READONLY (clause) = 0;
1396 : 1157 : bitmap_set_bit (new_suppress, DECL_UID (decl));
1397 : 1157 : *pdecl = get_nonlocal_debug_decl (info, decl);
1398 : 1157 : if (OMP_CLAUSE_CODE (clause) != OMP_CLAUSE_PRIVATE)
1399 : 24171 : need_chain = true;
1400 : : }
1401 : : break;
1402 : :
1403 : 165 : case OMP_CLAUSE_SCHEDULE:
1404 : 165 : if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1405 : : break;
1406 : : /* FALLTHRU */
1407 : 2506 : case OMP_CLAUSE_FINAL:
1408 : 2506 : case OMP_CLAUSE_IF:
1409 : 2506 : case OMP_CLAUSE_SELF:
1410 : 2506 : case OMP_CLAUSE_NUM_THREADS:
1411 : 2506 : case OMP_CLAUSE_DEPEND:
1412 : 2506 : case OMP_CLAUSE_DOACROSS:
1413 : 2506 : case OMP_CLAUSE_DEVICE:
1414 : 2506 : case OMP_CLAUSE_NUM_TEAMS:
1415 : 2506 : case OMP_CLAUSE_THREAD_LIMIT:
1416 : 2506 : case OMP_CLAUSE_SAFELEN:
1417 : 2506 : case OMP_CLAUSE_SIMDLEN:
1418 : 2506 : case OMP_CLAUSE_PRIORITY:
1419 : 2506 : case OMP_CLAUSE_GRAINSIZE:
1420 : 2506 : case OMP_CLAUSE_NUM_TASKS:
1421 : 2506 : case OMP_CLAUSE_HINT:
1422 : 2506 : case OMP_CLAUSE_FILTER:
1423 : 2506 : case OMP_CLAUSE_NUM_GANGS:
1424 : 2506 : case OMP_CLAUSE_NUM_WORKERS:
1425 : 2506 : case OMP_CLAUSE_VECTOR_LENGTH:
1426 : 2506 : case OMP_CLAUSE_GANG:
1427 : 2506 : case OMP_CLAUSE_WORKER:
1428 : 2506 : case OMP_CLAUSE_VECTOR:
1429 : 2506 : case OMP_CLAUSE_ASYNC:
1430 : 2506 : case OMP_CLAUSE_WAIT:
1431 : : /* Several OpenACC clauses have optional arguments. Check if they
1432 : : are present. */
1433 : 2506 : if (OMP_CLAUSE_OPERAND (clause, 0))
1434 : : {
1435 : 2250 : wi->val_only = true;
1436 : 2250 : wi->is_lhs = false;
1437 : 2250 : convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
1438 : : &dummy, wi);
1439 : : }
1440 : :
1441 : : /* The gang clause accepts two arguments. */
1442 : 2506 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_GANG
1443 : 2506 : && OMP_CLAUSE_GANG_STATIC_EXPR (clause))
1444 : : {
1445 : 28 : wi->val_only = true;
1446 : 28 : wi->is_lhs = false;
1447 : 28 : convert_nonlocal_reference_op
1448 : 28 : (&OMP_CLAUSE_GANG_STATIC_EXPR (clause), &dummy, wi);
1449 : : }
1450 : : break;
1451 : :
1452 : 7 : case OMP_CLAUSE_DIST_SCHEDULE:
1453 : 7 : if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause) != NULL)
1454 : : {
1455 : 7 : wi->val_only = true;
1456 : 7 : wi->is_lhs = false;
1457 : 7 : convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
1458 : : &dummy, wi);
1459 : : }
1460 : : break;
1461 : :
1462 : 7295 : case OMP_CLAUSE_MAP:
1463 : 7295 : case OMP_CLAUSE_TO:
1464 : 7295 : case OMP_CLAUSE_FROM:
1465 : 7295 : if (OMP_CLAUSE_SIZE (clause))
1466 : : {
1467 : 7295 : wi->val_only = true;
1468 : 7295 : wi->is_lhs = false;
1469 : 7295 : convert_nonlocal_reference_op (&OMP_CLAUSE_SIZE (clause),
1470 : : &dummy, wi);
1471 : : }
1472 : 7295 : if (DECL_P (OMP_CLAUSE_DECL (clause)))
1473 : 3431 : goto do_decl_clause;
1474 : 3864 : wi->val_only = true;
1475 : 3864 : wi->is_lhs = false;
1476 : 3864 : walk_tree (&OMP_CLAUSE_DECL (clause), convert_nonlocal_reference_op,
1477 : : wi, NULL);
1478 : 3864 : break;
1479 : :
1480 : 6 : case OMP_CLAUSE_ALIGNED:
1481 : 6 : if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
1482 : : {
1483 : 6 : wi->val_only = true;
1484 : 6 : wi->is_lhs = false;
1485 : 6 : convert_nonlocal_reference_op
1486 : 6 : (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause), &dummy, wi);
1487 : : }
1488 : : /* FALLTHRU */
1489 : 6 : case OMP_CLAUSE_NONTEMPORAL:
1490 : 0 : do_decl_clause_no_supp:
1491 : : /* Like do_decl_clause, but don't add any suppression. */
1492 : 6 : decl = OMP_CLAUSE_DECL (clause);
1493 : 6 : if (VAR_P (decl)
1494 : 6 : && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1495 : : break;
1496 : 6 : if (decl_function_context (decl) != info->context)
1497 : : {
1498 : 6 : OMP_CLAUSE_DECL (clause) = get_nonlocal_debug_decl (info, decl);
1499 : 6 : need_chain = true;
1500 : : }
1501 : : break;
1502 : :
1503 : 0 : case OMP_CLAUSE_ALLOCATE:
1504 : 0 : if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause))
1505 : : {
1506 : 0 : wi->val_only = true;
1507 : 0 : wi->is_lhs = false;
1508 : 0 : convert_nonlocal_reference_op
1509 : 0 : (&OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause), &dummy, wi);
1510 : : }
1511 : 0 : goto do_decl_clause_no_supp;
1512 : :
1513 : : case OMP_CLAUSE_NOWAIT:
1514 : : case OMP_CLAUSE_ORDERED:
1515 : : case OMP_CLAUSE_DEFAULT:
1516 : : case OMP_CLAUSE_COPYIN:
1517 : : case OMP_CLAUSE_COLLAPSE:
1518 : : case OMP_CLAUSE_TILE:
1519 : : case OMP_CLAUSE_UNTIED:
1520 : : case OMP_CLAUSE_MERGEABLE:
1521 : : case OMP_CLAUSE_PROC_BIND:
1522 : : case OMP_CLAUSE_NOGROUP:
1523 : : case OMP_CLAUSE_THREADS:
1524 : : case OMP_CLAUSE_SIMD:
1525 : : case OMP_CLAUSE_DEFAULTMAP:
1526 : : case OMP_CLAUSE_ORDER:
1527 : : case OMP_CLAUSE_SEQ:
1528 : : case OMP_CLAUSE_INDEPENDENT:
1529 : : case OMP_CLAUSE_AUTO:
1530 : : case OMP_CLAUSE_IF_PRESENT:
1531 : : case OMP_CLAUSE_FINALIZE:
1532 : : case OMP_CLAUSE_BIND:
1533 : : case OMP_CLAUSE__CONDTEMP_:
1534 : : case OMP_CLAUSE__SCANTEMP_:
1535 : : break;
1536 : :
1537 : : /* The following clause belongs to the OpenACC cache directive, which
1538 : : is discarded during gimplification. */
1539 : 0 : case OMP_CLAUSE__CACHE_:
1540 : : /* The following clauses are only allowed in the OpenMP declare simd
1541 : : directive, so not seen here. */
1542 : 0 : case OMP_CLAUSE_UNIFORM:
1543 : 0 : case OMP_CLAUSE_INBRANCH:
1544 : 0 : case OMP_CLAUSE_NOTINBRANCH:
1545 : : /* The following clauses are only allowed on OpenMP cancel and
1546 : : cancellation point directives, which at this point have already
1547 : : been lowered into a function call. */
1548 : 0 : case OMP_CLAUSE_FOR:
1549 : 0 : case OMP_CLAUSE_PARALLEL:
1550 : 0 : case OMP_CLAUSE_SECTIONS:
1551 : 0 : case OMP_CLAUSE_TASKGROUP:
1552 : : /* The following clauses are only added during OMP lowering; nested
1553 : : function decomposition happens before that. */
1554 : 0 : case OMP_CLAUSE__LOOPTEMP_:
1555 : 0 : case OMP_CLAUSE__REDUCTEMP_:
1556 : 0 : case OMP_CLAUSE__SIMDUID_:
1557 : 0 : case OMP_CLAUSE__SIMT_:
1558 : : /* The following clauses are only allowed on OpenACC 'routine'
1559 : : directives, not seen here. */
1560 : 0 : case OMP_CLAUSE_NOHOST:
1561 : : /* Anything else. */
1562 : 0 : default:
1563 : 0 : gcc_unreachable ();
1564 : : }
1565 : : }
1566 : :
1567 : 4885 : info->suppress_expansion = new_suppress;
1568 : :
1569 : 4885 : if (need_stmts)
1570 : 1540 : for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1571 : 1255 : switch (OMP_CLAUSE_CODE (clause))
1572 : : {
1573 : 103 : case OMP_CLAUSE_REDUCTION:
1574 : 103 : case OMP_CLAUSE_IN_REDUCTION:
1575 : 103 : case OMP_CLAUSE_TASK_REDUCTION:
1576 : 103 : if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1577 : : {
1578 : 37 : tree old_context
1579 : 37 : = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1580 : 37 : DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1581 : 37 : = info->context;
1582 : 37 : if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
1583 : 0 : DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
1584 : 0 : = info->context;
1585 : 37 : tree save_local_var_chain = info->new_local_var_chain;
1586 : 37 : info->new_local_var_chain = NULL;
1587 : 37 : gimple_seq *seq = &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause);
1588 : 37 : walk_body (convert_nonlocal_reference_stmt,
1589 : : convert_nonlocal_reference_op, info, seq);
1590 : 37 : if (info->new_local_var_chain)
1591 : 1 : declare_vars (info->new_local_var_chain,
1592 : : gimple_seq_first_stmt (*seq), false);
1593 : 37 : info->new_local_var_chain = NULL;
1594 : 37 : seq = &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause);
1595 : 37 : walk_body (convert_nonlocal_reference_stmt,
1596 : : convert_nonlocal_reference_op, info, seq);
1597 : 37 : if (info->new_local_var_chain)
1598 : 1 : declare_vars (info->new_local_var_chain,
1599 : : gimple_seq_first_stmt (*seq), false);
1600 : 37 : info->new_local_var_chain = save_local_var_chain;
1601 : 37 : DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1602 : 37 : = old_context;
1603 : 37 : if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
1604 : 0 : DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
1605 : 0 : = old_context;
1606 : : }
1607 : : break;
1608 : :
1609 : 625 : case OMP_CLAUSE_LASTPRIVATE:
1610 : 625 : case OMP_CLAUSE_LINEAR:
1611 : 625 : {
1612 : 625 : tree save_local_var_chain = info->new_local_var_chain;
1613 : 625 : info->new_local_var_chain = NULL;
1614 : 625 : gimple_seq *seq;
1615 : 625 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_LASTPRIVATE)
1616 : 410 : seq = &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause);
1617 : : else
1618 : 215 : seq = &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause);
1619 : 625 : walk_body (convert_nonlocal_reference_stmt,
1620 : : convert_nonlocal_reference_op, info, seq);
1621 : 625 : if (info->new_local_var_chain)
1622 : : {
1623 : 8 : gimple *g = gimple_seq_first_stmt (*seq);
1624 : 8 : if (gimple_code (g) != GIMPLE_BIND)
1625 : : {
1626 : 2 : g = gimple_build_bind (NULL_TREE, *seq, NULL_TREE);
1627 : 2 : *seq = NULL;
1628 : 2 : gimple_seq_add_stmt_without_update (seq, g);
1629 : : }
1630 : 8 : declare_vars (info->new_local_var_chain,
1631 : : gimple_seq_first_stmt (*seq), false);
1632 : : }
1633 : 625 : info->new_local_var_chain = save_local_var_chain;
1634 : : }
1635 : 625 : break;
1636 : :
1637 : : default:
1638 : : break;
1639 : : }
1640 : :
1641 : 4885 : return need_chain;
1642 : : }
1643 : :
1644 : : /* Create nonlocal debug decls for nonlocal VLA array bounds. */
1645 : :
1646 : : static void
1647 : 2 : note_nonlocal_vla_type (struct nesting_info *info, tree type)
1648 : : {
1649 : 3 : while (POINTER_TYPE_P (type) && !TYPE_NAME (type))
1650 : 1 : type = TREE_TYPE (type);
1651 : :
1652 : 2 : if (TYPE_NAME (type)
1653 : 2 : && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1654 : 4 : && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1655 : 1 : type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1656 : :
1657 : 2 : while (POINTER_TYPE_P (type)
1658 : : || VECTOR_TYPE_P (type)
1659 : : || TREE_CODE (type) == FUNCTION_TYPE
1660 : 2 : || TREE_CODE (type) == METHOD_TYPE)
1661 : 0 : type = TREE_TYPE (type);
1662 : :
1663 : 2 : if (TREE_CODE (type) == ARRAY_TYPE)
1664 : : {
1665 : 1 : tree domain, t;
1666 : :
1667 : 1 : note_nonlocal_vla_type (info, TREE_TYPE (type));
1668 : 1 : domain = TYPE_DOMAIN (type);
1669 : 1 : if (domain)
1670 : : {
1671 : 1 : t = TYPE_MIN_VALUE (domain);
1672 : 1 : if (t && (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
1673 : 1 : && decl_function_context (t) != info->context)
1674 : 0 : get_nonlocal_debug_decl (info, t);
1675 : 1 : t = TYPE_MAX_VALUE (domain);
1676 : 1 : if (t && (VAR_P (t) || TREE_CODE (t) == PARM_DECL)
1677 : 2 : && decl_function_context (t) != info->context)
1678 : 1 : get_nonlocal_debug_decl (info, t);
1679 : : }
1680 : : }
1681 : 2 : }
1682 : :
1683 : : /* Callback for walk_gimple_stmt. Rewrite all references to VAR and
1684 : : PARM_DECLs that belong to outer functions. This handles statements
1685 : : that are not handled via the standard recursion done in
1686 : : walk_gimple_stmt. STMT is the statement to examine, DATA is as in
1687 : : convert_nonlocal_reference_op. Set *HANDLED_OPS_P to true if all the
1688 : : operands of STMT have been handled by this function. */
1689 : :
1690 : : static tree
1691 : 5375886 : convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1692 : : struct walk_stmt_info *wi)
1693 : : {
1694 : 5375886 : struct nesting_info *info = (struct nesting_info *) wi->info;
1695 : 5375886 : tree save_local_var_chain;
1696 : 5375886 : bitmap save_suppress;
1697 : 5375886 : gimple *stmt = gsi_stmt (*gsi);
1698 : :
1699 : 5375886 : switch (gimple_code (stmt))
1700 : : {
1701 : 211904 : case GIMPLE_GOTO:
1702 : : /* Don't walk non-local gotos for now. */
1703 : 211904 : if (TREE_CODE (gimple_goto_dest (stmt)) != LABEL_DECL)
1704 : : {
1705 : 75 : wi->val_only = true;
1706 : 75 : wi->is_lhs = false;
1707 : 75 : *handled_ops_p = false;
1708 : 75 : return NULL_TREE;
1709 : : }
1710 : : break;
1711 : :
1712 : 38 : case GIMPLE_OMP_TEAMS:
1713 : 38 : if (!gimple_omp_teams_host (as_a <gomp_teams *> (stmt)))
1714 : : {
1715 : 26 : save_suppress = info->suppress_expansion;
1716 : 26 : convert_nonlocal_omp_clauses (gimple_omp_teams_clauses_ptr (stmt),
1717 : : wi);
1718 : 26 : walk_body (convert_nonlocal_reference_stmt,
1719 : : convert_nonlocal_reference_op, info,
1720 : : gimple_omp_body_ptr (stmt));
1721 : 26 : info->suppress_expansion = save_suppress;
1722 : 26 : break;
1723 : : }
1724 : : /* FALLTHRU */
1725 : :
1726 : 1321 : case GIMPLE_OMP_PARALLEL:
1727 : 1321 : case GIMPLE_OMP_TASK:
1728 : 1321 : save_suppress = info->suppress_expansion;
1729 : 1321 : if (convert_nonlocal_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
1730 : : wi))
1731 : : {
1732 : 152 : tree c, decl;
1733 : 152 : decl = get_chain_decl (info);
1734 : 152 : c = build_omp_clause (gimple_location (stmt),
1735 : : OMP_CLAUSE_FIRSTPRIVATE);
1736 : 152 : OMP_CLAUSE_DECL (c) = decl;
1737 : 152 : OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
1738 : 152 : gimple_omp_taskreg_set_clauses (stmt, c);
1739 : : }
1740 : :
1741 : 1321 : save_local_var_chain = info->new_local_var_chain;
1742 : 1321 : info->new_local_var_chain = NULL;
1743 : :
1744 : 1321 : walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1745 : : info, gimple_omp_body_ptr (stmt));
1746 : :
1747 : 1321 : if (info->new_local_var_chain)
1748 : 110 : declare_vars (info->new_local_var_chain,
1749 : : gimple_seq_first_stmt (gimple_omp_body (stmt)),
1750 : : false);
1751 : 1321 : info->new_local_var_chain = save_local_var_chain;
1752 : 1321 : info->suppress_expansion = save_suppress;
1753 : 1321 : break;
1754 : :
1755 : 1506 : case GIMPLE_OMP_FOR:
1756 : 1506 : save_suppress = info->suppress_expansion;
1757 : 1506 : convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
1758 : 1506 : walk_gimple_omp_for (as_a <gomp_for *> (stmt),
1759 : : convert_nonlocal_reference_stmt,
1760 : : convert_nonlocal_reference_op, info);
1761 : 1506 : walk_body (convert_nonlocal_reference_stmt,
1762 : : convert_nonlocal_reference_op, info, gimple_omp_body_ptr (stmt));
1763 : 1506 : info->suppress_expansion = save_suppress;
1764 : 1506 : break;
1765 : :
1766 : 42 : case GIMPLE_OMP_SECTIONS:
1767 : 42 : save_suppress = info->suppress_expansion;
1768 : 42 : convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
1769 : 42 : walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1770 : : info, gimple_omp_body_ptr (stmt));
1771 : 42 : info->suppress_expansion = save_suppress;
1772 : 42 : break;
1773 : :
1774 : 185 : case GIMPLE_OMP_SINGLE:
1775 : 185 : save_suppress = info->suppress_expansion;
1776 : 185 : convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
1777 : 185 : walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1778 : : info, gimple_omp_body_ptr (stmt));
1779 : 185 : info->suppress_expansion = save_suppress;
1780 : 185 : break;
1781 : :
1782 : 0 : case GIMPLE_OMP_SCOPE:
1783 : 0 : save_suppress = info->suppress_expansion;
1784 : 0 : convert_nonlocal_omp_clauses (gimple_omp_scope_clauses_ptr (stmt), wi);
1785 : 0 : walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1786 : : info, gimple_omp_body_ptr (stmt));
1787 : 0 : info->suppress_expansion = save_suppress;
1788 : 0 : break;
1789 : :
1790 : 38 : case GIMPLE_OMP_TASKGROUP:
1791 : 38 : save_suppress = info->suppress_expansion;
1792 : 38 : convert_nonlocal_omp_clauses (gimple_omp_taskgroup_clauses_ptr (stmt), wi);
1793 : 38 : walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1794 : : info, gimple_omp_body_ptr (stmt));
1795 : 38 : info->suppress_expansion = save_suppress;
1796 : 38 : break;
1797 : :
1798 : 1767 : case GIMPLE_OMP_TARGET:
1799 : 1767 : if (!is_gimple_omp_offloaded (stmt))
1800 : : {
1801 : 648 : save_suppress = info->suppress_expansion;
1802 : 648 : convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt),
1803 : : wi);
1804 : 648 : info->suppress_expansion = save_suppress;
1805 : 648 : walk_body (convert_nonlocal_reference_stmt,
1806 : : convert_nonlocal_reference_op, info,
1807 : : gimple_omp_body_ptr (stmt));
1808 : 648 : break;
1809 : : }
1810 : 1119 : save_suppress = info->suppress_expansion;
1811 : 1119 : if (convert_nonlocal_omp_clauses (gimple_omp_target_clauses_ptr (stmt),
1812 : : wi))
1813 : : {
1814 : 55 : tree c, decl;
1815 : 55 : decl = get_chain_decl (info);
1816 : 55 : c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP);
1817 : 55 : OMP_CLAUSE_DECL (c) = decl;
1818 : 55 : OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TO);
1819 : 55 : OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
1820 : 55 : OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
1821 : 55 : gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt), c);
1822 : : }
1823 : :
1824 : 1119 : save_local_var_chain = info->new_local_var_chain;
1825 : 1119 : info->new_local_var_chain = NULL;
1826 : :
1827 : 1119 : walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1828 : : info, gimple_omp_body_ptr (stmt));
1829 : :
1830 : 1119 : if (info->new_local_var_chain)
1831 : 216 : declare_vars (info->new_local_var_chain,
1832 : : gimple_seq_first_stmt (gimple_omp_body (stmt)),
1833 : : false);
1834 : 1119 : info->new_local_var_chain = save_local_var_chain;
1835 : 1119 : info->suppress_expansion = save_suppress;
1836 : 1119 : break;
1837 : :
1838 : 600 : case GIMPLE_OMP_SECTION:
1839 : 600 : case GIMPLE_OMP_STRUCTURED_BLOCK:
1840 : 600 : case GIMPLE_OMP_MASTER:
1841 : 600 : case GIMPLE_OMP_MASKED:
1842 : 600 : case GIMPLE_OMP_ORDERED:
1843 : 600 : case GIMPLE_OMP_SCAN:
1844 : 600 : walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1845 : : info, gimple_omp_body_ptr (stmt));
1846 : 600 : break;
1847 : :
1848 : 239534 : case GIMPLE_BIND:
1849 : 239534 : {
1850 : 239534 : gbind *bind_stmt = as_a <gbind *> (stmt);
1851 : :
1852 : 1112277 : for (tree var = gimple_bind_vars (bind_stmt); var; var = DECL_CHAIN (var))
1853 : 872743 : if (TREE_CODE (var) == NAMELIST_DECL)
1854 : : {
1855 : : /* Adjust decls mentioned in NAMELIST_DECL. */
1856 : 131 : tree decls = NAMELIST_DECL_ASSOCIATED_DECL (var);
1857 : 131 : tree decl;
1858 : 131 : unsigned int i;
1859 : :
1860 : 873420 : FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls), i, decl)
1861 : : {
1862 : 771 : if (VAR_P (decl)
1863 : 677 : && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1864 : 94 : continue;
1865 : 583 : if (decl_function_context (decl) != info->context)
1866 : 7 : CONSTRUCTOR_ELT (decls, i)->value
1867 : 14 : = get_nonlocal_debug_decl (info, decl);
1868 : : }
1869 : : }
1870 : :
1871 : 239534 : *handled_ops_p = false;
1872 : 239534 : return NULL_TREE;
1873 : : }
1874 : 320750 : case GIMPLE_COND:
1875 : 320750 : wi->val_only = true;
1876 : 320750 : wi->is_lhs = false;
1877 : 320750 : *handled_ops_p = false;
1878 : 320750 : return NULL_TREE;
1879 : :
1880 : 3266906 : case GIMPLE_ASSIGN:
1881 : 3266906 : if (gimple_clobber_p (stmt))
1882 : : {
1883 : 123939 : tree lhs = gimple_assign_lhs (stmt);
1884 : 123939 : if (DECL_P (lhs)
1885 : 123905 : && !(TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
1886 : 247775 : && decl_function_context (lhs) != info->context)
1887 : : {
1888 : 11 : gsi_replace (gsi, gimple_build_nop (), true);
1889 : 11 : break;
1890 : : }
1891 : : }
1892 : 3266895 : *handled_ops_p = false;
1893 : 3266895 : return NULL_TREE;
1894 : :
1895 : 1331307 : default:
1896 : : /* For every other statement that we are not interested in
1897 : : handling here, let the walker traverse the operands. */
1898 : 1331307 : *handled_ops_p = false;
1899 : 1331307 : return NULL_TREE;
1900 : : }
1901 : :
1902 : : /* We have handled all of STMT operands, no need to traverse the operands. */
1903 : 217325 : *handled_ops_p = true;
1904 : 217325 : return NULL_TREE;
1905 : : }
1906 : :
1907 : :
1908 : : /* A subroutine of convert_local_reference. Create a local variable
1909 : : in the parent function with DECL_VALUE_EXPR set to reference the
1910 : : field in FRAME. This is used both for debug info and in OMP
1911 : : lowering. */
1912 : :
1913 : : static tree
1914 : 210 : get_local_debug_decl (struct nesting_info *info, tree decl, tree field)
1915 : : {
1916 : 210 : tree x, new_decl;
1917 : :
1918 : 210 : tree *slot = &info->var_map->get_or_insert (decl);
1919 : 210 : if (*slot)
1920 : : return *slot;
1921 : :
1922 : : /* Make sure frame_decl gets created. */
1923 : 65 : (void) get_frame_type (info);
1924 : 65 : x = info->frame_decl;
1925 : 65 : x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1926 : :
1927 : 65 : new_decl = get_debug_decl (decl);
1928 : 65 : DECL_CONTEXT (new_decl) = info->context;
1929 : :
1930 : 65 : SET_DECL_VALUE_EXPR (new_decl, x);
1931 : 65 : DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
1932 : 65 : *slot = new_decl;
1933 : :
1934 : 65 : DECL_CHAIN (new_decl) = info->debug_var_chain;
1935 : 65 : info->debug_var_chain = new_decl;
1936 : :
1937 : : /* Do not emit debug info twice. */
1938 : 65 : DECL_IGNORED_P (decl) = 1;
1939 : :
1940 : 65 : return new_decl;
1941 : : }
1942 : :
1943 : :
1944 : : /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1945 : : and PARM_DECLs that were referenced by inner nested functions.
1946 : : The rewrite will be a structure reference to the local frame variable. */
1947 : :
1948 : : static bool convert_local_omp_clauses (tree *, struct walk_stmt_info *);
1949 : :
1950 : : static tree
1951 : 14541078 : convert_local_reference_op (tree *tp, int *walk_subtrees, void *data)
1952 : : {
1953 : 14541078 : struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1954 : 14541078 : struct nesting_info *const info = (struct nesting_info *) wi->info;
1955 : 14541078 : tree t = *tp, field, x;
1956 : 14541078 : bool save_val_only;
1957 : :
1958 : 14541078 : *walk_subtrees = 0;
1959 : 14541078 : switch (TREE_CODE (t))
1960 : : {
1961 : 3866977 : case VAR_DECL:
1962 : : /* Non-automatic variables are never processed. */
1963 : 3866977 : if (TREE_STATIC (t) || DECL_EXTERNAL (t))
1964 : : break;
1965 : : /* FALLTHRU */
1966 : :
1967 : 3876017 : case PARM_DECL:
1968 : 3876017 : if (t != info->frame_decl && decl_function_context (t) == info->context)
1969 : : {
1970 : : /* If we copied a pointer to the frame, then the original decl
1971 : : is used unchanged in the parent function. */
1972 : 3873376 : if (use_pointer_in_frame (t))
1973 : : break;
1974 : :
1975 : : /* No need to transform anything if no child references the
1976 : : variable. */
1977 : 3873262 : field = lookup_field_for_decl (info, t, NO_INSERT);
1978 : 3873262 : if (!field)
1979 : : break;
1980 : 20842 : wi->changed = true;
1981 : :
1982 : 20842 : if (bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
1983 : 123 : x = get_local_debug_decl (info, t, field);
1984 : : else
1985 : 20719 : x = get_frame_field (info, info->context, field, &wi->gsi);
1986 : :
1987 : 20842 : if (wi->val_only)
1988 : : {
1989 : 8097 : if (wi->is_lhs)
1990 : 2663 : x = save_tmp_var (info, x, &wi->gsi);
1991 : : else
1992 : 5434 : x = init_tmp_var (info, x, &wi->gsi);
1993 : : }
1994 : :
1995 : 20842 : *tp = x;
1996 : : }
1997 : : break;
1998 : :
1999 : 644725 : case ADDR_EXPR:
2000 : 644725 : save_val_only = wi->val_only;
2001 : 644725 : wi->val_only = false;
2002 : 644725 : wi->is_lhs = false;
2003 : 644725 : wi->changed = false;
2004 : 644725 : walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op, wi, NULL);
2005 : 644725 : wi->val_only = save_val_only;
2006 : :
2007 : : /* If we converted anything ... */
2008 : 644725 : if (wi->changed)
2009 : : {
2010 : 3530 : tree save_context;
2011 : :
2012 : : /* Then the frame decl is now addressable. */
2013 : 3530 : TREE_ADDRESSABLE (info->frame_decl) = 1;
2014 : :
2015 : 3530 : save_context = current_function_decl;
2016 : 3530 : current_function_decl = info->context;
2017 : 3530 : recompute_tree_invariant_for_addr_expr (t);
2018 : :
2019 : : /* If we are in a context where we only accept values, then
2020 : : compute the address into a temporary. */
2021 : 3530 : if (save_val_only)
2022 : 2933 : *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
2023 : : t, &wi->gsi);
2024 : 3530 : current_function_decl = save_context;
2025 : : }
2026 : : break;
2027 : :
2028 : 1734612 : case REALPART_EXPR:
2029 : 1734612 : case IMAGPART_EXPR:
2030 : 1734612 : case COMPONENT_REF:
2031 : 1734612 : case ARRAY_REF:
2032 : 1734612 : case ARRAY_RANGE_REF:
2033 : 1734612 : case BIT_FIELD_REF:
2034 : : /* Go down this entire nest and just look at the final prefix and
2035 : : anything that describes the references. Otherwise, we lose track
2036 : : of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value. */
2037 : 1734612 : save_val_only = wi->val_only;
2038 : 1734612 : wi->val_only = true;
2039 : 1734612 : wi->is_lhs = false;
2040 : 5069243 : for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
2041 : : {
2042 : 3334631 : if (TREE_CODE (t) == COMPONENT_REF)
2043 : 2507431 : walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
2044 : : NULL);
2045 : 827200 : else if (TREE_CODE (t) == ARRAY_REF
2046 : 827200 : || TREE_CODE (t) == ARRAY_RANGE_REF)
2047 : : {
2048 : 826552 : walk_tree (&TREE_OPERAND (t, 1), convert_local_reference_op, wi,
2049 : : NULL);
2050 : 826552 : walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
2051 : : NULL);
2052 : 826552 : walk_tree (&TREE_OPERAND (t, 3), convert_local_reference_op, wi,
2053 : : NULL);
2054 : : }
2055 : : }
2056 : 1734612 : wi->val_only = false;
2057 : 1734612 : walk_tree (tp, convert_local_reference_op, wi, NULL);
2058 : 1734612 : wi->val_only = save_val_only;
2059 : 1734612 : break;
2060 : :
2061 : 331203 : case MEM_REF:
2062 : 331203 : save_val_only = wi->val_only;
2063 : 331203 : wi->val_only = true;
2064 : 331203 : wi->is_lhs = false;
2065 : 331203 : walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op,
2066 : : wi, NULL);
2067 : : /* We need to re-fold the MEM_REF as component references as
2068 : : part of a ADDR_EXPR address are not allowed. But we cannot
2069 : : fold here, as the chain record type is not yet finalized. */
2070 : 331203 : if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
2071 : 331203 : && !DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
2072 : 0 : info->mem_refs->add (tp);
2073 : 331203 : wi->val_only = save_val_only;
2074 : 331203 : break;
2075 : :
2076 : 851 : case VIEW_CONVERT_EXPR:
2077 : : /* Just request to look at the subtrees, leaving val_only and lhs
2078 : : untouched. This might actually be for !val_only + lhs, in which
2079 : : case we don't want to force a replacement by a temporary. */
2080 : 851 : *walk_subtrees = 1;
2081 : 851 : break;
2082 : :
2083 : 7799943 : default:
2084 : 7799943 : if (!IS_TYPE_OR_DECL_P (t))
2085 : : {
2086 : 5679110 : *walk_subtrees = 1;
2087 : 5679110 : wi->val_only = true;
2088 : 5679110 : wi->is_lhs = false;
2089 : : }
2090 : : break;
2091 : : }
2092 : :
2093 : 14541078 : return NULL_TREE;
2094 : : }
2095 : :
2096 : : static tree convert_local_reference_stmt (gimple_stmt_iterator *, bool *,
2097 : : struct walk_stmt_info *);
2098 : :
2099 : : /* Helper for convert_local_reference. Convert all the references in
2100 : : the chain of clauses at *PCLAUSES. WI is as in convert_local_reference. */
2101 : :
2102 : : static bool
2103 : 4885 : convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
2104 : : {
2105 : 4885 : struct nesting_info *const info = (struct nesting_info *) wi->info;
2106 : 4885 : bool need_frame = false, need_stmts = false;
2107 : 4885 : tree clause, decl, *pdecl;
2108 : 4885 : int dummy;
2109 : 4885 : bitmap new_suppress;
2110 : :
2111 : 4885 : new_suppress = BITMAP_GGC_ALLOC ();
2112 : 4885 : bitmap_copy (new_suppress, info->suppress_expansion);
2113 : :
2114 : 29263 : for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
2115 : : {
2116 : 24378 : pdecl = NULL;
2117 : 24378 : switch (OMP_CLAUSE_CODE (clause))
2118 : : {
2119 : 663 : case OMP_CLAUSE_REDUCTION:
2120 : 663 : case OMP_CLAUSE_IN_REDUCTION:
2121 : 663 : case OMP_CLAUSE_TASK_REDUCTION:
2122 : 663 : if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
2123 : 37 : need_stmts = true;
2124 : 663 : if (TREE_CODE (OMP_CLAUSE_DECL (clause)) == MEM_REF)
2125 : : {
2126 : 6 : pdecl = &TREE_OPERAND (OMP_CLAUSE_DECL (clause), 0);
2127 : 6 : if (TREE_CODE (*pdecl) == POINTER_PLUS_EXPR)
2128 : 0 : pdecl = &TREE_OPERAND (*pdecl, 0);
2129 : 6 : if (INDIRECT_REF_P (*pdecl)
2130 : 6 : || TREE_CODE (*pdecl) == ADDR_EXPR)
2131 : 4 : pdecl = &TREE_OPERAND (*pdecl, 0);
2132 : : }
2133 : 663 : goto do_decl_clause;
2134 : :
2135 : 1152 : case OMP_CLAUSE_LASTPRIVATE:
2136 : 1152 : if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
2137 : 250 : need_stmts = true;
2138 : 1152 : goto do_decl_clause;
2139 : :
2140 : 391 : case OMP_CLAUSE_LINEAR:
2141 : 391 : if (OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause))
2142 : 74 : need_stmts = true;
2143 : 391 : wi->val_only = true;
2144 : 391 : wi->is_lhs = false;
2145 : 391 : convert_local_reference_op (&OMP_CLAUSE_LINEAR_STEP (clause), &dummy,
2146 : : wi);
2147 : 391 : goto do_decl_clause;
2148 : :
2149 : 5692 : case OMP_CLAUSE_PRIVATE:
2150 : 5692 : case OMP_CLAUSE_FIRSTPRIVATE:
2151 : 5692 : case OMP_CLAUSE_COPYPRIVATE:
2152 : 5692 : case OMP_CLAUSE_SHARED:
2153 : 5692 : case OMP_CLAUSE_ENTER:
2154 : 5692 : case OMP_CLAUSE_LINK:
2155 : 5692 : case OMP_CLAUSE_USE_DEVICE_PTR:
2156 : 5692 : case OMP_CLAUSE_USE_DEVICE_ADDR:
2157 : 5692 : case OMP_CLAUSE_HAS_DEVICE_ADDR:
2158 : 5692 : case OMP_CLAUSE_IS_DEVICE_PTR:
2159 : 5692 : case OMP_CLAUSE_DETACH:
2160 : 5692 : do_decl_clause:
2161 : 2206 : if (pdecl == NULL)
2162 : 16819 : pdecl = &OMP_CLAUSE_DECL (clause);
2163 : 16825 : decl = *pdecl;
2164 : 16825 : if (VAR_P (decl)
2165 : 16825 : && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
2166 : : break;
2167 : 16379 : if (decl_function_context (decl) == info->context
2168 : 16379 : && !use_pointer_in_frame (decl))
2169 : : {
2170 : 16253 : tree field = lookup_field_for_decl (info, decl, NO_INSERT);
2171 : 16253 : if (field)
2172 : : {
2173 : 85 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_SHARED)
2174 : 37 : OMP_CLAUSE_SHARED_READONLY (clause) = 0;
2175 : 85 : bitmap_set_bit (new_suppress, DECL_UID (decl));
2176 : 85 : *pdecl = get_local_debug_decl (info, decl, field);
2177 : 85 : need_frame = true;
2178 : : }
2179 : : }
2180 : : break;
2181 : :
2182 : 165 : case OMP_CLAUSE_SCHEDULE:
2183 : 165 : if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
2184 : : break;
2185 : : /* FALLTHRU */
2186 : 2506 : case OMP_CLAUSE_FINAL:
2187 : 2506 : case OMP_CLAUSE_IF:
2188 : 2506 : case OMP_CLAUSE_SELF:
2189 : 2506 : case OMP_CLAUSE_NUM_THREADS:
2190 : 2506 : case OMP_CLAUSE_DEPEND:
2191 : 2506 : case OMP_CLAUSE_DOACROSS:
2192 : 2506 : case OMP_CLAUSE_DEVICE:
2193 : 2506 : case OMP_CLAUSE_NUM_TEAMS:
2194 : 2506 : case OMP_CLAUSE_THREAD_LIMIT:
2195 : 2506 : case OMP_CLAUSE_SAFELEN:
2196 : 2506 : case OMP_CLAUSE_SIMDLEN:
2197 : 2506 : case OMP_CLAUSE_PRIORITY:
2198 : 2506 : case OMP_CLAUSE_GRAINSIZE:
2199 : 2506 : case OMP_CLAUSE_NUM_TASKS:
2200 : 2506 : case OMP_CLAUSE_HINT:
2201 : 2506 : case OMP_CLAUSE_FILTER:
2202 : 2506 : case OMP_CLAUSE_NUM_GANGS:
2203 : 2506 : case OMP_CLAUSE_NUM_WORKERS:
2204 : 2506 : case OMP_CLAUSE_VECTOR_LENGTH:
2205 : 2506 : case OMP_CLAUSE_GANG:
2206 : 2506 : case OMP_CLAUSE_WORKER:
2207 : 2506 : case OMP_CLAUSE_VECTOR:
2208 : 2506 : case OMP_CLAUSE_ASYNC:
2209 : 2506 : case OMP_CLAUSE_WAIT:
2210 : : /* Several OpenACC clauses have optional arguments. Check if they
2211 : : are present. */
2212 : 2506 : if (OMP_CLAUSE_OPERAND (clause, 0))
2213 : : {
2214 : 2250 : wi->val_only = true;
2215 : 2250 : wi->is_lhs = false;
2216 : 2250 : convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
2217 : : &dummy, wi);
2218 : : }
2219 : :
2220 : : /* The gang clause accepts two arguments. */
2221 : 2506 : if (OMP_CLAUSE_CODE (clause) == OMP_CLAUSE_GANG
2222 : 2506 : && OMP_CLAUSE_GANG_STATIC_EXPR (clause))
2223 : : {
2224 : 28 : wi->val_only = true;
2225 : 28 : wi->is_lhs = false;
2226 : 28 : convert_nonlocal_reference_op
2227 : 28 : (&OMP_CLAUSE_GANG_STATIC_EXPR (clause), &dummy, wi);
2228 : : }
2229 : : break;
2230 : :
2231 : 7 : case OMP_CLAUSE_DIST_SCHEDULE:
2232 : 7 : if (OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (clause) != NULL)
2233 : : {
2234 : 7 : wi->val_only = true;
2235 : 7 : wi->is_lhs = false;
2236 : 7 : convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
2237 : : &dummy, wi);
2238 : : }
2239 : : break;
2240 : :
2241 : 7350 : case OMP_CLAUSE_MAP:
2242 : 7350 : case OMP_CLAUSE_TO:
2243 : 7350 : case OMP_CLAUSE_FROM:
2244 : 7350 : if (OMP_CLAUSE_SIZE (clause))
2245 : : {
2246 : 7350 : wi->val_only = true;
2247 : 7350 : wi->is_lhs = false;
2248 : 7350 : convert_local_reference_op (&OMP_CLAUSE_SIZE (clause),
2249 : : &dummy, wi);
2250 : : }
2251 : 7350 : if (DECL_P (OMP_CLAUSE_DECL (clause)))
2252 : 3486 : goto do_decl_clause;
2253 : 3864 : wi->val_only = true;
2254 : 3864 : wi->is_lhs = false;
2255 : 3864 : walk_tree (&OMP_CLAUSE_DECL (clause), convert_local_reference_op,
2256 : : wi, NULL);
2257 : 3864 : break;
2258 : :
2259 : 6 : case OMP_CLAUSE_ALIGNED:
2260 : 6 : if (OMP_CLAUSE_ALIGNED_ALIGNMENT (clause))
2261 : : {
2262 : 6 : wi->val_only = true;
2263 : 6 : wi->is_lhs = false;
2264 : 6 : convert_local_reference_op
2265 : 6 : (&OMP_CLAUSE_ALIGNED_ALIGNMENT (clause), &dummy, wi);
2266 : : }
2267 : : /* FALLTHRU */
2268 : 6 : case OMP_CLAUSE_NONTEMPORAL:
2269 : 0 : do_decl_clause_no_supp:
2270 : : /* Like do_decl_clause, but don't add any suppression. */
2271 : 6 : decl = OMP_CLAUSE_DECL (clause);
2272 : 6 : if (VAR_P (decl)
2273 : 6 : && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
2274 : : break;
2275 : 6 : if (decl_function_context (decl) == info->context
2276 : 6 : && !use_pointer_in_frame (decl))
2277 : : {
2278 : 6 : tree field = lookup_field_for_decl (info, decl, NO_INSERT);
2279 : 6 : if (field)
2280 : : {
2281 : 0 : OMP_CLAUSE_DECL (clause)
2282 : 0 : = get_local_debug_decl (info, decl, field);
2283 : 0 : need_frame = true;
2284 : : }
2285 : : }
2286 : : break;
2287 : :
2288 : 0 : case OMP_CLAUSE_ALLOCATE:
2289 : 0 : if (OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause))
2290 : : {
2291 : 0 : wi->val_only = true;
2292 : 0 : wi->is_lhs = false;
2293 : 0 : convert_local_reference_op
2294 : 0 : (&OMP_CLAUSE_ALLOCATE_ALLOCATOR (clause), &dummy, wi);
2295 : : }
2296 : 0 : goto do_decl_clause_no_supp;
2297 : :
2298 : : case OMP_CLAUSE_NOWAIT:
2299 : : case OMP_CLAUSE_ORDERED:
2300 : : case OMP_CLAUSE_DEFAULT:
2301 : : case OMP_CLAUSE_COPYIN:
2302 : : case OMP_CLAUSE_COLLAPSE:
2303 : : case OMP_CLAUSE_TILE:
2304 : : case OMP_CLAUSE_UNTIED:
2305 : : case OMP_CLAUSE_MERGEABLE:
2306 : : case OMP_CLAUSE_PROC_BIND:
2307 : : case OMP_CLAUSE_NOGROUP:
2308 : : case OMP_CLAUSE_THREADS:
2309 : : case OMP_CLAUSE_SIMD:
2310 : : case OMP_CLAUSE_DEFAULTMAP:
2311 : : case OMP_CLAUSE_ORDER:
2312 : : case OMP_CLAUSE_SEQ:
2313 : : case OMP_CLAUSE_INDEPENDENT:
2314 : : case OMP_CLAUSE_AUTO:
2315 : : case OMP_CLAUSE_IF_PRESENT:
2316 : : case OMP_CLAUSE_FINALIZE:
2317 : : case OMP_CLAUSE_BIND:
2318 : : case OMP_CLAUSE__CONDTEMP_:
2319 : : case OMP_CLAUSE__SCANTEMP_:
2320 : : break;
2321 : :
2322 : : /* The following clause belongs to the OpenACC cache directive, which
2323 : : is discarded during gimplification. */
2324 : 0 : case OMP_CLAUSE__CACHE_:
2325 : : /* The following clauses are only allowed in the OpenMP declare simd
2326 : : directive, so not seen here. */
2327 : 0 : case OMP_CLAUSE_UNIFORM:
2328 : 0 : case OMP_CLAUSE_INBRANCH:
2329 : 0 : case OMP_CLAUSE_NOTINBRANCH:
2330 : : /* The following clauses are only allowed on OpenMP cancel and
2331 : : cancellation point directives, which at this point have already
2332 : : been lowered into a function call. */
2333 : 0 : case OMP_CLAUSE_FOR:
2334 : 0 : case OMP_CLAUSE_PARALLEL:
2335 : 0 : case OMP_CLAUSE_SECTIONS:
2336 : 0 : case OMP_CLAUSE_TASKGROUP:
2337 : : /* The following clauses are only added during OMP lowering; nested
2338 : : function decomposition happens before that. */
2339 : 0 : case OMP_CLAUSE__LOOPTEMP_:
2340 : 0 : case OMP_CLAUSE__REDUCTEMP_:
2341 : 0 : case OMP_CLAUSE__SIMDUID_:
2342 : 0 : case OMP_CLAUSE__SIMT_:
2343 : : /* The following clauses are only allowed on OpenACC 'routine'
2344 : : directives, not seen here. */
2345 : 0 : case OMP_CLAUSE_NOHOST:
2346 : : /* Anything else. */
2347 : 0 : default:
2348 : 0 : gcc_unreachable ();
2349 : : }
2350 : : }
2351 : :
2352 : 4885 : info->suppress_expansion = new_suppress;
2353 : :
2354 : 4885 : if (need_stmts)
2355 : 1547 : for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
2356 : 1262 : switch (OMP_CLAUSE_CODE (clause))
2357 : : {
2358 : 103 : case OMP_CLAUSE_REDUCTION:
2359 : 103 : case OMP_CLAUSE_IN_REDUCTION:
2360 : 103 : case OMP_CLAUSE_TASK_REDUCTION:
2361 : 103 : if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
2362 : : {
2363 : 37 : tree old_context
2364 : 37 : = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
2365 : 37 : DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
2366 : 37 : = info->context;
2367 : 37 : if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
2368 : 0 : DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
2369 : 0 : = info->context;
2370 : 37 : walk_body (convert_local_reference_stmt,
2371 : : convert_local_reference_op, info,
2372 : 37 : &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
2373 : 37 : walk_body (convert_local_reference_stmt,
2374 : : convert_local_reference_op, info,
2375 : 37 : &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
2376 : 37 : DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
2377 : 37 : = old_context;
2378 : 37 : if (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
2379 : 0 : DECL_CONTEXT (OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER (clause))
2380 : 0 : = old_context;
2381 : : }
2382 : : break;
2383 : :
2384 : 410 : case OMP_CLAUSE_LASTPRIVATE:
2385 : 410 : walk_body (convert_local_reference_stmt,
2386 : : convert_local_reference_op, info,
2387 : 410 : &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
2388 : 410 : break;
2389 : :
2390 : 215 : case OMP_CLAUSE_LINEAR:
2391 : 215 : walk_body (convert_local_reference_stmt,
2392 : : convert_local_reference_op, info,
2393 : 215 : &OMP_CLAUSE_LINEAR_GIMPLE_SEQ (clause));
2394 : 215 : break;
2395 : :
2396 : : default:
2397 : : break;
2398 : : }
2399 : :
2400 : 4885 : return need_frame;
2401 : : }
2402 : :
2403 : :
2404 : : /* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
2405 : : and PARM_DECLs that were referenced by inner nested functions.
2406 : : The rewrite will be a structure reference to the local frame variable. */
2407 : :
2408 : : static tree
2409 : 5384518 : convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2410 : : struct walk_stmt_info *wi)
2411 : : {
2412 : 5384518 : struct nesting_info *info = (struct nesting_info *) wi->info;
2413 : 5384518 : tree save_local_var_chain;
2414 : 5384518 : bitmap save_suppress;
2415 : 5384518 : char save_static_chain_added;
2416 : 5384518 : bool frame_decl_added;
2417 : 5384518 : gimple *stmt = gsi_stmt (*gsi);
2418 : :
2419 : 5384518 : switch (gimple_code (stmt))
2420 : : {
2421 : 38 : case GIMPLE_OMP_TEAMS:
2422 : 38 : if (!gimple_omp_teams_host (as_a <gomp_teams *> (stmt)))
2423 : : {
2424 : 26 : save_suppress = info->suppress_expansion;
2425 : 26 : convert_local_omp_clauses (gimple_omp_teams_clauses_ptr (stmt), wi);
2426 : 26 : walk_body (convert_local_reference_stmt, convert_local_reference_op,
2427 : : info, gimple_omp_body_ptr (stmt));
2428 : 26 : info->suppress_expansion = save_suppress;
2429 : 26 : break;
2430 : : }
2431 : : /* FALLTHRU */
2432 : :
2433 : 1321 : case GIMPLE_OMP_PARALLEL:
2434 : 1321 : case GIMPLE_OMP_TASK:
2435 : 1321 : save_suppress = info->suppress_expansion;
2436 : 1321 : frame_decl_added = false;
2437 : 1321 : if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
2438 : : wi))
2439 : : {
2440 : 40 : tree c = build_omp_clause (gimple_location (stmt),
2441 : : OMP_CLAUSE_SHARED);
2442 : 40 : (void) get_frame_type (info);
2443 : 40 : OMP_CLAUSE_DECL (c) = info->frame_decl;
2444 : 40 : OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
2445 : 40 : gimple_omp_taskreg_set_clauses (stmt, c);
2446 : 40 : info->static_chain_added |= 4;
2447 : 40 : frame_decl_added = true;
2448 : : }
2449 : :
2450 : 1321 : save_local_var_chain = info->new_local_var_chain;
2451 : 1321 : save_static_chain_added = info->static_chain_added;
2452 : 1321 : info->new_local_var_chain = NULL;
2453 : 1321 : info->static_chain_added = 0;
2454 : :
2455 : 1321 : walk_body (convert_local_reference_stmt, convert_local_reference_op, info,
2456 : : gimple_omp_body_ptr (stmt));
2457 : :
2458 : 1321 : if ((info->static_chain_added & 4) != 0 && !frame_decl_added)
2459 : : {
2460 : 1 : tree c = build_omp_clause (gimple_location (stmt),
2461 : : OMP_CLAUSE_SHARED);
2462 : 1 : (void) get_frame_type (info);
2463 : 1 : OMP_CLAUSE_DECL (c) = info->frame_decl;
2464 : 1 : OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
2465 : 1 : info->static_chain_added |= 4;
2466 : 1 : gimple_omp_taskreg_set_clauses (stmt, c);
2467 : : }
2468 : 1321 : if (info->new_local_var_chain)
2469 : 19 : declare_vars (info->new_local_var_chain,
2470 : : gimple_seq_first_stmt (gimple_omp_body (stmt)), false);
2471 : 1321 : info->new_local_var_chain = save_local_var_chain;
2472 : 1321 : info->suppress_expansion = save_suppress;
2473 : 1321 : info->static_chain_added |= save_static_chain_added;
2474 : 1321 : break;
2475 : :
2476 : 1506 : case GIMPLE_OMP_FOR:
2477 : 1506 : save_suppress = info->suppress_expansion;
2478 : 1506 : convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
2479 : 1506 : walk_gimple_omp_for (as_a <gomp_for *> (stmt),
2480 : : convert_local_reference_stmt,
2481 : : convert_local_reference_op, info);
2482 : 1506 : walk_body (convert_local_reference_stmt, convert_local_reference_op,
2483 : : info, gimple_omp_body_ptr (stmt));
2484 : 1506 : info->suppress_expansion = save_suppress;
2485 : 1506 : break;
2486 : :
2487 : 42 : case GIMPLE_OMP_SECTIONS:
2488 : 42 : save_suppress = info->suppress_expansion;
2489 : 42 : convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
2490 : 42 : walk_body (convert_local_reference_stmt, convert_local_reference_op,
2491 : : info, gimple_omp_body_ptr (stmt));
2492 : 42 : info->suppress_expansion = save_suppress;
2493 : 42 : break;
2494 : :
2495 : 185 : case GIMPLE_OMP_SINGLE:
2496 : 185 : save_suppress = info->suppress_expansion;
2497 : 185 : convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
2498 : 185 : walk_body (convert_local_reference_stmt, convert_local_reference_op,
2499 : : info, gimple_omp_body_ptr (stmt));
2500 : 185 : info->suppress_expansion = save_suppress;
2501 : 185 : break;
2502 : :
2503 : 0 : case GIMPLE_OMP_SCOPE:
2504 : 0 : save_suppress = info->suppress_expansion;
2505 : 0 : convert_local_omp_clauses (gimple_omp_scope_clauses_ptr (stmt), wi);
2506 : 0 : walk_body (convert_local_reference_stmt, convert_local_reference_op,
2507 : : info, gimple_omp_body_ptr (stmt));
2508 : 0 : info->suppress_expansion = save_suppress;
2509 : 0 : break;
2510 : :
2511 : 38 : case GIMPLE_OMP_TASKGROUP:
2512 : 38 : save_suppress = info->suppress_expansion;
2513 : 38 : convert_local_omp_clauses (gimple_omp_taskgroup_clauses_ptr (stmt), wi);
2514 : 38 : walk_body (convert_local_reference_stmt, convert_local_reference_op,
2515 : : info, gimple_omp_body_ptr (stmt));
2516 : 38 : info->suppress_expansion = save_suppress;
2517 : 38 : break;
2518 : :
2519 : 1767 : case GIMPLE_OMP_TARGET:
2520 : 1767 : if (!is_gimple_omp_offloaded (stmt))
2521 : : {
2522 : 648 : save_suppress = info->suppress_expansion;
2523 : 648 : convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt), wi);
2524 : 648 : info->suppress_expansion = save_suppress;
2525 : 648 : walk_body (convert_local_reference_stmt, convert_local_reference_op,
2526 : : info, gimple_omp_body_ptr (stmt));
2527 : 648 : break;
2528 : : }
2529 : 1119 : save_suppress = info->suppress_expansion;
2530 : 1119 : frame_decl_added = false;
2531 : 1119 : if (convert_local_omp_clauses (gimple_omp_target_clauses_ptr (stmt), wi))
2532 : : {
2533 : 0 : tree c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP);
2534 : 0 : (void) get_frame_type (info);
2535 : 0 : OMP_CLAUSE_DECL (c) = info->frame_decl;
2536 : 0 : OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM);
2537 : 0 : OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (info->frame_decl);
2538 : 0 : OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
2539 : 0 : gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt), c);
2540 : 0 : info->static_chain_added |= 4;
2541 : 0 : frame_decl_added = true;
2542 : : }
2543 : :
2544 : 1119 : save_local_var_chain = info->new_local_var_chain;
2545 : 1119 : save_static_chain_added = info->static_chain_added;
2546 : 1119 : info->new_local_var_chain = NULL;
2547 : 1119 : info->static_chain_added = 0;
2548 : :
2549 : 1119 : walk_body (convert_local_reference_stmt, convert_local_reference_op, info,
2550 : : gimple_omp_body_ptr (stmt));
2551 : :
2552 : 1119 : if ((info->static_chain_added & 4) != 0 && !frame_decl_added)
2553 : : {
2554 : 0 : tree c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP);
2555 : 0 : (void) get_frame_type (info);
2556 : 0 : OMP_CLAUSE_DECL (c) = info->frame_decl;
2557 : 0 : OMP_CLAUSE_SET_MAP_KIND (c, GOMP_MAP_TOFROM);
2558 : 0 : OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (info->frame_decl);
2559 : 0 : OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
2560 : 0 : gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt), c);
2561 : 0 : info->static_chain_added |= 4;
2562 : : }
2563 : :
2564 : 1119 : if (info->new_local_var_chain)
2565 : 1 : declare_vars (info->new_local_var_chain,
2566 : : gimple_seq_first_stmt (gimple_omp_body (stmt)), false);
2567 : 1119 : info->new_local_var_chain = save_local_var_chain;
2568 : 1119 : info->suppress_expansion = save_suppress;
2569 : 1119 : info->static_chain_added |= save_static_chain_added;
2570 : 1119 : break;
2571 : :
2572 : 600 : case GIMPLE_OMP_SECTION:
2573 : 600 : case GIMPLE_OMP_STRUCTURED_BLOCK:
2574 : 600 : case GIMPLE_OMP_MASTER:
2575 : 600 : case GIMPLE_OMP_MASKED:
2576 : 600 : case GIMPLE_OMP_ORDERED:
2577 : 600 : case GIMPLE_OMP_SCAN:
2578 : 600 : walk_body (convert_local_reference_stmt, convert_local_reference_op,
2579 : : info, gimple_omp_body_ptr (stmt));
2580 : 600 : break;
2581 : :
2582 : 320750 : case GIMPLE_COND:
2583 : 320750 : wi->val_only = true;
2584 : 320750 : wi->is_lhs = false;
2585 : 320750 : *handled_ops_p = false;
2586 : 320750 : return NULL_TREE;
2587 : :
2588 : 3275525 : case GIMPLE_ASSIGN:
2589 : 3275525 : if (gimple_clobber_p (stmt))
2590 : : {
2591 : 123928 : tree lhs = gimple_assign_lhs (stmt);
2592 : 123928 : if (DECL_P (lhs)
2593 : 123894 : && decl_function_context (lhs) == info->context
2594 : 123892 : && !use_pointer_in_frame (lhs)
2595 : 247820 : && lookup_field_for_decl (info, lhs, NO_INSERT))
2596 : : {
2597 : 1578 : gsi_replace (gsi, gimple_build_nop (), true);
2598 : 1578 : break;
2599 : : }
2600 : : }
2601 : 3273947 : *handled_ops_p = false;
2602 : 3273947 : return NULL_TREE;
2603 : :
2604 : 239536 : case GIMPLE_BIND:
2605 : 239536 : for (tree var = gimple_bind_vars (as_a <gbind *> (stmt));
2606 : 1113525 : var;
2607 : 873989 : var = DECL_CHAIN (var))
2608 : 873989 : if (TREE_CODE (var) == NAMELIST_DECL)
2609 : : {
2610 : : /* Adjust decls mentioned in NAMELIST_DECL. */
2611 : 131 : tree decls = NAMELIST_DECL_ASSOCIATED_DECL (var);
2612 : 131 : tree decl;
2613 : 131 : unsigned int i;
2614 : :
2615 : 874666 : FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (decls), i, decl)
2616 : : {
2617 : 771 : if (VAR_P (decl)
2618 : 677 : && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
2619 : 94 : continue;
2620 : 583 : if (decl_function_context (decl) == info->context
2621 : 583 : && !use_pointer_in_frame (decl))
2622 : : {
2623 : 583 : tree field = lookup_field_for_decl (info, decl, NO_INSERT);
2624 : 583 : if (field)
2625 : : {
2626 : 2 : CONSTRUCTOR_ELT (decls, i)->value
2627 : 4 : = get_local_debug_decl (info, decl, field);
2628 : : }
2629 : : }
2630 : : }
2631 : : }
2632 : :
2633 : 239536 : *handled_ops_p = false;
2634 : 239536 : return NULL_TREE;
2635 : :
2636 : 1543222 : default:
2637 : : /* For every other statement that we are not interested in
2638 : : handling here, let the walker traverse the operands. */
2639 : 1543222 : *handled_ops_p = false;
2640 : 1543222 : return NULL_TREE;
2641 : : }
2642 : :
2643 : : /* Indicate that we have handled all the operands ourselves. */
2644 : 7063 : *handled_ops_p = true;
2645 : 7063 : return NULL_TREE;
2646 : : }
2647 : :
2648 : :
2649 : : /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_GOTOs
2650 : : that reference labels from outer functions. The rewrite will be a
2651 : : call to __builtin_nonlocal_goto. */
2652 : :
2653 : : static tree
2654 : 5387177 : convert_nl_goto_reference (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2655 : : struct walk_stmt_info *wi)
2656 : : {
2657 : 5387177 : struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
2658 : 5387177 : tree label, new_label, target_context, x, field;
2659 : 5387177 : gcall *call;
2660 : 5387177 : gimple *stmt = gsi_stmt (*gsi);
2661 : :
2662 : 5387177 : if (gimple_code (stmt) != GIMPLE_GOTO)
2663 : : {
2664 : 5175371 : *handled_ops_p = false;
2665 : 5175371 : return NULL_TREE;
2666 : : }
2667 : :
2668 : 211806 : label = gimple_goto_dest (stmt);
2669 : 211806 : if (TREE_CODE (label) != LABEL_DECL)
2670 : : {
2671 : 75 : *handled_ops_p = false;
2672 : 75 : return NULL_TREE;
2673 : : }
2674 : :
2675 : 211731 : target_context = decl_function_context (label);
2676 : 211731 : if (target_context == info->context)
2677 : : {
2678 : 211212 : *handled_ops_p = false;
2679 : 211212 : return NULL_TREE;
2680 : : }
2681 : :
2682 : 519 : for (i = info->outer; target_context != i->context; i = i->outer)
2683 : 0 : continue;
2684 : :
2685 : : /* The original user label may also be use for a normal goto, therefore
2686 : : we must create a new label that will actually receive the abnormal
2687 : : control transfer. This new label will be marked LABEL_NONLOCAL; this
2688 : : mark will trigger proper behavior in the cfg, as well as cause the
2689 : : (hairy target-specific) non-local goto receiver code to be generated
2690 : : when we expand rtl. Enter this association into var_map so that we
2691 : : can insert the new label into the IL during a second pass. */
2692 : 519 : tree *slot = &i->var_map->get_or_insert (label);
2693 : 519 : if (*slot == NULL)
2694 : : {
2695 : 476 : new_label = create_artificial_label (UNKNOWN_LOCATION);
2696 : 476 : DECL_NONLOCAL (new_label) = 1;
2697 : 476 : *slot = new_label;
2698 : : }
2699 : : else
2700 : : new_label = *slot;
2701 : :
2702 : : /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field). */
2703 : 519 : field = get_nl_goto_field (i);
2704 : 519 : x = get_frame_field (info, target_context, field, gsi);
2705 : 519 : x = build_addr (x);
2706 : 519 : x = gsi_gimplify_val (info, x, gsi);
2707 : 1038 : call = gimple_build_call (builtin_decl_implicit (BUILT_IN_NONLOCAL_GOTO),
2708 : : 2, build_addr (new_label), x);
2709 : 519 : gsi_replace (gsi, call, false);
2710 : :
2711 : : /* We have handled all of STMT's operands, no need to keep going. */
2712 : 519 : *handled_ops_p = true;
2713 : 519 : return NULL_TREE;
2714 : 0 : }
2715 : :
2716 : :
2717 : : /* Called via walk_function+walk_tree, rewrite all GIMPLE_LABELs whose labels
2718 : : are referenced via nonlocal goto from a nested function. The rewrite
2719 : : will involve installing a newly generated DECL_NONLOCAL label, and
2720 : : (potentially) a branch around the rtl gunk that is assumed to be
2721 : : attached to such a label. */
2722 : :
2723 : : static tree
2724 : 5387696 : convert_nl_goto_receiver (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2725 : : struct walk_stmt_info *wi)
2726 : : {
2727 : 5387696 : struct nesting_info *const info = (struct nesting_info *) wi->info;
2728 : 5387696 : tree label, new_label;
2729 : 5387696 : gimple_stmt_iterator tmp_gsi;
2730 : 5387696 : glabel *stmt = dyn_cast <glabel *> (gsi_stmt (*gsi));
2731 : :
2732 : 5387696 : if (!stmt)
2733 : : {
2734 : 4461188 : *handled_ops_p = false;
2735 : 4461188 : return NULL_TREE;
2736 : : }
2737 : :
2738 : 926508 : label = gimple_label_label (stmt);
2739 : :
2740 : 926508 : tree *slot = info->var_map->get (label);
2741 : 926508 : if (!slot)
2742 : : {
2743 : 926032 : *handled_ops_p = false;
2744 : 926032 : return NULL_TREE;
2745 : : }
2746 : :
2747 : : /* If there's any possibility that the previous statement falls through,
2748 : : then we must branch around the new non-local label. */
2749 : 476 : tmp_gsi = wi->gsi;
2750 : 476 : gsi_prev (&tmp_gsi);
2751 : 476 : if (gsi_end_p (tmp_gsi) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi)))
2752 : : {
2753 : 265 : gimple *stmt = gimple_build_goto (label);
2754 : 265 : gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
2755 : : }
2756 : :
2757 : 476 : new_label = (tree) *slot;
2758 : 476 : stmt = gimple_build_label (new_label);
2759 : 476 : gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
2760 : :
2761 : 476 : *handled_ops_p = true;
2762 : 476 : return NULL_TREE;
2763 : : }
2764 : :
2765 : :
2766 : : /* Called via walk_function+walk_stmt, rewrite all references to addresses
2767 : : of nested functions that require the use of trampolines. The rewrite
2768 : : will involve a reference a trampoline generated for the occasion. */
2769 : :
2770 : : static tree
2771 : 17741791 : convert_tramp_reference_op (tree *tp, int *walk_subtrees, void *data)
2772 : : {
2773 : 17741791 : struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
2774 : 17741791 : struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
2775 : 17741791 : tree t = *tp, decl, target_context, x, builtin;
2776 : 17741791 : bool descr;
2777 : 17741791 : gcall *call;
2778 : :
2779 : 17741791 : *walk_subtrees = 0;
2780 : 17741791 : switch (TREE_CODE (t))
2781 : : {
2782 : 359542 : case ADDR_EXPR:
2783 : : /* Build
2784 : : T.1 = &CHAIN->tramp;
2785 : : T.2 = __builtin_adjust_trampoline (T.1);
2786 : : T.3 = (func_type)T.2;
2787 : : */
2788 : :
2789 : 359542 : decl = TREE_OPERAND (t, 0);
2790 : 359542 : if (TREE_CODE (decl) != FUNCTION_DECL)
2791 : : break;
2792 : :
2793 : : /* Only need to process nested functions. */
2794 : 862 : target_context = decl_function_context (decl);
2795 : 862 : if (!target_context)
2796 : : break;
2797 : :
2798 : : /* If the nested function doesn't use a static chain, then
2799 : : it doesn't need a trampoline. */
2800 : 607 : if (!DECL_STATIC_CHAIN (decl))
2801 : : break;
2802 : :
2803 : : /* If we don't want a trampoline, then don't build one. */
2804 : 282 : if (TREE_NO_TRAMPOLINE (t))
2805 : : break;
2806 : :
2807 : : /* Lookup the immediate parent of the callee, as that's where
2808 : : we need to insert the trampoline. */
2809 : 307 : for (i = info; i->context != target_context; i = i->outer)
2810 : 25 : continue;
2811 : :
2812 : : /* Decide whether to generate a descriptor or a trampoline. */
2813 : 282 : descr = FUNC_ADDR_BY_DESCRIPTOR (t) && !flag_trampolines;
2814 : :
2815 : 282 : if (descr)
2816 : 0 : x = lookup_descr_for_decl (i, decl, INSERT);
2817 : : else
2818 : 282 : x = lookup_tramp_for_decl (i, decl, INSERT);
2819 : :
2820 : : /* Compute the address of the field holding the trampoline. */
2821 : 282 : x = get_frame_field (info, target_context, x, &wi->gsi);
2822 : :
2823 : : /* APB: We don't need to do the adjustment calls when using off-stack
2824 : : trampolines, any such adjustment will be done when the off-stack
2825 : : trampoline is created. */
2826 : 282 : if (!descr && flag_trampoline_impl == TRAMPOLINE_IMPL_HEAP)
2827 : 3 : x = gsi_gimplify_val (info, x, &wi->gsi);
2828 : : else
2829 : : {
2830 : 279 : x = build_addr (x);
2831 : :
2832 : 279 : x = gsi_gimplify_val (info, x, &wi->gsi);
2833 : :
2834 : : /* Do machine-specific ugliness. Normally this will involve
2835 : : computing extra alignment, but it can really be anything. */
2836 : 279 : if (descr)
2837 : 0 : builtin = builtin_decl_implicit (BUILT_IN_ADJUST_DESCRIPTOR);
2838 : : else
2839 : 279 : builtin = builtin_decl_implicit (BUILT_IN_ADJUST_TRAMPOLINE);
2840 : 279 : call = gimple_build_call (builtin, 1, x);
2841 : 279 : x = init_tmp_var_with_call (info, &wi->gsi, call);
2842 : : }
2843 : :
2844 : : /* Cast back to the proper function type. */
2845 : 282 : x = build1 (NOP_EXPR, TREE_TYPE (t), x);
2846 : 282 : x = init_tmp_var (info, x, &wi->gsi);
2847 : :
2848 : 282 : *tp = x;
2849 : 282 : break;
2850 : :
2851 : 17382249 : default:
2852 : 17382249 : if (!IS_TYPE_OR_DECL_P (t))
2853 : 9200200 : *walk_subtrees = 1;
2854 : : break;
2855 : : }
2856 : :
2857 : 17741791 : return NULL_TREE;
2858 : : }
2859 : :
2860 : :
2861 : : /* Called via walk_function+walk_gimple_stmt, rewrite all references
2862 : : to addresses of nested functions that require the use of
2863 : : trampolines. The rewrite will involve a reference a trampoline
2864 : : generated for the occasion. */
2865 : :
2866 : : static tree
2867 : 5419015 : convert_tramp_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2868 : : struct walk_stmt_info *wi)
2869 : : {
2870 : 5419015 : struct nesting_info *info = (struct nesting_info *) wi->info;
2871 : 5419015 : gimple *stmt = gsi_stmt (*gsi);
2872 : :
2873 : 5419015 : switch (gimple_code (stmt))
2874 : : {
2875 : 322677 : case GIMPLE_CALL:
2876 : 322677 : {
2877 : : /* Only walk call arguments, lest we generate trampolines for
2878 : : direct calls. */
2879 : 322677 : unsigned long i, nargs = gimple_call_num_args (stmt);
2880 : 1097603 : for (i = 0; i < nargs; i++)
2881 : 774926 : walk_tree (gimple_call_arg_ptr (stmt, i), convert_tramp_reference_op,
2882 : : wi, NULL);
2883 : : break;
2884 : : }
2885 : :
2886 : 38 : case GIMPLE_OMP_TEAMS:
2887 : 38 : if (!gimple_omp_teams_host (as_a <gomp_teams *> (stmt)))
2888 : : {
2889 : 26 : *handled_ops_p = false;
2890 : 26 : return NULL_TREE;
2891 : : }
2892 : 12 : goto do_parallel;
2893 : :
2894 : 1767 : case GIMPLE_OMP_TARGET:
2895 : 1767 : if (!is_gimple_omp_offloaded (stmt))
2896 : : {
2897 : 648 : *handled_ops_p = false;
2898 : 648 : return NULL_TREE;
2899 : : }
2900 : : /* FALLTHRU */
2901 : 2456 : case GIMPLE_OMP_PARALLEL:
2902 : 2456 : case GIMPLE_OMP_TASK:
2903 : 1119 : do_parallel:
2904 : 2456 : {
2905 : 2456 : tree save_local_var_chain = info->new_local_var_chain;
2906 : 2456 : walk_gimple_op (stmt, convert_tramp_reference_op, wi);
2907 : 2456 : info->new_local_var_chain = NULL;
2908 : 2456 : char save_static_chain_added = info->static_chain_added;
2909 : 2456 : info->static_chain_added = 0;
2910 : 2456 : walk_body (convert_tramp_reference_stmt, convert_tramp_reference_op,
2911 : : info, gimple_omp_body_ptr (stmt));
2912 : 2456 : if (info->new_local_var_chain)
2913 : 6 : declare_vars (info->new_local_var_chain,
2914 : : gimple_seq_first_stmt (gimple_omp_body (stmt)),
2915 : : false);
2916 : 7368 : for (int i = 0; i < 2; i++)
2917 : : {
2918 : 4912 : tree c, decl;
2919 : 4912 : if ((info->static_chain_added & (1 << i)) == 0)
2920 : 4906 : continue;
2921 : 6 : decl = i ? get_chain_decl (info) : info->frame_decl;
2922 : : /* Don't add CHAIN.* or FRAME.* twice. */
2923 : 6 : if (gimple_code (stmt) == GIMPLE_OMP_TARGET)
2924 : 0 : c = gimple_omp_target_clauses (stmt);
2925 : : else
2926 : 6 : c = gimple_omp_taskreg_clauses (stmt);
2927 : 6 : for (; c; c = OMP_CLAUSE_CHAIN (c))
2928 : 1 : if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
2929 : 1 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
2930 : 2 : && OMP_CLAUSE_DECL (c) == decl)
2931 : : break;
2932 : 6 : if (c == NULL && gimple_code (stmt) != GIMPLE_OMP_TARGET)
2933 : : {
2934 : 8 : c = build_omp_clause (gimple_location (stmt),
2935 : : i ? OMP_CLAUSE_FIRSTPRIVATE
2936 : : : OMP_CLAUSE_SHARED);
2937 : 5 : OMP_CLAUSE_DECL (c) = decl;
2938 : 5 : OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
2939 : 5 : gimple_omp_taskreg_set_clauses (stmt, c);
2940 : : }
2941 : 1 : else if (c == NULL)
2942 : : {
2943 : 0 : c = build_omp_clause (gimple_location (stmt),
2944 : : OMP_CLAUSE_MAP);
2945 : 0 : OMP_CLAUSE_DECL (c) = decl;
2946 : 0 : OMP_CLAUSE_SET_MAP_KIND (c,
2947 : : i ? GOMP_MAP_TO : GOMP_MAP_TOFROM);
2948 : 0 : OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
2949 : 0 : OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
2950 : 0 : gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt),
2951 : : c);
2952 : : }
2953 : : }
2954 : 2456 : info->new_local_var_chain = save_local_var_chain;
2955 : 2456 : info->static_chain_added |= save_static_chain_added;
2956 : : }
2957 : 2456 : break;
2958 : :
2959 : 5093208 : default:
2960 : 5093208 : *handled_ops_p = false;
2961 : 5093208 : return NULL_TREE;
2962 : : }
2963 : :
2964 : 325133 : *handled_ops_p = true;
2965 : 325133 : return NULL_TREE;
2966 : : }
2967 : :
2968 : :
2969 : :
2970 : : /* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_CALLs
2971 : : that reference nested functions to make sure that the static chain
2972 : : is set up properly for the call. */
2973 : :
2974 : : static tree
2975 : 5419605 : convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
2976 : : struct walk_stmt_info *wi)
2977 : : {
2978 : 5419605 : struct nesting_info *const info = (struct nesting_info *) wi->info;
2979 : 5419605 : tree decl, target_context;
2980 : 5419605 : char save_static_chain_added;
2981 : 5419605 : int i;
2982 : 5419605 : gimple *stmt = gsi_stmt (*gsi);
2983 : :
2984 : 5419605 : switch (gimple_code (stmt))
2985 : : {
2986 : 322956 : case GIMPLE_CALL:
2987 : 322956 : if (gimple_call_chain (stmt))
2988 : : break;
2989 : 322748 : decl = gimple_call_fndecl (stmt);
2990 : 322748 : if (!decl)
2991 : : break;
2992 : 289987 : target_context = decl_function_context (decl);
2993 : 341754 : if (target_context && DECL_STATIC_CHAIN (decl))
2994 : : {
2995 : : struct nesting_info *i = info;
2996 : 17992 : while (i && i->context != target_context)
2997 : 2175 : i = i->outer;
2998 : : /* If none of the outer contexts is the target context, this means
2999 : : that the function is called in a wrong context. */
3000 : 15817 : if (!i)
3001 : 0 : internal_error ("%s from %s called in %s",
3002 : 0 : IDENTIFIER_POINTER (DECL_NAME (decl)),
3003 : 0 : IDENTIFIER_POINTER (DECL_NAME (target_context)),
3004 : 0 : IDENTIFIER_POINTER (DECL_NAME (info->context)));
3005 : :
3006 : 15817 : gimple_call_set_chain (as_a <gcall *> (stmt),
3007 : : get_static_chain (info, target_context,
3008 : : &wi->gsi));
3009 : 29499 : info->static_chain_added |= (1 << (info->context != target_context));
3010 : : }
3011 : : break;
3012 : :
3013 : 38 : case GIMPLE_OMP_TEAMS:
3014 : 38 : if (!gimple_omp_teams_host (as_a <gomp_teams *> (stmt)))
3015 : : {
3016 : 26 : walk_body (convert_gimple_call, NULL, info,
3017 : : gimple_omp_body_ptr (stmt));
3018 : 26 : break;
3019 : : }
3020 : : /* FALLTHRU */
3021 : :
3022 : 1337 : case GIMPLE_OMP_PARALLEL:
3023 : 1337 : case GIMPLE_OMP_TASK:
3024 : 1337 : save_static_chain_added = info->static_chain_added;
3025 : 1337 : info->static_chain_added = 0;
3026 : 1337 : walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
3027 : 4011 : for (i = 0; i < 2; i++)
3028 : : {
3029 : 2674 : tree c, decl;
3030 : 2674 : if ((info->static_chain_added & (1 << i)) == 0)
3031 : 2604 : continue;
3032 : 70 : decl = i ? get_chain_decl (info) : info->frame_decl;
3033 : : /* Don't add CHAIN.* or FRAME.* twice. */
3034 : 70 : for (c = gimple_omp_taskreg_clauses (stmt);
3035 : 750 : c;
3036 : 680 : c = OMP_CLAUSE_CHAIN (c))
3037 : 682 : if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
3038 : 270 : || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
3039 : 742 : && OMP_CLAUSE_DECL (c) == decl)
3040 : : break;
3041 : 70 : if (c == NULL)
3042 : : {
3043 : 112 : c = build_omp_clause (gimple_location (stmt),
3044 : : i ? OMP_CLAUSE_FIRSTPRIVATE
3045 : : : OMP_CLAUSE_SHARED);
3046 : 68 : OMP_CLAUSE_DECL (c) = decl;
3047 : 68 : OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
3048 : 68 : gimple_omp_taskreg_set_clauses (stmt, c);
3049 : : }
3050 : : }
3051 : 1337 : info->static_chain_added |= save_static_chain_added;
3052 : 1337 : break;
3053 : :
3054 : 1767 : case GIMPLE_OMP_TARGET:
3055 : 1767 : if (!is_gimple_omp_offloaded (stmt))
3056 : : {
3057 : 648 : walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
3058 : 648 : break;
3059 : : }
3060 : 1119 : save_static_chain_added = info->static_chain_added;
3061 : 1119 : info->static_chain_added = 0;
3062 : 1119 : walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
3063 : 3357 : for (i = 0; i < 2; i++)
3064 : : {
3065 : 2238 : tree c, decl;
3066 : 2238 : if ((info->static_chain_added & (1 << i)) == 0)
3067 : 2218 : continue;
3068 : 20 : decl = i ? get_chain_decl (info) : info->frame_decl;
3069 : : /* Don't add CHAIN.* or FRAME.* twice. */
3070 : 20 : for (c = gimple_omp_target_clauses (stmt);
3071 : 150 : c;
3072 : 130 : c = OMP_CLAUSE_CHAIN (c))
3073 : 130 : if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP
3074 : 130 : && OMP_CLAUSE_DECL (c) == decl)
3075 : : break;
3076 : 20 : if (c == NULL)
3077 : : {
3078 : 20 : c = build_omp_clause (gimple_location (stmt), OMP_CLAUSE_MAP);
3079 : 20 : OMP_CLAUSE_DECL (c) = decl;
3080 : 30 : OMP_CLAUSE_SET_MAP_KIND (c, i ? GOMP_MAP_TO : GOMP_MAP_TOFROM);
3081 : 20 : OMP_CLAUSE_SIZE (c) = DECL_SIZE_UNIT (decl);
3082 : 20 : OMP_CLAUSE_CHAIN (c) = gimple_omp_target_clauses (stmt);
3083 : 20 : gimple_omp_target_set_clauses (as_a <gomp_target *> (stmt),
3084 : : c);
3085 : : }
3086 : : }
3087 : 1119 : info->static_chain_added |= save_static_chain_added;
3088 : 1119 : break;
3089 : :
3090 : 1511 : case GIMPLE_OMP_FOR:
3091 : 1511 : walk_body (convert_gimple_call, NULL, info,
3092 : : gimple_omp_for_pre_body_ptr (stmt));
3093 : : /* FALLTHRU */
3094 : 2457 : case GIMPLE_OMP_SECTIONS:
3095 : 2457 : case GIMPLE_OMP_SECTION:
3096 : 2457 : case GIMPLE_OMP_STRUCTURED_BLOCK:
3097 : 2457 : case GIMPLE_OMP_SINGLE:
3098 : 2457 : case GIMPLE_OMP_SCOPE:
3099 : 2457 : case GIMPLE_OMP_MASTER:
3100 : 2457 : case GIMPLE_OMP_MASKED:
3101 : 2457 : case GIMPLE_OMP_TASKGROUP:
3102 : 2457 : case GIMPLE_OMP_ORDERED:
3103 : 2457 : case GIMPLE_OMP_SCAN:
3104 : 2457 : case GIMPLE_OMP_CRITICAL:
3105 : 2457 : walk_body (convert_gimple_call, NULL, info, gimple_omp_body_ptr (stmt));
3106 : 2457 : break;
3107 : :
3108 : 5091062 : default:
3109 : : /* Keep looking for other operands. */
3110 : 5091062 : *handled_ops_p = false;
3111 : 5091062 : return NULL_TREE;
3112 : : }
3113 : :
3114 : 328543 : *handled_ops_p = true;
3115 : 328543 : return NULL_TREE;
3116 : : }
3117 : :
3118 : : /* Walk the nesting tree starting with ROOT. Convert all trampolines and
3119 : : call expressions. At the same time, determine if a nested function
3120 : : actually uses its static chain; if not, remember that. */
3121 : :
3122 : : static void
3123 : 8933 : convert_all_function_calls (struct nesting_info *root)
3124 : : {
3125 : 8933 : unsigned int chain_count = 0, old_chain_count, iter_count;
3126 : 8933 : struct nesting_info *n;
3127 : :
3128 : : /* First, optimistically clear static_chain for all decls that haven't
3129 : : used the static chain already for variable access. But always create
3130 : : it if not optimizing. This makes it possible to reconstruct the static
3131 : : nesting tree at run time and thus to resolve up-level references from
3132 : : within the debugger. */
3133 : 80786 : FOR_EACH_NEST_INFO (n, root)
3134 : : {
3135 : 31460 : if (n->thunk_p)
3136 : 0 : continue;
3137 : 31460 : tree decl = n->context;
3138 : 31460 : if (!optimize)
3139 : : {
3140 : 5229 : if (n->inner)
3141 : 1544 : (void) get_frame_type (n);
3142 : 5229 : if (n->outer)
3143 : 3731 : (void) get_chain_decl (n);
3144 : : }
3145 : 26231 : else if (!n->outer || (!n->chain_decl && !n->chain_field))
3146 : : {
3147 : 23591 : DECL_STATIC_CHAIN (decl) = 0;
3148 : 23591 : if (dump_file && (dump_flags & TDF_DETAILS))
3149 : 0 : fprintf (dump_file, "Guessing no static-chain for %s\n",
3150 : 0 : lang_hooks.decl_printable_name (decl, 2));
3151 : : }
3152 : : else
3153 : 2640 : DECL_STATIC_CHAIN (decl) = 1;
3154 : 31460 : chain_count += DECL_STATIC_CHAIN (decl);
3155 : : }
3156 : :
3157 : 71853 : FOR_EACH_NEST_INFO (n, root)
3158 : 31460 : if (n->thunk_p)
3159 : : {
3160 : 0 : tree decl = n->context;
3161 : 0 : tree alias = thunk_info::get (cgraph_node::get (decl))->alias;
3162 : 0 : DECL_STATIC_CHAIN (decl) = DECL_STATIC_CHAIN (alias);
3163 : : }
3164 : :
3165 : : /* Walk the functions and perform transformations. Note that these
3166 : : transformations can induce new uses of the static chain, which in turn
3167 : : require re-examining all users of the decl. */
3168 : : /* ??? It would make sense to try to use the call graph to speed this up,
3169 : : but the call graph hasn't really been built yet. Even if it did, we
3170 : : would still need to iterate in this loop since address-of references
3171 : : wouldn't show up in the callgraph anyway. */
3172 : : iter_count = 0;
3173 : 8989 : do
3174 : : {
3175 : 8989 : old_chain_count = chain_count;
3176 : 8989 : chain_count = 0;
3177 : 8989 : iter_count++;
3178 : :
3179 : 8989 : if (dump_file && (dump_flags & TDF_DETAILS))
3180 : 0 : fputc ('\n', dump_file);
3181 : :
3182 : 81436 : FOR_EACH_NEST_INFO (n, root)
3183 : : {
3184 : 31729 : if (n->thunk_p)
3185 : 0 : continue;
3186 : 31729 : tree decl = n->context;
3187 : 31729 : walk_function (convert_tramp_reference_stmt,
3188 : : convert_tramp_reference_op, n);
3189 : 31729 : walk_function (convert_gimple_call, NULL, n);
3190 : 31729 : chain_count += DECL_STATIC_CHAIN (decl);
3191 : : }
3192 : :
3193 : 72447 : FOR_EACH_NEST_INFO (n, root)
3194 : 31729 : if (n->thunk_p)
3195 : : {
3196 : 0 : tree decl = n->context;
3197 : 0 : tree alias = thunk_info::get (cgraph_node::get (decl))->alias;
3198 : 0 : DECL_STATIC_CHAIN (decl) = DECL_STATIC_CHAIN (alias);
3199 : : }
3200 : : }
3201 : 8989 : while (chain_count != old_chain_count);
3202 : :
3203 : 8933 : if (dump_file && (dump_flags & TDF_DETAILS))
3204 : 0 : fprintf (dump_file, "convert_all_function_calls iterations: %u\n\n",
3205 : : iter_count);
3206 : 8933 : }
3207 : :
3208 : : struct nesting_copy_body_data
3209 : : {
3210 : : copy_body_data cb;
3211 : : struct nesting_info *root;
3212 : : };
3213 : :
3214 : : /* A helper subroutine for debug_var_chain type remapping. */
3215 : :
3216 : : static tree
3217 : 30 : nesting_copy_decl (tree decl, copy_body_data *id)
3218 : : {
3219 : 30 : struct nesting_copy_body_data *nid = (struct nesting_copy_body_data *) id;
3220 : 30 : tree *slot = nid->root->var_map->get (decl);
3221 : :
3222 : 30 : if (slot)
3223 : 6 : return (tree) *slot;
3224 : :
3225 : 24 : if (TREE_CODE (decl) == TYPE_DECL && DECL_ORIGINAL_TYPE (decl))
3226 : : {
3227 : 6 : tree new_decl = copy_decl_no_change (decl, id);
3228 : 12 : DECL_ORIGINAL_TYPE (new_decl)
3229 : 6 : = remap_type (DECL_ORIGINAL_TYPE (decl), id);
3230 : 6 : return new_decl;
3231 : : }
3232 : :
3233 : 18 : if (VAR_P (decl)
3234 : : || TREE_CODE (decl) == PARM_DECL
3235 : : || TREE_CODE (decl) == RESULT_DECL)
3236 : : return decl;
3237 : :
3238 : 0 : return copy_decl_no_change (decl, id);
3239 : : }
3240 : :
3241 : : /* A helper function for remap_vla_decls. See if *TP contains
3242 : : some remapped variables. */
3243 : :
3244 : : static tree
3245 : 36 : contains_remapped_vars (tree *tp, int *walk_subtrees, void *data)
3246 : : {
3247 : 36 : struct nesting_info *root = (struct nesting_info *) data;
3248 : 36 : tree t = *tp;
3249 : :
3250 : 36 : if (DECL_P (t))
3251 : : {
3252 : 0 : *walk_subtrees = 0;
3253 : 0 : tree *slot = root->var_map->get (t);
3254 : :
3255 : 0 : if (slot)
3256 : 0 : return *slot;
3257 : : }
3258 : : return NULL;
3259 : : }
3260 : :
3261 : : /* Remap VLA decls in BLOCK and subblocks if remapped variables are
3262 : : involved. */
3263 : :
3264 : : static void
3265 : 2700 : remap_vla_decls (tree block, struct nesting_info *root)
3266 : : {
3267 : 2700 : tree var, subblock, val, type;
3268 : 2700 : struct nesting_copy_body_data id;
3269 : :
3270 : 5053 : for (subblock = BLOCK_SUBBLOCKS (block);
3271 : 5053 : subblock;
3272 : 2353 : subblock = BLOCK_CHAIN (subblock))
3273 : 2353 : remap_vla_decls (subblock, root);
3274 : :
3275 : 8627 : for (var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
3276 : 5927 : if (VAR_P (var) && DECL_HAS_VALUE_EXPR_P (var))
3277 : : {
3278 : 88 : val = DECL_VALUE_EXPR (var);
3279 : 88 : type = TREE_TYPE (var);
3280 : :
3281 : 100 : if (! (INDIRECT_REF_P (val)
3282 : 12 : && VAR_P (TREE_OPERAND (val, 0))
3283 : 12 : && variably_modified_type_p (type, NULL)))
3284 : 76 : continue;
3285 : :
3286 : 12 : if (root->var_map->get (TREE_OPERAND (val, 0))
3287 : 12 : || walk_tree (&type, contains_remapped_vars, root, NULL))
3288 : : break;
3289 : : }
3290 : :
3291 : 2700 : if (var == NULL_TREE)
3292 : 2700 : return;
3293 : :
3294 : 0 : memset (&id, 0, sizeof (id));
3295 : 0 : id.cb.copy_decl = nesting_copy_decl;
3296 : 0 : id.cb.decl_map = new hash_map<tree, tree>;
3297 : 0 : id.root = root;
3298 : :
3299 : 0 : for (; var; var = DECL_CHAIN (var))
3300 : 0 : if (VAR_P (var) && DECL_HAS_VALUE_EXPR_P (var))
3301 : : {
3302 : 0 : struct nesting_info *i;
3303 : 0 : tree newt, context;
3304 : :
3305 : 0 : val = DECL_VALUE_EXPR (var);
3306 : 0 : type = TREE_TYPE (var);
3307 : :
3308 : 0 : if (! (INDIRECT_REF_P (val)
3309 : 0 : && VAR_P (TREE_OPERAND (val, 0))
3310 : 0 : && variably_modified_type_p (type, NULL)))
3311 : 0 : continue;
3312 : :
3313 : 0 : tree *slot = root->var_map->get (TREE_OPERAND (val, 0));
3314 : 0 : if (!slot && !walk_tree (&type, contains_remapped_vars, root, NULL))
3315 : 0 : continue;
3316 : :
3317 : 0 : context = decl_function_context (var);
3318 : 0 : for (i = root; i; i = i->outer)
3319 : 0 : if (i->context == context)
3320 : : break;
3321 : :
3322 : 0 : if (i == NULL)
3323 : 0 : continue;
3324 : :
3325 : : /* Fully expand value expressions. This avoids having debug variables
3326 : : only referenced from them and that can be swept during GC. */
3327 : 0 : if (slot)
3328 : : {
3329 : 0 : tree t = (tree) *slot;
3330 : 0 : gcc_assert (DECL_P (t) && DECL_HAS_VALUE_EXPR_P (t));
3331 : 0 : val = build1 (INDIRECT_REF, TREE_TYPE (val), DECL_VALUE_EXPR (t));
3332 : : }
3333 : :
3334 : 0 : id.cb.src_fn = i->context;
3335 : 0 : id.cb.dst_fn = i->context;
3336 : 0 : id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
3337 : :
3338 : 0 : TREE_TYPE (var) = newt = remap_type (type, &id.cb);
3339 : 0 : while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
3340 : : {
3341 : 0 : newt = TREE_TYPE (newt);
3342 : 0 : type = TREE_TYPE (type);
3343 : : }
3344 : 0 : if (TYPE_NAME (newt)
3345 : 0 : && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
3346 : 0 : && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
3347 : 0 : && newt != type
3348 : 0 : && TYPE_NAME (newt) == TYPE_NAME (type))
3349 : 0 : TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
3350 : :
3351 : 0 : walk_tree (&val, copy_tree_body_r, &id.cb, NULL);
3352 : 0 : if (val != DECL_VALUE_EXPR (var))
3353 : 0 : SET_DECL_VALUE_EXPR (var, val);
3354 : : }
3355 : :
3356 : 0 : delete id.cb.decl_map;
3357 : : }
3358 : :
3359 : : /* Fixup VLA decls in BLOCK and subblocks if remapped variables are
3360 : : involved. */
3361 : :
3362 : : static void
3363 : 237450 : fixup_vla_decls (tree block)
3364 : : {
3365 : 1019846 : for (tree var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
3366 : 782396 : if (VAR_P (var) && DECL_HAS_VALUE_EXPR_P (var))
3367 : : {
3368 : 3735 : tree val = DECL_VALUE_EXPR (var);
3369 : :
3370 : 3735 : if (! (INDIRECT_REF_P (val)
3371 : 340 : && VAR_P (TREE_OPERAND (val, 0))
3372 : 338 : && DECL_HAS_VALUE_EXPR_P (TREE_OPERAND (val, 0))))
3373 : 3702 : continue;
3374 : :
3375 : : /* Fully expand value expressions. This avoids having debug variables
3376 : : only referenced from them and that can be swept during GC. */
3377 : 33 : val = build1 (INDIRECT_REF, TREE_TYPE (val),
3378 : 33 : DECL_VALUE_EXPR (TREE_OPERAND (val, 0)));
3379 : 33 : SET_DECL_VALUE_EXPR (var, val);
3380 : : }
3381 : :
3382 : 443787 : for (tree sub = BLOCK_SUBBLOCKS (block); sub; sub = BLOCK_CHAIN (sub))
3383 : 206337 : fixup_vla_decls (sub);
3384 : 237450 : }
3385 : :
3386 : : /* Fold the MEM_REF *E. */
3387 : : bool
3388 : 0 : fold_mem_refs (tree *const &e, void *data ATTRIBUTE_UNUSED)
3389 : : {
3390 : 0 : tree *ref_p = CONST_CAST2 (tree *, const tree *, (const tree *)e);
3391 : 0 : *ref_p = fold (*ref_p);
3392 : 0 : return true;
3393 : : }
3394 : :
3395 : : /* Given DECL, a nested function, build an initialization call for FIELD,
3396 : : the trampoline or descriptor for DECL, using FUNC as the function. */
3397 : :
3398 : : static gcall *
3399 : 261 : build_init_call_stmt (struct nesting_info *info, tree decl, tree field,
3400 : : tree func)
3401 : : {
3402 : 261 : tree arg1, arg2, arg3, x;
3403 : :
3404 : 261 : gcc_assert (DECL_STATIC_CHAIN (decl));
3405 : 261 : arg3 = build_addr (info->frame_decl);
3406 : :
3407 : 261 : arg2 = build_addr (decl);
3408 : :
3409 : 261 : x = build3 (COMPONENT_REF, TREE_TYPE (field),
3410 : : info->frame_decl, field, NULL_TREE);
3411 : 261 : arg1 = build_addr (x);
3412 : :
3413 : 261 : return gimple_build_call (func, 3, arg1, arg2, arg3);
3414 : : }
3415 : :
3416 : : /* Do "everything else" to clean up or complete state collected by the various
3417 : : walking passes -- create a field to hold the frame base address, lay out the
3418 : : types and decls, generate code to initialize the frame decl, store critical
3419 : : expressions in the struct function for rtl to find. */
3420 : :
3421 : : static void
3422 : 31460 : finalize_nesting_tree_1 (struct nesting_info *root)
3423 : : {
3424 : 31460 : gimple_seq cleanup_list = NULL;
3425 : 31460 : gimple_seq stmt_list = NULL;
3426 : 31460 : gimple *stmt;
3427 : 31460 : tree context = root->context;
3428 : 31460 : struct function *sf;
3429 : :
3430 : 31460 : if (root->thunk_p)
3431 : 0 : return;
3432 : :
3433 : : /* If we created a non-local frame type or decl, we need to lay them
3434 : : out at this time. */
3435 : 31460 : if (root->frame_type)
3436 : : {
3437 : : /* Debugging information needs to compute the frame base address of the
3438 : : parent frame out of the static chain from the nested frame.
3439 : :
3440 : : The static chain is the address of the FRAME record, so one could
3441 : : imagine it would be possible to compute the frame base address just
3442 : : adding a constant offset to this address. Unfortunately, this is not
3443 : : possible: if the FRAME object has alignment constraints that are
3444 : : stronger than the stack, then the offset between the frame base and
3445 : : the FRAME object will be dynamic.
3446 : :
3447 : : What we do instead is to append a field to the FRAME object that holds
3448 : : the frame base address: then debug info just has to fetch this
3449 : : field. */
3450 : :
3451 : : /* Debugging information will refer to the CFA as the frame base
3452 : : address: we will do the same here. */
3453 : 3309 : const tree frame_addr_fndecl
3454 : 3309 : = builtin_decl_explicit (BUILT_IN_DWARF_CFA);
3455 : :
3456 : : /* Create a field in the FRAME record to hold the frame base address for
3457 : : this stack frame. Since it will be used only by the debugger, put it
3458 : : at the end of the record in order not to shift all other offsets. */
3459 : 3309 : tree fb_decl = make_node (FIELD_DECL);
3460 : :
3461 : 3309 : DECL_NAME (fb_decl) = get_identifier ("FRAME_BASE.PARENT");
3462 : 3309 : TREE_TYPE (fb_decl) = ptr_type_node;
3463 : 3309 : TREE_ADDRESSABLE (fb_decl) = 1;
3464 : 3309 : DECL_CONTEXT (fb_decl) = root->frame_type;
3465 : 3309 : TYPE_FIELDS (root->frame_type) = chainon (TYPE_FIELDS (root->frame_type),
3466 : : fb_decl);
3467 : :
3468 : : /* In some cases the frame type will trigger the -Wpadded warning.
3469 : : This is not helpful; suppress it. */
3470 : 3309 : int save_warn_padded = warn_padded;
3471 : 3309 : warn_padded = 0;
3472 : 3309 : layout_type (root->frame_type);
3473 : 3309 : warn_padded = save_warn_padded;
3474 : 3309 : layout_decl (root->frame_decl, 0);
3475 : :
3476 : : /* Initialize the frame base address field. If the builtin we need is
3477 : : not available, set it to NULL so that debugging information does not
3478 : : reference junk. */
3479 : 3309 : tree fb_ref = build3 (COMPONENT_REF, TREE_TYPE (fb_decl),
3480 : : root->frame_decl, fb_decl, NULL_TREE);
3481 : 3309 : tree fb_tmp;
3482 : :
3483 : 3309 : if (frame_addr_fndecl != NULL_TREE)
3484 : : {
3485 : 1032 : gcall *fb_gimple = gimple_build_call (frame_addr_fndecl, 1,
3486 : : integer_zero_node);
3487 : 1032 : gimple_stmt_iterator gsi = gsi_last (stmt_list);
3488 : :
3489 : 1032 : fb_tmp = init_tmp_var_with_call (root, &gsi, fb_gimple);
3490 : : }
3491 : : else
3492 : 2277 : fb_tmp = build_int_cst (TREE_TYPE (fb_ref), 0);
3493 : 3309 : gimple_seq_add_stmt (&stmt_list,
3494 : 3309 : gimple_build_assign (fb_ref, fb_tmp));
3495 : :
3496 : 3309 : declare_vars (root->frame_decl,
3497 : : gimple_seq_first_stmt (gimple_body (context)), true);
3498 : : }
3499 : :
3500 : : /* If any parameters were referenced non-locally, then we need to insert
3501 : : a copy or a pointer. */
3502 : 31460 : if (root->any_parm_remapped)
3503 : : {
3504 : 211 : tree p;
3505 : 593 : for (p = DECL_ARGUMENTS (context); p ; p = DECL_CHAIN (p))
3506 : : {
3507 : 382 : tree field, x, y;
3508 : :
3509 : 382 : field = lookup_field_for_decl (root, p, NO_INSERT);
3510 : 382 : if (!field)
3511 : 132 : continue;
3512 : :
3513 : 250 : if (use_pointer_in_frame (p))
3514 : 21 : x = build_addr (p);
3515 : : else
3516 : : x = p;
3517 : :
3518 : : /* If the assignment is from a non-register the stmt is
3519 : : not valid gimple. Make it so by using a temporary instead. */
3520 : 250 : if (!is_gimple_reg (x)
3521 : 250 : && is_gimple_reg_type (TREE_TYPE (x)))
3522 : : {
3523 : 37 : gimple_stmt_iterator gsi = gsi_last (stmt_list);
3524 : 37 : x = init_tmp_var (root, x, &gsi);
3525 : : }
3526 : :
3527 : 250 : y = build3 (COMPONENT_REF, TREE_TYPE (field),
3528 : : root->frame_decl, field, NULL_TREE);
3529 : 250 : stmt = gimple_build_assign (y, x);
3530 : 250 : gimple_seq_add_stmt (&stmt_list, stmt);
3531 : : }
3532 : : }
3533 : :
3534 : : /* If a chain_field was created, then it needs to be initialized
3535 : : from chain_decl. */
3536 : 31460 : if (root->chain_field)
3537 : : {
3538 : 77 : tree x = build3 (COMPONENT_REF, TREE_TYPE (root->chain_field),
3539 : : root->frame_decl, root->chain_field, NULL_TREE);
3540 : 77 : stmt = gimple_build_assign (x, get_chain_decl (root));
3541 : 77 : gimple_seq_add_stmt (&stmt_list, stmt);
3542 : : }
3543 : :
3544 : : /* If trampolines were created, then we need to initialize them. */
3545 : 31460 : if (root->any_tramp_created)
3546 : : {
3547 : 234 : struct nesting_info *i;
3548 : 571 : for (i = root->inner; i ; i = i->next)
3549 : : {
3550 : 337 : tree field, x;
3551 : :
3552 : 337 : field = lookup_tramp_for_decl (root, i->context, NO_INSERT);
3553 : 337 : if (!field)
3554 : 75 : continue;
3555 : :
3556 : 262 : if (flag_trampoline_impl == TRAMPOLINE_IMPL_HEAP)
3557 : : {
3558 : : /* We pass a whole bunch of arguments to the builtin function that
3559 : : creates the off-stack trampoline, these are
3560 : : 1. The nested function chain value (that must be passed to the
3561 : : nested function so it can find the function arguments).
3562 : : 2. A pointer to the nested function implementation,
3563 : : 3. The address in the local stack frame where we should write
3564 : : the address of the trampoline.
3565 : :
3566 : : When this code was originally written I just kind of threw
3567 : : everything at the builtin, figuring I'd work out what was
3568 : : actually needed later, I think, the stack pointer could
3569 : : certainly be dropped, arguments #2 and #4 are based off the
3570 : : stack pointer anyway, so #1 doesn't seem to add much value. */
3571 : 1 : tree arg1, arg2, arg3;
3572 : :
3573 : 1 : gcc_assert (DECL_STATIC_CHAIN (i->context));
3574 : 1 : arg1 = build_addr (root->frame_decl);
3575 : 1 : arg2 = build_addr (i->context);
3576 : :
3577 : 1 : x = build3 (COMPONENT_REF, TREE_TYPE (field),
3578 : : root->frame_decl, field, NULL_TREE);
3579 : 1 : arg3 = build_addr (x);
3580 : :
3581 : 1 : x = builtin_decl_explicit (BUILT_IN_GCC_NESTED_PTR_CREATED);
3582 : 1 : stmt = gimple_build_call (x, 3, arg1, arg2, arg3);
3583 : 1 : gimple_seq_add_stmt (&stmt_list, stmt);
3584 : :
3585 : : /* This call to delete the nested function trampoline is added to
3586 : : the cleanup list, and called when we exit the current scope. */
3587 : 1 : x = builtin_decl_explicit (BUILT_IN_GCC_NESTED_PTR_DELETED);
3588 : 1 : stmt = gimple_build_call (x, 0);
3589 : 1 : gimple_seq_add_stmt (&cleanup_list, stmt);
3590 : : }
3591 : : else
3592 : : {
3593 : : /* Original code to initialise the on stack trampoline. */
3594 : 261 : x = builtin_decl_implicit (BUILT_IN_INIT_TRAMPOLINE);
3595 : 261 : stmt = build_init_call_stmt (root, i->context, field, x);
3596 : 261 : gimple_seq_add_stmt (&stmt_list, stmt);
3597 : : }
3598 : : }
3599 : : }
3600 : :
3601 : : /* If descriptors were created, then we need to initialize them. */
3602 : 31460 : if (root->any_descr_created)
3603 : : {
3604 : 0 : struct nesting_info *i;
3605 : 0 : for (i = root->inner; i ; i = i->next)
3606 : : {
3607 : 0 : tree field, x;
3608 : :
3609 : 0 : field = lookup_descr_for_decl (root, i->context, NO_INSERT);
3610 : 0 : if (!field)
3611 : 0 : continue;
3612 : :
3613 : 0 : x = builtin_decl_implicit (BUILT_IN_INIT_DESCRIPTOR);
3614 : 0 : stmt = build_init_call_stmt (root, i->context, field, x);
3615 : 0 : gimple_seq_add_stmt (&stmt_list, stmt);
3616 : : }
3617 : : }
3618 : :
3619 : : /* If we created initialization statements, insert them. */
3620 : 31460 : if (stmt_list)
3621 : : {
3622 : 3309 : if (flag_trampoline_impl == TRAMPOLINE_IMPL_HEAP)
3623 : : {
3624 : : /* Handle off-stack trampolines. */
3625 : 1 : gbind *bind;
3626 : 1 : annotate_all_with_location (stmt_list, DECL_SOURCE_LOCATION (context));
3627 : 1 : annotate_all_with_location (cleanup_list, DECL_SOURCE_LOCATION (context));
3628 : 1 : bind = gimple_seq_first_stmt_as_a_bind (gimple_body (context));
3629 : 1 : gimple_seq_add_seq (&stmt_list, gimple_bind_body (bind));
3630 : :
3631 : 1 : gimple_seq xxx_list = NULL;
3632 : :
3633 : 1 : if (cleanup_list != NULL)
3634 : : {
3635 : : /* Maybe we shouldn't be creating this try/finally if -fno-exceptions is
3636 : : in use. If this is the case, then maybe we should, instead, be
3637 : : inserting the cleanup code onto every path out of this function? Not
3638 : : yet figured out how we would do this. */
3639 : 1 : gtry *t = gimple_build_try (stmt_list, cleanup_list, GIMPLE_TRY_FINALLY);
3640 : 1 : gimple_seq_add_stmt (&xxx_list, t);
3641 : : }
3642 : : else
3643 : 0 : xxx_list = stmt_list;
3644 : :
3645 : 1 : gimple_bind_set_body (bind, xxx_list);
3646 : : }
3647 : : else
3648 : : {
3649 : : /* The traditional, on stack trampolines. */
3650 : 3308 : gbind *bind;
3651 : 3308 : annotate_all_with_location (stmt_list, DECL_SOURCE_LOCATION (context));
3652 : 3308 : bind = gimple_seq_first_stmt_as_a_bind (gimple_body (context));
3653 : 3308 : gimple_seq_add_seq (&stmt_list, gimple_bind_body (bind));
3654 : 3308 : gimple_bind_set_body (bind, stmt_list);
3655 : : }
3656 : : }
3657 : :
3658 : : /* If a chain_decl was created, then it needs to be registered with
3659 : : struct function so that it gets initialized from the static chain
3660 : : register at the beginning of the function. */
3661 : 31460 : sf = DECL_STRUCT_FUNCTION (root->context);
3662 : 31460 : sf->static_chain_decl = root->chain_decl;
3663 : :
3664 : : /* Similarly for the non-local goto save area. */
3665 : 31460 : if (root->nl_goto_field)
3666 : : {
3667 : 373 : sf->nonlocal_goto_save_area
3668 : 373 : = get_frame_field (root, context, root->nl_goto_field, NULL);
3669 : 373 : sf->has_nonlocal_label = 1;
3670 : : }
3671 : :
3672 : : /* Make sure all new local variables get inserted into the
3673 : : proper BIND_EXPR. */
3674 : 31460 : if (root->new_local_var_chain)
3675 : 3382 : declare_vars (root->new_local_var_chain,
3676 : : gimple_seq_first_stmt (gimple_body (root->context)),
3677 : : false);
3678 : :
3679 : 31460 : if (root->debug_var_chain)
3680 : : {
3681 : 347 : tree debug_var;
3682 : 347 : gbind *scope;
3683 : :
3684 : 347 : remap_vla_decls (DECL_INITIAL (root->context), root);
3685 : :
3686 : 1020 : for (debug_var = root->debug_var_chain; debug_var;
3687 : 673 : debug_var = DECL_CHAIN (debug_var))
3688 : 679 : if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
3689 : : break;
3690 : :
3691 : : /* If there are any debug decls with variable length types,
3692 : : remap those types using other debug_var_chain variables. */
3693 : 347 : if (debug_var)
3694 : : {
3695 : 6 : struct nesting_copy_body_data id;
3696 : :
3697 : 6 : memset (&id, 0, sizeof (id));
3698 : 6 : id.cb.copy_decl = nesting_copy_decl;
3699 : 6 : id.cb.decl_map = new hash_map<tree, tree>;
3700 : 6 : id.root = root;
3701 : :
3702 : 36 : for (; debug_var; debug_var = DECL_CHAIN (debug_var))
3703 : 30 : if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
3704 : : {
3705 : 6 : tree type = TREE_TYPE (debug_var);
3706 : 6 : tree newt, t = type;
3707 : 6 : struct nesting_info *i;
3708 : :
3709 : 12 : for (i = root; i; i = i->outer)
3710 : 12 : if (variably_modified_type_p (type, i->context))
3711 : : break;
3712 : :
3713 : 6 : if (i == NULL)
3714 : 0 : continue;
3715 : :
3716 : 6 : id.cb.src_fn = i->context;
3717 : 6 : id.cb.dst_fn = i->context;
3718 : 6 : id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
3719 : :
3720 : 6 : TREE_TYPE (debug_var) = newt = remap_type (type, &id.cb);
3721 : 12 : while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
3722 : : {
3723 : 6 : newt = TREE_TYPE (newt);
3724 : 6 : t = TREE_TYPE (t);
3725 : : }
3726 : 6 : if (TYPE_NAME (newt)
3727 : 6 : && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
3728 : 6 : && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
3729 : 6 : && newt != t
3730 : 12 : && TYPE_NAME (newt) == TYPE_NAME (t))
3731 : 6 : TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
3732 : : }
3733 : :
3734 : 12 : delete id.cb.decl_map;
3735 : : }
3736 : :
3737 : 347 : scope = gimple_seq_first_stmt_as_a_bind (gimple_body (root->context));
3738 : 347 : if (gimple_bind_block (scope))
3739 : 345 : declare_vars (root->debug_var_chain, scope, true);
3740 : : else
3741 : 2 : BLOCK_VARS (DECL_INITIAL (root->context))
3742 : 4 : = chainon (BLOCK_VARS (DECL_INITIAL (root->context)),
3743 : : root->debug_var_chain);
3744 : : }
3745 : : else
3746 : 31113 : fixup_vla_decls (DECL_INITIAL (root->context));
3747 : :
3748 : : /* Fold the rewritten MEM_REF trees. */
3749 : 31460 : root->mem_refs->traverse<void *, fold_mem_refs> (NULL);
3750 : :
3751 : : /* Dump the translated tree function. */
3752 : 31460 : if (dump_file)
3753 : : {
3754 : 0 : fputs ("\n\n", dump_file);
3755 : 0 : dump_function_to_file (root->context, dump_file, dump_flags);
3756 : : }
3757 : : }
3758 : :
3759 : : static void
3760 : 8933 : finalize_nesting_tree (struct nesting_info *root)
3761 : : {
3762 : 8933 : struct nesting_info *n;
3763 : 80786 : FOR_EACH_NEST_INFO (n, root)
3764 : 31460 : finalize_nesting_tree_1 (n);
3765 : 8933 : }
3766 : :
3767 : : /* Unnest the nodes and pass them to cgraph. */
3768 : :
3769 : : static void
3770 : 31460 : unnest_nesting_tree_1 (struct nesting_info *root)
3771 : : {
3772 : 31460 : struct cgraph_node *node = cgraph_node::get (root->context);
3773 : :
3774 : : /* For nested functions update the cgraph to reflect unnesting.
3775 : : We also delay finalizing of these functions up to this point. */
3776 : 31460 : if (nested_function_info::get (node)->origin)
3777 : : {
3778 : 22527 : unnest_function (node);
3779 : 22527 : if (!root->thunk_p)
3780 : 22527 : cgraph_node::finalize_function (root->context, true);
3781 : : }
3782 : 31460 : }
3783 : :
3784 : : static void
3785 : 8933 : unnest_nesting_tree (struct nesting_info *root)
3786 : : {
3787 : 8933 : struct nesting_info *n;
3788 : 80786 : FOR_EACH_NEST_INFO (n, root)
3789 : 31460 : unnest_nesting_tree_1 (n);
3790 : 8933 : }
3791 : :
3792 : : /* Free the data structures allocated during this pass. */
3793 : :
3794 : : static void
3795 : 8933 : free_nesting_tree (struct nesting_info *root)
3796 : : {
3797 : 8933 : struct nesting_info *node, *next;
3798 : :
3799 : 8933 : node = iter_nestinfo_start (root);
3800 : 31460 : do
3801 : : {
3802 : 31460 : next = iter_nestinfo_next (node);
3803 : 62920 : delete node->var_map;
3804 : 62920 : delete node->field_map;
3805 : 62920 : delete node->mem_refs;
3806 : 31460 : free (node);
3807 : 31460 : node = next;
3808 : : }
3809 : 31460 : while (node);
3810 : 8933 : }
3811 : :
3812 : : /* Gimplify a function and all its nested functions. */
3813 : : static void
3814 : 31460 : gimplify_all_functions (struct cgraph_node *root)
3815 : : {
3816 : 31460 : struct cgraph_node *iter;
3817 : 31460 : if (!gimple_body (root->decl))
3818 : 22527 : gimplify_function_tree (root->decl);
3819 : 107974 : for (iter = first_nested_function (root); iter;
3820 : 22527 : iter = next_nested_function (iter))
3821 : 22527 : if (!iter->thunk)
3822 : 22527 : gimplify_all_functions (iter);
3823 : 31460 : }
3824 : :
3825 : : /* Main entry point for this pass. Process FNDECL and all of its nested
3826 : : subroutines and turn them into something less tightly bound. */
3827 : :
3828 : : void
3829 : 8933 : lower_nested_functions (tree fndecl)
3830 : : {
3831 : 8933 : struct cgraph_node *cgn;
3832 : 8933 : struct nesting_info *root;
3833 : :
3834 : : /* If there are no nested functions, there's nothing to do. */
3835 : 8933 : cgn = cgraph_node::get (fndecl);
3836 : 17866 : if (!first_nested_function (cgn))
3837 : : return;
3838 : :
3839 : 8933 : gimplify_all_functions (cgn);
3840 : :
3841 : 8933 : set_dump_file (dump_begin (TDI_nested, &dump_flags));
3842 : 8933 : if (dump_file)
3843 : 0 : fprintf (dump_file, "\n;; Function %s\n\n",
3844 : 0 : lang_hooks.decl_printable_name (fndecl, 2));
3845 : :
3846 : 8933 : bitmap_obstack_initialize (&nesting_info_bitmap_obstack);
3847 : 8933 : root = create_nesting_tree (cgn);
3848 : :
3849 : 8933 : walk_all_functions (convert_nonlocal_reference_stmt,
3850 : : convert_nonlocal_reference_op,
3851 : : root);
3852 : 8933 : walk_all_functions (convert_local_reference_stmt,
3853 : : convert_local_reference_op,
3854 : : root);
3855 : 8933 : walk_all_functions (convert_nl_goto_reference, NULL, root);
3856 : 8933 : walk_all_functions (convert_nl_goto_receiver, NULL, root);
3857 : :
3858 : 8933 : convert_all_function_calls (root);
3859 : 8933 : finalize_nesting_tree (root);
3860 : 8933 : unnest_nesting_tree (root);
3861 : :
3862 : 8933 : free_nesting_tree (root);
3863 : 8933 : bitmap_obstack_release (&nesting_info_bitmap_obstack);
3864 : :
3865 : 8933 : if (dump_file)
3866 : : {
3867 : 0 : dump_end (TDI_nested, dump_file);
3868 : 0 : set_dump_file (NULL);
3869 : : }
3870 : : }
3871 : :
3872 : : #include "gt-tree-nested.h"
|
