OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [tree-nested.c] - Blame information for rev 714

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* Nested function decomposition for GIMPLE.
2
   Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
 
5
   This file is part of GCC.
6
 
7
   GCC is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 3, or (at your option)
10
   any later version.
11
 
12
   GCC is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with GCC; see the file COPYING3.  If not see
19
   <http://www.gnu.org/licenses/>.  */
20
 
21
#include "config.h"
22
#include "system.h"
23
#include "coretypes.h"
24
#include "tm.h"
25
#include "tree.h"
26
#include "tm_p.h"
27
#include "function.h"
28
#include "tree-dump.h"
29
#include "tree-inline.h"
30
#include "gimple.h"
31
#include "tree-iterator.h"
32
#include "tree-flow.h"
33
#include "cgraph.h"
34
#include "expr.h"       /* FIXME: For STACK_SAVEAREA_MODE and SAVE_NONLOCAL.  */
35
#include "langhooks.h"
36
#include "pointer-set.h"
37
 
38
 
39
/* The object of this pass is to lower the representation of a set of nested
40
   functions in order to expose all of the gory details of the various
41
   nonlocal references.  We want to do this sooner rather than later, in
42
   order to give us more freedom in emitting all of the functions in question.
43
 
44
   Back in olden times, when gcc was young, we developed an insanely
45
   complicated scheme whereby variables which were referenced nonlocally
46
   were forced to live in the stack of the declaring function, and then
47
   the nested functions magically discovered where these variables were
48
   placed.  In order for this scheme to function properly, it required
49
   that the outer function be partially expanded, then we switch to
50
   compiling the inner function, and once done with those we switch back
51
   to compiling the outer function.  Such delicate ordering requirements
52
   makes it difficult to do whole translation unit optimizations
53
   involving such functions.
54
 
55
   The implementation here is much more direct.  Everything that can be
56
   referenced by an inner function is a member of an explicitly created
57
   structure herein called the "nonlocal frame struct".  The incoming
58
   static chain for a nested function is a pointer to this struct in
59
   the parent.  In this way, we settle on known offsets from a known
60
   base, and so are decoupled from the logic that places objects in the
61
   function's stack frame.  More importantly, we don't have to wait for
62
   that to happen -- since the compilation of the inner function is no
63
   longer tied to a real stack frame, the nonlocal frame struct can be
64
   allocated anywhere.  Which means that the outer function is now
65
   inlinable.
66
 
67
   Theory of operation here is very simple.  Iterate over all the
68
   statements in all the functions (depth first) several times,
69
   allocating structures and fields on demand.  In general we want to
70
   examine inner functions first, so that we can avoid making changes
71
   to outer functions which are unnecessary.
72
 
73
   The order of the passes matters a bit, in that later passes will be
74
   skipped if it is discovered that the functions don't actually interact
75
   at all.  That is, they're nested in the lexical sense but could have
76
   been written as independent functions without change.  */
77
 
78
 
79
struct nesting_info
80
{
81
  struct nesting_info *outer;
82
  struct nesting_info *inner;
83
  struct nesting_info *next;
84
 
85
  struct pointer_map_t *field_map;
86
  struct pointer_map_t *var_map;
87
  struct pointer_set_t *mem_refs;
88
  bitmap suppress_expansion;
89
 
90
  tree context;
91
  tree new_local_var_chain;
92
  tree debug_var_chain;
93
  tree frame_type;
94
  tree frame_decl;
95
  tree chain_field;
96
  tree chain_decl;
97
  tree nl_goto_field;
98
 
99
  bool any_parm_remapped;
100
  bool any_tramp_created;
101
  char static_chain_added;
102
};
103
 
104
 
105
/* Iterate over the nesting tree, starting with ROOT, depth first.  */
106
 
107
static inline struct nesting_info *
108
iter_nestinfo_start (struct nesting_info *root)
109
{
110
  while (root->inner)
111
    root = root->inner;
112
  return root;
113
}
114
 
115
static inline struct nesting_info *
116
iter_nestinfo_next (struct nesting_info *node)
117
{
118
  if (node->next)
119
    return iter_nestinfo_start (node->next);
120
  return node->outer;
121
}
122
 
123
#define FOR_EACH_NEST_INFO(I, ROOT) \
124
  for ((I) = iter_nestinfo_start (ROOT); (I); (I) = iter_nestinfo_next (I))
125
 
126
/* Obstack used for the bitmaps in the struct above.  */
127
static struct bitmap_obstack nesting_info_bitmap_obstack;
128
 
129
 
130
/* We're working in so many different function contexts simultaneously,
131
   that create_tmp_var is dangerous.  Prevent mishap.  */
132
#define create_tmp_var cant_use_create_tmp_var_here_dummy
133
 
134
/* Like create_tmp_var, except record the variable for registration at
135
   the given nesting level.  */
136
 
137
static tree
138
create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix)
139
{
140
  tree tmp_var;
141
 
142
  /* If the type is of variable size or a type which must be created by the
143
     frontend, something is wrong.  Note that we explicitly allow
144
     incomplete types here, since we create them ourselves here.  */
145
  gcc_assert (!TREE_ADDRESSABLE (type));
146
  gcc_assert (!TYPE_SIZE_UNIT (type)
147
              || TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
148
 
149
  tmp_var = create_tmp_var_raw (type, prefix);
150
  DECL_CONTEXT (tmp_var) = info->context;
151
  DECL_CHAIN (tmp_var) = info->new_local_var_chain;
152
  DECL_SEEN_IN_BIND_EXPR_P (tmp_var) = 1;
153
  if (TREE_CODE (type) == COMPLEX_TYPE
154
      || TREE_CODE (type) == VECTOR_TYPE)
155
    DECL_GIMPLE_REG_P (tmp_var) = 1;
156
 
157
  info->new_local_var_chain = tmp_var;
158
 
159
  return tmp_var;
160
}
161
 
162
/* Take the address of EXP to be used within function CONTEXT.
163
   Mark it for addressability as necessary.  */
164
 
165
tree
166
build_addr (tree exp, tree context)
167
{
168
  tree base = exp;
169
  tree save_context;
170
  tree retval;
171
 
172
  while (handled_component_p (base))
173
    base = TREE_OPERAND (base, 0);
174
 
175
  if (DECL_P (base))
176
    TREE_ADDRESSABLE (base) = 1;
177
 
178
  /* Building the ADDR_EXPR will compute a set of properties for
179
     that ADDR_EXPR.  Those properties are unfortunately context
180
     specific, i.e., they are dependent on CURRENT_FUNCTION_DECL.
181
 
182
     Temporarily set CURRENT_FUNCTION_DECL to the desired context,
183
     build the ADDR_EXPR, then restore CURRENT_FUNCTION_DECL.  That
184
     way the properties are for the ADDR_EXPR are computed properly.  */
185
  save_context = current_function_decl;
186
  current_function_decl = context;
187
  retval = build_fold_addr_expr (exp);
188
  current_function_decl = save_context;
189
  return retval;
190
}
191
 
192
/* Insert FIELD into TYPE, sorted by alignment requirements.  */
193
 
194
void
195
insert_field_into_struct (tree type, tree field)
196
{
197
  tree *p;
198
 
199
  DECL_CONTEXT (field) = type;
200
 
201
  for (p = &TYPE_FIELDS (type); *p ; p = &DECL_CHAIN (*p))
202
    if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
203
      break;
204
 
205
  DECL_CHAIN (field) = *p;
206
  *p = field;
207
 
208
  /* Set correct alignment for frame struct type.  */
209
  if (TYPE_ALIGN (type) < DECL_ALIGN (field))
210
    TYPE_ALIGN (type) = DECL_ALIGN (field);
211
}
212
 
213
/* Build or return the RECORD_TYPE that describes the frame state that is
214
   shared between INFO->CONTEXT and its nested functions.  This record will
215
   not be complete until finalize_nesting_tree; up until that point we'll
216
   be adding fields as necessary.
217
 
218
   We also build the DECL that represents this frame in the function.  */
219
 
220
static tree
221
get_frame_type (struct nesting_info *info)
222
{
223
  tree type = info->frame_type;
224
  if (!type)
225
    {
226
      char *name;
227
 
228
      type = make_node (RECORD_TYPE);
229
 
230
      name = concat ("FRAME.",
231
                     IDENTIFIER_POINTER (DECL_NAME (info->context)),
232
                     NULL);
233
      TYPE_NAME (type) = get_identifier (name);
234
      free (name);
235
 
236
      info->frame_type = type;
237
      info->frame_decl = create_tmp_var_for (info, type, "FRAME");
238
 
239
      /* ??? Always make it addressable for now, since it is meant to
240
         be pointed to by the static chain pointer.  This pessimizes
241
         when it turns out that no static chains are needed because
242
         the nested functions referencing non-local variables are not
243
         reachable, but the true pessimization is to create the non-
244
         local frame structure in the first place.  */
245
      TREE_ADDRESSABLE (info->frame_decl) = 1;
246
    }
247
  return type;
248
}
249
 
250
/* Return true if DECL should be referenced by pointer in the non-local
251
   frame structure.  */
252
 
253
static bool
254
use_pointer_in_frame (tree decl)
255
{
256
  if (TREE_CODE (decl) == PARM_DECL)
257
    {
258
      /* It's illegal to copy TREE_ADDRESSABLE, impossible to copy variable
259
         sized decls, and inefficient to copy large aggregates.  Don't bother
260
         moving anything but scalar variables.  */
261
      return AGGREGATE_TYPE_P (TREE_TYPE (decl));
262
    }
263
  else
264
    {
265
      /* Variable sized types make things "interesting" in the frame.  */
266
      return DECL_SIZE (decl) == NULL || !TREE_CONSTANT (DECL_SIZE (decl));
267
    }
268
}
269
 
270
/* Given DECL, a non-locally accessed variable, find or create a field
271
   in the non-local frame structure for the given nesting context.  */
272
 
273
static tree
274
lookup_field_for_decl (struct nesting_info *info, tree decl,
275
                       enum insert_option insert)
276
{
277
  void **slot;
278
 
279
  if (insert == NO_INSERT)
280
    {
281
      slot = pointer_map_contains (info->field_map, decl);
282
      return slot ? (tree) *slot : NULL_TREE;
283
    }
284
 
285
  slot = pointer_map_insert (info->field_map, decl);
286
  if (!*slot)
287
    {
288
      tree field = make_node (FIELD_DECL);
289
      DECL_NAME (field) = DECL_NAME (decl);
290
 
291
      if (use_pointer_in_frame (decl))
292
        {
293
          TREE_TYPE (field) = build_pointer_type (TREE_TYPE (decl));
294
          DECL_ALIGN (field) = TYPE_ALIGN (TREE_TYPE (field));
295
          DECL_NONADDRESSABLE_P (field) = 1;
296
        }
297
      else
298
        {
299
          TREE_TYPE (field) = TREE_TYPE (decl);
300
          DECL_SOURCE_LOCATION (field) = DECL_SOURCE_LOCATION (decl);
301
          DECL_ALIGN (field) = DECL_ALIGN (decl);
302
          DECL_USER_ALIGN (field) = DECL_USER_ALIGN (decl);
303
          TREE_ADDRESSABLE (field) = TREE_ADDRESSABLE (decl);
304
          DECL_NONADDRESSABLE_P (field) = !TREE_ADDRESSABLE (decl);
305
          TREE_THIS_VOLATILE (field) = TREE_THIS_VOLATILE (decl);
306
        }
307
 
308
      insert_field_into_struct (get_frame_type (info), field);
309
      *slot = field;
310
 
311
      if (TREE_CODE (decl) == PARM_DECL)
312
        info->any_parm_remapped = true;
313
    }
314
 
315
  return (tree) *slot;
316
}
317
 
318
/* Build or return the variable that holds the static chain within
319
   INFO->CONTEXT.  This variable may only be used within INFO->CONTEXT.  */
320
 
321
static tree
322
get_chain_decl (struct nesting_info *info)
323
{
324
  tree decl = info->chain_decl;
325
 
326
  if (!decl)
327
    {
328
      tree type;
329
 
330
      type = get_frame_type (info->outer);
331
      type = build_pointer_type (type);
332
 
333
      /* Note that this variable is *not* entered into any BIND_EXPR;
334
         the construction of this variable is handled specially in
335
         expand_function_start and initialize_inlined_parameters.
336
         Note also that it's represented as a parameter.  This is more
337
         close to the truth, since the initial value does come from
338
         the caller.  */
339
      decl = build_decl (DECL_SOURCE_LOCATION (info->context),
340
                         PARM_DECL, create_tmp_var_name ("CHAIN"), type);
341
      DECL_ARTIFICIAL (decl) = 1;
342
      DECL_IGNORED_P (decl) = 1;
343
      TREE_USED (decl) = 1;
344
      DECL_CONTEXT (decl) = info->context;
345
      DECL_ARG_TYPE (decl) = type;
346
 
347
      /* Tell tree-inline.c that we never write to this variable, so
348
         it can copy-prop the replacement value immediately.  */
349
      TREE_READONLY (decl) = 1;
350
 
351
      info->chain_decl = decl;
352
 
353
      if (dump_file
354
          && (dump_flags & TDF_DETAILS)
355
          && !DECL_STATIC_CHAIN (info->context))
356
        fprintf (dump_file, "Setting static-chain for %s\n",
357
                 lang_hooks.decl_printable_name (info->context, 2));
358
 
359
      DECL_STATIC_CHAIN (info->context) = 1;
360
    }
361
  return decl;
362
}
363
 
364
/* Build or return the field within the non-local frame state that holds
365
   the static chain for INFO->CONTEXT.  This is the way to walk back up
366
   multiple nesting levels.  */
367
 
368
static tree
369
get_chain_field (struct nesting_info *info)
370
{
371
  tree field = info->chain_field;
372
 
373
  if (!field)
374
    {
375
      tree type = build_pointer_type (get_frame_type (info->outer));
376
 
377
      field = make_node (FIELD_DECL);
378
      DECL_NAME (field) = get_identifier ("__chain");
379
      TREE_TYPE (field) = type;
380
      DECL_ALIGN (field) = TYPE_ALIGN (type);
381
      DECL_NONADDRESSABLE_P (field) = 1;
382
 
383
      insert_field_into_struct (get_frame_type (info), field);
384
 
385
      info->chain_field = field;
386
 
387
      if (dump_file
388
          && (dump_flags & TDF_DETAILS)
389
          && !DECL_STATIC_CHAIN (info->context))
390
        fprintf (dump_file, "Setting static-chain for %s\n",
391
                 lang_hooks.decl_printable_name (info->context, 2));
392
 
393
      DECL_STATIC_CHAIN (info->context) = 1;
394
    }
395
  return field;
396
}
397
 
398
/* Initialize a new temporary with the GIMPLE_CALL STMT.  */
399
 
400
static tree
401
init_tmp_var_with_call (struct nesting_info *info, gimple_stmt_iterator *gsi,
402
                        gimple call)
403
{
404
  tree t;
405
 
406
  t = create_tmp_var_for (info, gimple_call_return_type (call), NULL);
407
  gimple_call_set_lhs (call, t);
408
  if (! gsi_end_p (*gsi))
409
    gimple_set_location (call, gimple_location (gsi_stmt (*gsi)));
410
  gsi_insert_before (gsi, call, GSI_SAME_STMT);
411
 
412
  return t;
413
}
414
 
415
 
416
/* Copy EXP into a temporary.  Allocate the temporary in the context of
417
   INFO and insert the initialization statement before GSI.  */
418
 
419
static tree
420
init_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
421
{
422
  tree t;
423
  gimple stmt;
424
 
425
  t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
426
  stmt = gimple_build_assign (t, exp);
427
  if (! gsi_end_p (*gsi))
428
    gimple_set_location (stmt, gimple_location (gsi_stmt (*gsi)));
429
  gsi_insert_before_without_update (gsi, stmt, GSI_SAME_STMT);
430
 
431
  return t;
432
}
433
 
434
 
435
/* Similarly, but only do so to force EXP to satisfy is_gimple_val.  */
436
 
437
static tree
438
gsi_gimplify_val (struct nesting_info *info, tree exp,
439
                  gimple_stmt_iterator *gsi)
440
{
441
  if (is_gimple_val (exp))
442
    return exp;
443
  else
444
    return init_tmp_var (info, exp, gsi);
445
}
446
 
447
/* Similarly, but copy from the temporary and insert the statement
448
   after the iterator.  */
449
 
450
static tree
451
save_tmp_var (struct nesting_info *info, tree exp, gimple_stmt_iterator *gsi)
452
{
453
  tree t;
454
  gimple stmt;
455
 
456
  t = create_tmp_var_for (info, TREE_TYPE (exp), NULL);
457
  stmt = gimple_build_assign (exp, t);
458
  if (! gsi_end_p (*gsi))
459
    gimple_set_location (stmt, gimple_location (gsi_stmt (*gsi)));
460
  gsi_insert_after_without_update (gsi, stmt, GSI_SAME_STMT);
461
 
462
  return t;
463
}
464
 
465
/* Build or return the type used to represent a nested function trampoline.  */
466
 
467
static GTY(()) tree trampoline_type;
468
 
469
static tree
470
get_trampoline_type (struct nesting_info *info)
471
{
472
  unsigned align, size;
473
  tree t;
474
 
475
  if (trampoline_type)
476
    return trampoline_type;
477
 
478
  align = TRAMPOLINE_ALIGNMENT;
479
  size = TRAMPOLINE_SIZE;
480
 
481
  /* If we won't be able to guarantee alignment simply via TYPE_ALIGN,
482
     then allocate extra space so that we can do dynamic alignment.  */
483
  if (align > STACK_BOUNDARY)
484
    {
485
      size += ((align/BITS_PER_UNIT) - 1) & -(STACK_BOUNDARY/BITS_PER_UNIT);
486
      align = STACK_BOUNDARY;
487
    }
488
 
489
  t = build_index_type (size_int (size - 1));
490
  t = build_array_type (char_type_node, t);
491
  t = build_decl (DECL_SOURCE_LOCATION (info->context),
492
                  FIELD_DECL, get_identifier ("__data"), t);
493
  DECL_ALIGN (t) = align;
494
  DECL_USER_ALIGN (t) = 1;
495
 
496
  trampoline_type = make_node (RECORD_TYPE);
497
  TYPE_NAME (trampoline_type) = get_identifier ("__builtin_trampoline");
498
  TYPE_FIELDS (trampoline_type) = t;
499
  layout_type (trampoline_type);
500
  DECL_CONTEXT (t) = trampoline_type;
501
 
502
  return trampoline_type;
503
}
504
 
505
/* Given DECL, a nested function, find or create a field in the non-local
506
   frame structure for a trampoline for this function.  */
507
 
508
static tree
509
lookup_tramp_for_decl (struct nesting_info *info, tree decl,
510
                       enum insert_option insert)
511
{
512
  void **slot;
513
 
514
  if (insert == NO_INSERT)
515
    {
516
      slot = pointer_map_contains (info->var_map, decl);
517
      return slot ? (tree) *slot : NULL_TREE;
518
    }
519
 
520
  slot = pointer_map_insert (info->var_map, decl);
521
  if (!*slot)
522
    {
523
      tree field = make_node (FIELD_DECL);
524
      DECL_NAME (field) = DECL_NAME (decl);
525
      TREE_TYPE (field) = get_trampoline_type (info);
526
      TREE_ADDRESSABLE (field) = 1;
527
 
528
      insert_field_into_struct (get_frame_type (info), field);
529
      *slot = field;
530
 
531
      info->any_tramp_created = true;
532
    }
533
 
534
  return (tree) *slot;
535
}
536
 
537
/* Build or return the field within the non-local frame state that holds
538
   the non-local goto "jmp_buf".  The buffer itself is maintained by the
539
   rtl middle-end as dynamic stack space is allocated.  */
540
 
541
static tree
542
get_nl_goto_field (struct nesting_info *info)
543
{
544
  tree field = info->nl_goto_field;
545
  if (!field)
546
    {
547
      unsigned size;
548
      tree type;
549
 
550
      /* For __builtin_nonlocal_goto, we need N words.  The first is the
551
         frame pointer, the rest is for the target's stack pointer save
552
         area.  The number of words is controlled by STACK_SAVEAREA_MODE;
553
         not the best interface, but it'll do for now.  */
554
      if (Pmode == ptr_mode)
555
        type = ptr_type_node;
556
      else
557
        type = lang_hooks.types.type_for_mode (Pmode, 1);
558
 
559
      size = GET_MODE_SIZE (STACK_SAVEAREA_MODE (SAVE_NONLOCAL));
560
      size = size / GET_MODE_SIZE (Pmode);
561
      size = size + 1;
562
 
563
      type = build_array_type
564
        (type, build_index_type (size_int (size)));
565
 
566
      field = make_node (FIELD_DECL);
567
      DECL_NAME (field) = get_identifier ("__nl_goto_buf");
568
      TREE_TYPE (field) = type;
569
      DECL_ALIGN (field) = TYPE_ALIGN (type);
570
      TREE_ADDRESSABLE (field) = 1;
571
 
572
      insert_field_into_struct (get_frame_type (info), field);
573
 
574
      info->nl_goto_field = field;
575
    }
576
 
577
  return field;
578
}
579
 
580
/* Invoke CALLBACK on all statements of GIMPLE sequence SEQ.  */
581
 
582
static void
583
walk_body (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
584
           struct nesting_info *info, gimple_seq seq)
585
{
586
  struct walk_stmt_info wi;
587
 
588
  memset (&wi, 0, sizeof (wi));
589
  wi.info = info;
590
  wi.val_only = true;
591
  walk_gimple_seq (seq, callback_stmt, callback_op, &wi);
592
}
593
 
594
 
595
/* Invoke CALLBACK_STMT/CALLBACK_OP on all statements of INFO->CONTEXT.  */
596
 
597
static inline void
598
walk_function (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
599
               struct nesting_info *info)
600
{
601
  walk_body (callback_stmt, callback_op, info, gimple_body (info->context));
602
}
603
 
604
/* Invoke CALLBACK on a GIMPLE_OMP_FOR's init, cond, incr and pre-body.  */
605
 
606
static void
607
walk_gimple_omp_for (gimple for_stmt,
608
                     walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
609
                     struct nesting_info *info)
610
{
611
  struct walk_stmt_info wi;
612
  gimple_seq seq;
613
  tree t;
614
  size_t i;
615
 
616
  walk_body (callback_stmt, callback_op, info, gimple_omp_for_pre_body (for_stmt));
617
 
618
  seq = gimple_seq_alloc ();
619
  memset (&wi, 0, sizeof (wi));
620
  wi.info = info;
621
  wi.gsi = gsi_last (seq);
622
 
623
  for (i = 0; i < gimple_omp_for_collapse (for_stmt); i++)
624
    {
625
      wi.val_only = false;
626
      walk_tree (gimple_omp_for_index_ptr (for_stmt, i), callback_op,
627
                 &wi, NULL);
628
      wi.val_only = true;
629
      wi.is_lhs = false;
630
      walk_tree (gimple_omp_for_initial_ptr (for_stmt, i), callback_op,
631
                 &wi, NULL);
632
 
633
      wi.val_only = true;
634
      wi.is_lhs = false;
635
      walk_tree (gimple_omp_for_final_ptr (for_stmt, i), callback_op,
636
                 &wi, NULL);
637
 
638
      t = gimple_omp_for_incr (for_stmt, i);
639
      gcc_assert (BINARY_CLASS_P (t));
640
      wi.val_only = false;
641
      walk_tree (&TREE_OPERAND (t, 0), callback_op, &wi, NULL);
642
      wi.val_only = true;
643
      wi.is_lhs = false;
644
      walk_tree (&TREE_OPERAND (t, 1), callback_op, &wi, NULL);
645
    }
646
 
647
  if (gimple_seq_empty_p (seq))
648
    gimple_seq_free (seq);
649
  else
650
    {
651
      gimple_seq pre_body = gimple_omp_for_pre_body (for_stmt);
652
      annotate_all_with_location (seq, gimple_location (for_stmt));
653
      gimple_seq_add_seq (&pre_body, seq);
654
      gimple_omp_for_set_pre_body (for_stmt, pre_body);
655
    }
656
}
657
 
658
/* Similarly for ROOT and all functions nested underneath, depth first.  */
659
 
660
static void
661
walk_all_functions (walk_stmt_fn callback_stmt, walk_tree_fn callback_op,
662
                    struct nesting_info *root)
663
{
664
  struct nesting_info *n;
665
  FOR_EACH_NEST_INFO (n, root)
666
    walk_function (callback_stmt, callback_op, n);
667
}
668
 
669
 
670
/* We have to check for a fairly pathological case.  The operands of function
671
   nested function are to be interpreted in the context of the enclosing
672
   function.  So if any are variably-sized, they will get remapped when the
673
   enclosing function is inlined.  But that remapping would also have to be
674
   done in the types of the PARM_DECLs of the nested function, meaning the
675
   argument types of that function will disagree with the arguments in the
676
   calls to that function.  So we'd either have to make a copy of the nested
677
   function corresponding to each time the enclosing function was inlined or
678
   add a VIEW_CONVERT_EXPR to each such operand for each call to the nested
679
   function.  The former is not practical.  The latter would still require
680
   detecting this case to know when to add the conversions.  So, for now at
681
   least, we don't inline such an enclosing function.
682
 
683
   We have to do that check recursively, so here return indicating whether
684
   FNDECL has such a nested function.  ORIG_FN is the function we were
685
   trying to inline to use for checking whether any argument is variably
686
   modified by anything in it.
687
 
688
   It would be better to do this in tree-inline.c so that we could give
689
   the appropriate warning for why a function can't be inlined, but that's
690
   too late since the nesting structure has already been flattened and
691
   adding a flag just to record this fact seems a waste of a flag.  */
692
 
693
static bool
694
check_for_nested_with_variably_modified (tree fndecl, tree orig_fndecl)
695
{
696
  struct cgraph_node *cgn = cgraph_get_node (fndecl);
697
  tree arg;
698
 
699
  for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
700
    {
701
      for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = DECL_CHAIN (arg))
702
        if (variably_modified_type_p (TREE_TYPE (arg), orig_fndecl))
703
          return true;
704
 
705
      if (check_for_nested_with_variably_modified (cgn->decl, orig_fndecl))
706
        return true;
707
    }
708
 
709
  return false;
710
}
711
 
712
/* Construct our local datastructure describing the function nesting
713
   tree rooted by CGN.  */
714
 
715
static struct nesting_info *
716
create_nesting_tree (struct cgraph_node *cgn)
717
{
718
  struct nesting_info *info = XCNEW (struct nesting_info);
719
  info->field_map = pointer_map_create ();
720
  info->var_map = pointer_map_create ();
721
  info->mem_refs = pointer_set_create ();
722
  info->suppress_expansion = BITMAP_ALLOC (&nesting_info_bitmap_obstack);
723
  info->context = cgn->decl;
724
 
725
  for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
726
    {
727
      struct nesting_info *sub = create_nesting_tree (cgn);
728
      sub->outer = info;
729
      sub->next = info->inner;
730
      info->inner = sub;
731
    }
732
 
733
  /* See discussion at check_for_nested_with_variably_modified for a
734
     discussion of why this has to be here.  */
735
  if (check_for_nested_with_variably_modified (info->context, info->context))
736
    DECL_UNINLINABLE (info->context) = true;
737
 
738
  return info;
739
}
740
 
741
/* Return an expression computing the static chain for TARGET_CONTEXT
742
   from INFO->CONTEXT.  Insert any necessary computations before TSI.  */
743
 
744
static tree
745
get_static_chain (struct nesting_info *info, tree target_context,
746
                  gimple_stmt_iterator *gsi)
747
{
748
  struct nesting_info *i;
749
  tree x;
750
 
751
  if (info->context == target_context)
752
    {
753
      x = build_addr (info->frame_decl, target_context);
754
    }
755
  else
756
    {
757
      x = get_chain_decl (info);
758
 
759
      for (i = info->outer; i->context != target_context; i = i->outer)
760
        {
761
          tree field = get_chain_field (i);
762
 
763
          x = build_simple_mem_ref (x);
764
          x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
765
          x = init_tmp_var (info, x, gsi);
766
        }
767
    }
768
 
769
  return x;
770
}
771
 
772
 
773
/* Return an expression referencing FIELD from TARGET_CONTEXT's non-local
774
   frame as seen from INFO->CONTEXT.  Insert any necessary computations
775
   before GSI.  */
776
 
777
static tree
778
get_frame_field (struct nesting_info *info, tree target_context,
779
                 tree field, gimple_stmt_iterator *gsi)
780
{
781
  struct nesting_info *i;
782
  tree x;
783
 
784
  if (info->context == target_context)
785
    {
786
      /* Make sure frame_decl gets created.  */
787
      (void) get_frame_type (info);
788
      x = info->frame_decl;
789
    }
790
  else
791
    {
792
      x = get_chain_decl (info);
793
 
794
      for (i = info->outer; i->context != target_context; i = i->outer)
795
        {
796
          tree field = get_chain_field (i);
797
 
798
          x = build_simple_mem_ref (x);
799
          x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
800
          x = init_tmp_var (info, x, gsi);
801
        }
802
 
803
      x = build_simple_mem_ref (x);
804
    }
805
 
806
  x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
807
  return x;
808
}
809
 
810
static void note_nonlocal_vla_type (struct nesting_info *info, tree type);
811
 
812
/* A subroutine of convert_nonlocal_reference_op.  Create a local variable
813
   in the nested function with DECL_VALUE_EXPR set to reference the true
814
   variable in the parent function.  This is used both for debug info
815
   and in OpenMP lowering.  */
816
 
817
static tree
818
get_nonlocal_debug_decl (struct nesting_info *info, tree decl)
819
{
820
  tree target_context;
821
  struct nesting_info *i;
822
  tree x, field, new_decl;
823
  void **slot;
824
 
825
  slot = pointer_map_insert (info->var_map, decl);
826
 
827
  if (*slot)
828
    return (tree) *slot;
829
 
830
  target_context = decl_function_context (decl);
831
 
832
  /* A copy of the code in get_frame_field, but without the temporaries.  */
833
  if (info->context == target_context)
834
    {
835
      /* Make sure frame_decl gets created.  */
836
      (void) get_frame_type (info);
837
      x = info->frame_decl;
838
      i = info;
839
    }
840
  else
841
    {
842
      x = get_chain_decl (info);
843
      for (i = info->outer; i->context != target_context; i = i->outer)
844
        {
845
          field = get_chain_field (i);
846
          x = build_simple_mem_ref (x);
847
          x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
848
        }
849
      x = build_simple_mem_ref (x);
850
    }
851
 
852
  field = lookup_field_for_decl (i, decl, INSERT);
853
  x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
854
  if (use_pointer_in_frame (decl))
855
    x = build_simple_mem_ref (x);
856
 
857
  /* ??? We should be remapping types as well, surely.  */
858
  new_decl = build_decl (DECL_SOURCE_LOCATION (decl),
859
                         VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
860
  DECL_CONTEXT (new_decl) = info->context;
861
  DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
862
  DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
863
  TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
864
  TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
865
  TREE_READONLY (new_decl) = TREE_READONLY (decl);
866
  TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
867
  DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
868
  if ((TREE_CODE (decl) == PARM_DECL
869
       || TREE_CODE (decl) == RESULT_DECL
870
       || TREE_CODE (decl) == VAR_DECL)
871
      && DECL_BY_REFERENCE (decl))
872
    DECL_BY_REFERENCE (new_decl) = 1;
873
 
874
  SET_DECL_VALUE_EXPR (new_decl, x);
875
  DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
876
 
877
  *slot = new_decl;
878
  DECL_CHAIN (new_decl) = info->debug_var_chain;
879
  info->debug_var_chain = new_decl;
880
 
881
  if (!optimize
882
      && info->context != target_context
883
      && variably_modified_type_p (TREE_TYPE (decl), NULL))
884
    note_nonlocal_vla_type (info, TREE_TYPE (decl));
885
 
886
  return new_decl;
887
}
888
 
889
 
890
/* Callback for walk_gimple_stmt, rewrite all references to VAR
891
   and PARM_DECLs that belong to outer functions.
892
 
893
   The rewrite will involve some number of structure accesses back up
894
   the static chain.  E.g. for a variable FOO up one nesting level it'll
895
   be CHAIN->FOO.  For two levels it'll be CHAIN->__chain->FOO.  Further
896
   indirections apply to decls for which use_pointer_in_frame is true.  */
897
 
898
static tree
899
convert_nonlocal_reference_op (tree *tp, int *walk_subtrees, void *data)
900
{
901
  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
902
  struct nesting_info *const info = (struct nesting_info *) wi->info;
903
  tree t = *tp;
904
 
905
  *walk_subtrees = 0;
906
  switch (TREE_CODE (t))
907
    {
908
    case VAR_DECL:
909
      /* Non-automatic variables are never processed.  */
910
      if (TREE_STATIC (t) || DECL_EXTERNAL (t))
911
        break;
912
      /* FALLTHRU */
913
 
914
    case PARM_DECL:
915
      if (decl_function_context (t) != info->context)
916
        {
917
          tree x;
918
          wi->changed = true;
919
 
920
          x = get_nonlocal_debug_decl (info, t);
921
          if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
922
            {
923
              tree target_context = decl_function_context (t);
924
              struct nesting_info *i;
925
              for (i = info->outer; i->context != target_context; i = i->outer)
926
                continue;
927
              x = lookup_field_for_decl (i, t, INSERT);
928
              x = get_frame_field (info, target_context, x, &wi->gsi);
929
              if (use_pointer_in_frame (t))
930
                {
931
                  x = init_tmp_var (info, x, &wi->gsi);
932
                  x = build_simple_mem_ref (x);
933
                }
934
            }
935
 
936
          if (wi->val_only)
937
            {
938
              if (wi->is_lhs)
939
                x = save_tmp_var (info, x, &wi->gsi);
940
              else
941
                x = init_tmp_var (info, x, &wi->gsi);
942
            }
943
 
944
          *tp = x;
945
        }
946
      break;
947
 
948
    case LABEL_DECL:
949
      /* We're taking the address of a label from a parent function, but
950
         this is not itself a non-local goto.  Mark the label such that it
951
         will not be deleted, much as we would with a label address in
952
         static storage.  */
953
      if (decl_function_context (t) != info->context)
954
        FORCED_LABEL (t) = 1;
955
      break;
956
 
957
    case ADDR_EXPR:
958
      {
959
        bool save_val_only = wi->val_only;
960
 
961
        wi->val_only = false;
962
        wi->is_lhs = false;
963
        wi->changed = false;
964
        walk_tree (&TREE_OPERAND (t, 0), convert_nonlocal_reference_op, wi, 0);
965
        wi->val_only = true;
966
 
967
        if (wi->changed)
968
          {
969
            tree save_context;
970
 
971
            /* If we changed anything, we might no longer be directly
972
               referencing a decl.  */
973
            save_context = current_function_decl;
974
            current_function_decl = info->context;
975
            recompute_tree_invariant_for_addr_expr (t);
976
            current_function_decl = save_context;
977
 
978
            /* If the callback converted the address argument in a context
979
               where we only accept variables (and min_invariant, presumably),
980
               then compute the address into a temporary.  */
981
            if (save_val_only)
982
              *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
983
                                      t, &wi->gsi);
984
          }
985
      }
986
      break;
987
 
988
    case REALPART_EXPR:
989
    case IMAGPART_EXPR:
990
    case COMPONENT_REF:
991
    case ARRAY_REF:
992
    case ARRAY_RANGE_REF:
993
    case BIT_FIELD_REF:
994
      /* Go down this entire nest and just look at the final prefix and
995
         anything that describes the references.  Otherwise, we lose track
996
         of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
997
      wi->val_only = true;
998
      wi->is_lhs = false;
999
      for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1000
        {
1001
          if (TREE_CODE (t) == COMPONENT_REF)
1002
            walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op, wi,
1003
                       NULL);
1004
          else if (TREE_CODE (t) == ARRAY_REF
1005
                   || TREE_CODE (t) == ARRAY_RANGE_REF)
1006
            {
1007
              walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference_op,
1008
                         wi, NULL);
1009
              walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op,
1010
                         wi, NULL);
1011
              walk_tree (&TREE_OPERAND (t, 3), convert_nonlocal_reference_op,
1012
                         wi, NULL);
1013
            }
1014
          else if (TREE_CODE (t) == BIT_FIELD_REF)
1015
            {
1016
              walk_tree (&TREE_OPERAND (t, 1), convert_nonlocal_reference_op,
1017
                         wi, NULL);
1018
              walk_tree (&TREE_OPERAND (t, 2), convert_nonlocal_reference_op,
1019
                         wi, NULL);
1020
            }
1021
        }
1022
      wi->val_only = false;
1023
      walk_tree (tp, convert_nonlocal_reference_op, wi, NULL);
1024
      break;
1025
 
1026
    case VIEW_CONVERT_EXPR:
1027
      /* Just request to look at the subtrees, leaving val_only and lhs
1028
         untouched.  This might actually be for !val_only + lhs, in which
1029
         case we don't want to force a replacement by a temporary.  */
1030
      *walk_subtrees = 1;
1031
      break;
1032
 
1033
    default:
1034
      if (!IS_TYPE_OR_DECL_P (t))
1035
        {
1036
          *walk_subtrees = 1;
1037
          wi->val_only = true;
1038
          wi->is_lhs = false;
1039
        }
1040
      break;
1041
    }
1042
 
1043
  return NULL_TREE;
1044
}
1045
 
1046
static tree convert_nonlocal_reference_stmt (gimple_stmt_iterator *, bool *,
1047
                                             struct walk_stmt_info *);
1048
 
1049
/* Helper for convert_nonlocal_references, rewrite all references to VAR
1050
   and PARM_DECLs that belong to outer functions.  */
1051
 
1052
static bool
1053
convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1054
{
1055
  struct nesting_info *const info = (struct nesting_info *) wi->info;
1056
  bool need_chain = false, need_stmts = false;
1057
  tree clause, decl;
1058
  int dummy;
1059
  bitmap new_suppress;
1060
 
1061
  new_suppress = BITMAP_GGC_ALLOC ();
1062
  bitmap_copy (new_suppress, info->suppress_expansion);
1063
 
1064
  for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1065
    {
1066
      switch (OMP_CLAUSE_CODE (clause))
1067
        {
1068
        case OMP_CLAUSE_REDUCTION:
1069
          if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1070
            need_stmts = true;
1071
          goto do_decl_clause;
1072
 
1073
        case OMP_CLAUSE_LASTPRIVATE:
1074
          if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
1075
            need_stmts = true;
1076
          goto do_decl_clause;
1077
 
1078
        case OMP_CLAUSE_PRIVATE:
1079
        case OMP_CLAUSE_FIRSTPRIVATE:
1080
        case OMP_CLAUSE_COPYPRIVATE:
1081
        case OMP_CLAUSE_SHARED:
1082
        do_decl_clause:
1083
          decl = OMP_CLAUSE_DECL (clause);
1084
          if (TREE_CODE (decl) == VAR_DECL
1085
              && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1086
            break;
1087
          if (decl_function_context (decl) != info->context)
1088
            {
1089
              bitmap_set_bit (new_suppress, DECL_UID (decl));
1090
              OMP_CLAUSE_DECL (clause) = get_nonlocal_debug_decl (info, decl);
1091
              if (OMP_CLAUSE_CODE (clause) != OMP_CLAUSE_PRIVATE)
1092
                need_chain = true;
1093
            }
1094
          break;
1095
 
1096
        case OMP_CLAUSE_SCHEDULE:
1097
          if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1098
            break;
1099
          /* FALLTHRU */
1100
        case OMP_CLAUSE_FINAL:
1101
        case OMP_CLAUSE_IF:
1102
        case OMP_CLAUSE_NUM_THREADS:
1103
          wi->val_only = true;
1104
          wi->is_lhs = false;
1105
          convert_nonlocal_reference_op (&OMP_CLAUSE_OPERAND (clause, 0),
1106
                                         &dummy, wi);
1107
          break;
1108
 
1109
        case OMP_CLAUSE_NOWAIT:
1110
        case OMP_CLAUSE_ORDERED:
1111
        case OMP_CLAUSE_DEFAULT:
1112
        case OMP_CLAUSE_COPYIN:
1113
        case OMP_CLAUSE_COLLAPSE:
1114
        case OMP_CLAUSE_UNTIED:
1115
        case OMP_CLAUSE_MERGEABLE:
1116
          break;
1117
 
1118
        default:
1119
          gcc_unreachable ();
1120
        }
1121
    }
1122
 
1123
  info->suppress_expansion = new_suppress;
1124
 
1125
  if (need_stmts)
1126
    for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1127
      switch (OMP_CLAUSE_CODE (clause))
1128
        {
1129
        case OMP_CLAUSE_REDUCTION:
1130
          if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1131
            {
1132
              tree old_context
1133
                = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1134
              DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1135
                = info->context;
1136
              walk_body (convert_nonlocal_reference_stmt,
1137
                         convert_nonlocal_reference_op, info,
1138
                         OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
1139
              walk_body (convert_nonlocal_reference_stmt,
1140
                         convert_nonlocal_reference_op, info,
1141
                         OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
1142
              DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1143
                = old_context;
1144
            }
1145
          break;
1146
 
1147
        case OMP_CLAUSE_LASTPRIVATE:
1148
          walk_body (convert_nonlocal_reference_stmt,
1149
                     convert_nonlocal_reference_op, info,
1150
                     OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
1151
          break;
1152
 
1153
        default:
1154
          break;
1155
        }
1156
 
1157
  return need_chain;
1158
}
1159
 
1160
/* Create nonlocal debug decls for nonlocal VLA array bounds.  */
1161
 
1162
static void
1163
note_nonlocal_vla_type (struct nesting_info *info, tree type)
1164
{
1165
  while (POINTER_TYPE_P (type) && !TYPE_NAME (type))
1166
    type = TREE_TYPE (type);
1167
 
1168
  if (TYPE_NAME (type)
1169
      && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1170
      && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1171
    type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1172
 
1173
  while (POINTER_TYPE_P (type)
1174
         || TREE_CODE (type) == VECTOR_TYPE
1175
         || TREE_CODE (type) == FUNCTION_TYPE
1176
         || TREE_CODE (type) == METHOD_TYPE)
1177
    type = TREE_TYPE (type);
1178
 
1179
  if (TREE_CODE (type) == ARRAY_TYPE)
1180
    {
1181
      tree domain, t;
1182
 
1183
      note_nonlocal_vla_type (info, TREE_TYPE (type));
1184
      domain = TYPE_DOMAIN (type);
1185
      if (domain)
1186
        {
1187
          t = TYPE_MIN_VALUE (domain);
1188
          if (t && (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
1189
              && decl_function_context (t) != info->context)
1190
            get_nonlocal_debug_decl (info, t);
1191
          t = TYPE_MAX_VALUE (domain);
1192
          if (t && (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL)
1193
              && decl_function_context (t) != info->context)
1194
            get_nonlocal_debug_decl (info, t);
1195
        }
1196
    }
1197
}
1198
 
1199
/* Create nonlocal debug decls for nonlocal VLA array bounds for VLAs
1200
   in BLOCK.  */
1201
 
1202
static void
1203
note_nonlocal_block_vlas (struct nesting_info *info, tree block)
1204
{
1205
  tree var;
1206
 
1207
  for (var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
1208
    if (TREE_CODE (var) == VAR_DECL
1209
        && variably_modified_type_p (TREE_TYPE (var), NULL)
1210
        && DECL_HAS_VALUE_EXPR_P (var)
1211
        && decl_function_context (var) != info->context)
1212
      note_nonlocal_vla_type (info, TREE_TYPE (var));
1213
}
1214
 
1215
/* Callback for walk_gimple_stmt.  Rewrite all references to VAR and
1216
   PARM_DECLs that belong to outer functions.  This handles statements
1217
   that are not handled via the standard recursion done in
1218
   walk_gimple_stmt.  STMT is the statement to examine, DATA is as in
1219
   convert_nonlocal_reference_op.  Set *HANDLED_OPS_P to true if all the
1220
   operands of STMT have been handled by this function.  */
1221
 
1222
static tree
1223
convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1224
                                 struct walk_stmt_info *wi)
1225
{
1226
  struct nesting_info *info = (struct nesting_info *) wi->info;
1227
  tree save_local_var_chain;
1228
  bitmap save_suppress;
1229
  gimple stmt = gsi_stmt (*gsi);
1230
 
1231
  switch (gimple_code (stmt))
1232
    {
1233
    case GIMPLE_GOTO:
1234
      /* Don't walk non-local gotos for now.  */
1235
      if (TREE_CODE (gimple_goto_dest (stmt)) != LABEL_DECL)
1236
        {
1237
          wi->val_only = true;
1238
          wi->is_lhs = false;
1239
          *handled_ops_p = true;
1240
          return NULL_TREE;
1241
        }
1242
      break;
1243
 
1244
    case GIMPLE_OMP_PARALLEL:
1245
    case GIMPLE_OMP_TASK:
1246
      save_suppress = info->suppress_expansion;
1247
      if (convert_nonlocal_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
1248
                                        wi))
1249
        {
1250
          tree c, decl;
1251
          decl = get_chain_decl (info);
1252
          c = build_omp_clause (gimple_location (stmt),
1253
                                OMP_CLAUSE_FIRSTPRIVATE);
1254
          OMP_CLAUSE_DECL (c) = decl;
1255
          OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
1256
          gimple_omp_taskreg_set_clauses (stmt, c);
1257
        }
1258
 
1259
      save_local_var_chain = info->new_local_var_chain;
1260
      info->new_local_var_chain = NULL;
1261
 
1262
      walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1263
                 info, gimple_omp_body (stmt));
1264
 
1265
      if (info->new_local_var_chain)
1266
        declare_vars (info->new_local_var_chain,
1267
                      gimple_seq_first_stmt (gimple_omp_body (stmt)),
1268
                      false);
1269
      info->new_local_var_chain = save_local_var_chain;
1270
      info->suppress_expansion = save_suppress;
1271
      break;
1272
 
1273
    case GIMPLE_OMP_FOR:
1274
      save_suppress = info->suppress_expansion;
1275
      convert_nonlocal_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
1276
      walk_gimple_omp_for (stmt, convert_nonlocal_reference_stmt,
1277
                           convert_nonlocal_reference_op, info);
1278
      walk_body (convert_nonlocal_reference_stmt,
1279
                 convert_nonlocal_reference_op, info, gimple_omp_body (stmt));
1280
      info->suppress_expansion = save_suppress;
1281
      break;
1282
 
1283
    case GIMPLE_OMP_SECTIONS:
1284
      save_suppress = info->suppress_expansion;
1285
      convert_nonlocal_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
1286
      walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1287
                 info, gimple_omp_body (stmt));
1288
      info->suppress_expansion = save_suppress;
1289
      break;
1290
 
1291
    case GIMPLE_OMP_SINGLE:
1292
      save_suppress = info->suppress_expansion;
1293
      convert_nonlocal_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
1294
      walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1295
                 info, gimple_omp_body (stmt));
1296
      info->suppress_expansion = save_suppress;
1297
      break;
1298
 
1299
    case GIMPLE_OMP_SECTION:
1300
    case GIMPLE_OMP_MASTER:
1301
    case GIMPLE_OMP_ORDERED:
1302
      walk_body (convert_nonlocal_reference_stmt, convert_nonlocal_reference_op,
1303
                 info, gimple_omp_body (stmt));
1304
      break;
1305
 
1306
    case GIMPLE_BIND:
1307
      if (!optimize && gimple_bind_block (stmt))
1308
        note_nonlocal_block_vlas (info, gimple_bind_block (stmt));
1309
 
1310
      *handled_ops_p = false;
1311
      return NULL_TREE;
1312
 
1313
    case GIMPLE_COND:
1314
      wi->val_only = true;
1315
      wi->is_lhs = false;
1316
      *handled_ops_p = false;
1317
      return NULL_TREE;
1318
 
1319
    default:
1320
      /* For every other statement that we are not interested in
1321
         handling here, let the walker traverse the operands.  */
1322
      *handled_ops_p = false;
1323
      return NULL_TREE;
1324
    }
1325
 
1326
  /* We have handled all of STMT operands, no need to traverse the operands.  */
1327
  *handled_ops_p = true;
1328
  return NULL_TREE;
1329
}
1330
 
1331
 
1332
/* A subroutine of convert_local_reference.  Create a local variable
1333
   in the parent function with DECL_VALUE_EXPR set to reference the
1334
   field in FRAME.  This is used both for debug info and in OpenMP
1335
   lowering.  */
1336
 
1337
static tree
1338
get_local_debug_decl (struct nesting_info *info, tree decl, tree field)
1339
{
1340
  tree x, new_decl;
1341
  void **slot;
1342
 
1343
  slot = pointer_map_insert (info->var_map, decl);
1344
  if (*slot)
1345
    return (tree) *slot;
1346
 
1347
  /* Make sure frame_decl gets created.  */
1348
  (void) get_frame_type (info);
1349
  x = info->frame_decl;
1350
  x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
1351
 
1352
  new_decl = build_decl (DECL_SOURCE_LOCATION (decl),
1353
                         VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
1354
  DECL_CONTEXT (new_decl) = info->context;
1355
  DECL_ARTIFICIAL (new_decl) = DECL_ARTIFICIAL (decl);
1356
  DECL_IGNORED_P (new_decl) = DECL_IGNORED_P (decl);
1357
  TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (decl);
1358
  TREE_SIDE_EFFECTS (new_decl) = TREE_SIDE_EFFECTS (decl);
1359
  TREE_READONLY (new_decl) = TREE_READONLY (decl);
1360
  TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (decl);
1361
  DECL_SEEN_IN_BIND_EXPR_P (new_decl) = 1;
1362
  if ((TREE_CODE (decl) == PARM_DECL
1363
       || TREE_CODE (decl) == RESULT_DECL
1364
       || TREE_CODE (decl) == VAR_DECL)
1365
      && DECL_BY_REFERENCE (decl))
1366
    DECL_BY_REFERENCE (new_decl) = 1;
1367
 
1368
  SET_DECL_VALUE_EXPR (new_decl, x);
1369
  DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
1370
  *slot = new_decl;
1371
 
1372
  DECL_CHAIN (new_decl) = info->debug_var_chain;
1373
  info->debug_var_chain = new_decl;
1374
 
1375
  /* Do not emit debug info twice.  */
1376
  DECL_IGNORED_P (decl) = 1;
1377
 
1378
  return new_decl;
1379
}
1380
 
1381
 
1382
/* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1383
   and PARM_DECLs that were referenced by inner nested functions.
1384
   The rewrite will be a structure reference to the local frame variable.  */
1385
 
1386
static bool convert_local_omp_clauses (tree *, struct walk_stmt_info *);
1387
 
1388
static tree
1389
convert_local_reference_op (tree *tp, int *walk_subtrees, void *data)
1390
{
1391
  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1392
  struct nesting_info *const info = (struct nesting_info *) wi->info;
1393
  tree t = *tp, field, x;
1394
  bool save_val_only;
1395
 
1396
  *walk_subtrees = 0;
1397
  switch (TREE_CODE (t))
1398
    {
1399
    case VAR_DECL:
1400
      /* Non-automatic variables are never processed.  */
1401
      if (TREE_STATIC (t) || DECL_EXTERNAL (t))
1402
        break;
1403
      /* FALLTHRU */
1404
 
1405
    case PARM_DECL:
1406
      if (decl_function_context (t) == info->context)
1407
        {
1408
          /* If we copied a pointer to the frame, then the original decl
1409
             is used unchanged in the parent function.  */
1410
          if (use_pointer_in_frame (t))
1411
            break;
1412
 
1413
          /* No need to transform anything if no child references the
1414
             variable.  */
1415
          field = lookup_field_for_decl (info, t, NO_INSERT);
1416
          if (!field)
1417
            break;
1418
          wi->changed = true;
1419
 
1420
          x = get_local_debug_decl (info, t, field);
1421
          if (!bitmap_bit_p (info->suppress_expansion, DECL_UID (t)))
1422
            x = get_frame_field (info, info->context, field, &wi->gsi);
1423
 
1424
          if (wi->val_only)
1425
            {
1426
              if (wi->is_lhs)
1427
                x = save_tmp_var (info, x, &wi->gsi);
1428
              else
1429
                x = init_tmp_var (info, x, &wi->gsi);
1430
            }
1431
 
1432
          *tp = x;
1433
        }
1434
      break;
1435
 
1436
    case ADDR_EXPR:
1437
      save_val_only = wi->val_only;
1438
      wi->val_only = false;
1439
      wi->is_lhs = false;
1440
      wi->changed = false;
1441
      walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op, wi, NULL);
1442
      wi->val_only = save_val_only;
1443
 
1444
      /* If we converted anything ... */
1445
      if (wi->changed)
1446
        {
1447
          tree save_context;
1448
 
1449
          /* Then the frame decl is now addressable.  */
1450
          TREE_ADDRESSABLE (info->frame_decl) = 1;
1451
 
1452
          save_context = current_function_decl;
1453
          current_function_decl = info->context;
1454
          recompute_tree_invariant_for_addr_expr (t);
1455
          current_function_decl = save_context;
1456
 
1457
          /* If we are in a context where we only accept values, then
1458
             compute the address into a temporary.  */
1459
          if (save_val_only)
1460
            *tp = gsi_gimplify_val ((struct nesting_info *) wi->info,
1461
                                    t, &wi->gsi);
1462
        }
1463
      break;
1464
 
1465
    case REALPART_EXPR:
1466
    case IMAGPART_EXPR:
1467
    case COMPONENT_REF:
1468
    case ARRAY_REF:
1469
    case ARRAY_RANGE_REF:
1470
    case BIT_FIELD_REF:
1471
      /* Go down this entire nest and just look at the final prefix and
1472
         anything that describes the references.  Otherwise, we lose track
1473
         of whether a NOP_EXPR or VIEW_CONVERT_EXPR needs a simple value.  */
1474
      save_val_only = wi->val_only;
1475
      wi->val_only = true;
1476
      wi->is_lhs = false;
1477
      for (; handled_component_p (t); tp = &TREE_OPERAND (t, 0), t = *tp)
1478
        {
1479
          if (TREE_CODE (t) == COMPONENT_REF)
1480
            walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
1481
                       NULL);
1482
          else if (TREE_CODE (t) == ARRAY_REF
1483
                   || TREE_CODE (t) == ARRAY_RANGE_REF)
1484
            {
1485
              walk_tree (&TREE_OPERAND (t, 1), convert_local_reference_op, wi,
1486
                         NULL);
1487
              walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
1488
                         NULL);
1489
              walk_tree (&TREE_OPERAND (t, 3), convert_local_reference_op, wi,
1490
                         NULL);
1491
            }
1492
          else if (TREE_CODE (t) == BIT_FIELD_REF)
1493
            {
1494
              walk_tree (&TREE_OPERAND (t, 1), convert_local_reference_op, wi,
1495
                         NULL);
1496
              walk_tree (&TREE_OPERAND (t, 2), convert_local_reference_op, wi,
1497
                         NULL);
1498
            }
1499
        }
1500
      wi->val_only = false;
1501
      walk_tree (tp, convert_local_reference_op, wi, NULL);
1502
      wi->val_only = save_val_only;
1503
      break;
1504
 
1505
    case MEM_REF:
1506
      save_val_only = wi->val_only;
1507
      wi->val_only = true;
1508
      wi->is_lhs = false;
1509
      walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op,
1510
                 wi, NULL);
1511
      /* We need to re-fold the MEM_REF as component references as
1512
         part of a ADDR_EXPR address are not allowed.  But we cannot
1513
         fold here, as the chain record type is not yet finalized.  */
1514
      if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
1515
          && !DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
1516
        pointer_set_insert (info->mem_refs, tp);
1517
      wi->val_only = save_val_only;
1518
      break;
1519
 
1520
    case VIEW_CONVERT_EXPR:
1521
      /* Just request to look at the subtrees, leaving val_only and lhs
1522
         untouched.  This might actually be for !val_only + lhs, in which
1523
         case we don't want to force a replacement by a temporary.  */
1524
      *walk_subtrees = 1;
1525
      break;
1526
 
1527
    default:
1528
      if (!IS_TYPE_OR_DECL_P (t))
1529
        {
1530
          *walk_subtrees = 1;
1531
          wi->val_only = true;
1532
          wi->is_lhs = false;
1533
        }
1534
      break;
1535
    }
1536
 
1537
  return NULL_TREE;
1538
}
1539
 
1540
static tree convert_local_reference_stmt (gimple_stmt_iterator *, bool *,
1541
                                          struct walk_stmt_info *);
1542
 
1543
/* Helper for convert_local_reference.  Convert all the references in
1544
   the chain of clauses at *PCLAUSES.  WI is as in convert_local_reference.  */
1545
 
1546
static bool
1547
convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
1548
{
1549
  struct nesting_info *const info = (struct nesting_info *) wi->info;
1550
  bool need_frame = false, need_stmts = false;
1551
  tree clause, decl;
1552
  int dummy;
1553
  bitmap new_suppress;
1554
 
1555
  new_suppress = BITMAP_GGC_ALLOC ();
1556
  bitmap_copy (new_suppress, info->suppress_expansion);
1557
 
1558
  for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1559
    {
1560
      switch (OMP_CLAUSE_CODE (clause))
1561
        {
1562
        case OMP_CLAUSE_REDUCTION:
1563
          if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1564
            need_stmts = true;
1565
          goto do_decl_clause;
1566
 
1567
        case OMP_CLAUSE_LASTPRIVATE:
1568
          if (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause))
1569
            need_stmts = true;
1570
          goto do_decl_clause;
1571
 
1572
        case OMP_CLAUSE_PRIVATE:
1573
        case OMP_CLAUSE_FIRSTPRIVATE:
1574
        case OMP_CLAUSE_COPYPRIVATE:
1575
        case OMP_CLAUSE_SHARED:
1576
        do_decl_clause:
1577
          decl = OMP_CLAUSE_DECL (clause);
1578
          if (TREE_CODE (decl) == VAR_DECL
1579
              && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
1580
            break;
1581
          if (decl_function_context (decl) == info->context
1582
              && !use_pointer_in_frame (decl))
1583
            {
1584
              tree field = lookup_field_for_decl (info, decl, NO_INSERT);
1585
              if (field)
1586
                {
1587
                  bitmap_set_bit (new_suppress, DECL_UID (decl));
1588
                  OMP_CLAUSE_DECL (clause)
1589
                    = get_local_debug_decl (info, decl, field);
1590
                  need_frame = true;
1591
                }
1592
            }
1593
          break;
1594
 
1595
        case OMP_CLAUSE_SCHEDULE:
1596
          if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause) == NULL)
1597
            break;
1598
          /* FALLTHRU */
1599
        case OMP_CLAUSE_FINAL:
1600
        case OMP_CLAUSE_IF:
1601
        case OMP_CLAUSE_NUM_THREADS:
1602
          wi->val_only = true;
1603
          wi->is_lhs = false;
1604
          convert_local_reference_op (&OMP_CLAUSE_OPERAND (clause, 0), &dummy,
1605
                                      wi);
1606
          break;
1607
 
1608
        case OMP_CLAUSE_NOWAIT:
1609
        case OMP_CLAUSE_ORDERED:
1610
        case OMP_CLAUSE_DEFAULT:
1611
        case OMP_CLAUSE_COPYIN:
1612
        case OMP_CLAUSE_COLLAPSE:
1613
        case OMP_CLAUSE_UNTIED:
1614
        case OMP_CLAUSE_MERGEABLE:
1615
          break;
1616
 
1617
        default:
1618
          gcc_unreachable ();
1619
        }
1620
    }
1621
 
1622
  info->suppress_expansion = new_suppress;
1623
 
1624
  if (need_stmts)
1625
    for (clause = *pclauses; clause ; clause = OMP_CLAUSE_CHAIN (clause))
1626
      switch (OMP_CLAUSE_CODE (clause))
1627
        {
1628
        case OMP_CLAUSE_REDUCTION:
1629
          if (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1630
            {
1631
              tree old_context
1632
                = DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause));
1633
              DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1634
                = info->context;
1635
              walk_body (convert_local_reference_stmt,
1636
                         convert_local_reference_op, info,
1637
                         OMP_CLAUSE_REDUCTION_GIMPLE_INIT (clause));
1638
              walk_body (convert_local_reference_stmt,
1639
                         convert_local_reference_op, info,
1640
                         OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (clause));
1641
              DECL_CONTEXT (OMP_CLAUSE_REDUCTION_PLACEHOLDER (clause))
1642
                = old_context;
1643
            }
1644
          break;
1645
 
1646
        case OMP_CLAUSE_LASTPRIVATE:
1647
          walk_body (convert_local_reference_stmt,
1648
                     convert_local_reference_op, info,
1649
                     OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (clause));
1650
          break;
1651
 
1652
        default:
1653
          break;
1654
        }
1655
 
1656
  return need_frame;
1657
}
1658
 
1659
 
1660
/* Called via walk_function+walk_gimple_stmt, rewrite all references to VAR
1661
   and PARM_DECLs that were referenced by inner nested functions.
1662
   The rewrite will be a structure reference to the local frame variable.  */
1663
 
1664
static tree
1665
convert_local_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1666
                              struct walk_stmt_info *wi)
1667
{
1668
  struct nesting_info *info = (struct nesting_info *) wi->info;
1669
  tree save_local_var_chain;
1670
  bitmap save_suppress;
1671
  gimple stmt = gsi_stmt (*gsi);
1672
 
1673
  switch (gimple_code (stmt))
1674
    {
1675
    case GIMPLE_OMP_PARALLEL:
1676
    case GIMPLE_OMP_TASK:
1677
      save_suppress = info->suppress_expansion;
1678
      if (convert_local_omp_clauses (gimple_omp_taskreg_clauses_ptr (stmt),
1679
                                     wi))
1680
        {
1681
          tree c;
1682
          (void) get_frame_type (info);
1683
          c = build_omp_clause (gimple_location (stmt),
1684
                                OMP_CLAUSE_SHARED);
1685
          OMP_CLAUSE_DECL (c) = info->frame_decl;
1686
          OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
1687
          gimple_omp_taskreg_set_clauses (stmt, c);
1688
        }
1689
 
1690
      save_local_var_chain = info->new_local_var_chain;
1691
      info->new_local_var_chain = NULL;
1692
 
1693
      walk_body (convert_local_reference_stmt, convert_local_reference_op, info,
1694
                 gimple_omp_body (stmt));
1695
 
1696
      if (info->new_local_var_chain)
1697
        declare_vars (info->new_local_var_chain,
1698
                      gimple_seq_first_stmt (gimple_omp_body (stmt)), false);
1699
      info->new_local_var_chain = save_local_var_chain;
1700
      info->suppress_expansion = save_suppress;
1701
      break;
1702
 
1703
    case GIMPLE_OMP_FOR:
1704
      save_suppress = info->suppress_expansion;
1705
      convert_local_omp_clauses (gimple_omp_for_clauses_ptr (stmt), wi);
1706
      walk_gimple_omp_for (stmt, convert_local_reference_stmt,
1707
                           convert_local_reference_op, info);
1708
      walk_body (convert_local_reference_stmt, convert_local_reference_op,
1709
                 info, gimple_omp_body (stmt));
1710
      info->suppress_expansion = save_suppress;
1711
      break;
1712
 
1713
    case GIMPLE_OMP_SECTIONS:
1714
      save_suppress = info->suppress_expansion;
1715
      convert_local_omp_clauses (gimple_omp_sections_clauses_ptr (stmt), wi);
1716
      walk_body (convert_local_reference_stmt, convert_local_reference_op,
1717
                 info, gimple_omp_body (stmt));
1718
      info->suppress_expansion = save_suppress;
1719
      break;
1720
 
1721
    case GIMPLE_OMP_SINGLE:
1722
      save_suppress = info->suppress_expansion;
1723
      convert_local_omp_clauses (gimple_omp_single_clauses_ptr (stmt), wi);
1724
      walk_body (convert_local_reference_stmt, convert_local_reference_op,
1725
                 info, gimple_omp_body (stmt));
1726
      info->suppress_expansion = save_suppress;
1727
      break;
1728
 
1729
    case GIMPLE_OMP_SECTION:
1730
    case GIMPLE_OMP_MASTER:
1731
    case GIMPLE_OMP_ORDERED:
1732
      walk_body (convert_local_reference_stmt, convert_local_reference_op,
1733
                 info, gimple_omp_body (stmt));
1734
      break;
1735
 
1736
    case GIMPLE_COND:
1737
      wi->val_only = true;
1738
      wi->is_lhs = false;
1739
      *handled_ops_p = false;
1740
      return NULL_TREE;
1741
 
1742
    default:
1743
      /* For every other statement that we are not interested in
1744
         handling here, let the walker traverse the operands.  */
1745
      *handled_ops_p = false;
1746
      return NULL_TREE;
1747
    }
1748
 
1749
  /* Indicate that we have handled all the operands ourselves.  */
1750
  *handled_ops_p = true;
1751
  return NULL_TREE;
1752
}
1753
 
1754
 
1755
/* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_GOTOs
1756
   that reference labels from outer functions.  The rewrite will be a
1757
   call to __builtin_nonlocal_goto.  */
1758
 
1759
static tree
1760
convert_nl_goto_reference (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1761
                           struct walk_stmt_info *wi)
1762
{
1763
  struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
1764
  tree label, new_label, target_context, x, field;
1765
  void **slot;
1766
  gimple call;
1767
  gimple stmt = gsi_stmt (*gsi);
1768
 
1769
  if (gimple_code (stmt) != GIMPLE_GOTO)
1770
    {
1771
      *handled_ops_p = false;
1772
      return NULL_TREE;
1773
    }
1774
 
1775
  label = gimple_goto_dest (stmt);
1776
  if (TREE_CODE (label) != LABEL_DECL)
1777
    {
1778
      *handled_ops_p = false;
1779
      return NULL_TREE;
1780
    }
1781
 
1782
  target_context = decl_function_context (label);
1783
  if (target_context == info->context)
1784
    {
1785
      *handled_ops_p = false;
1786
      return NULL_TREE;
1787
    }
1788
 
1789
  for (i = info->outer; target_context != i->context; i = i->outer)
1790
    continue;
1791
 
1792
  /* The original user label may also be use for a normal goto, therefore
1793
     we must create a new label that will actually receive the abnormal
1794
     control transfer.  This new label will be marked LABEL_NONLOCAL; this
1795
     mark will trigger proper behavior in the cfg, as well as cause the
1796
     (hairy target-specific) non-local goto receiver code to be generated
1797
     when we expand rtl.  Enter this association into var_map so that we
1798
     can insert the new label into the IL during a second pass.  */
1799
  slot = pointer_map_insert (i->var_map, label);
1800
  if (*slot == NULL)
1801
    {
1802
      new_label = create_artificial_label (UNKNOWN_LOCATION);
1803
      DECL_NONLOCAL (new_label) = 1;
1804
      *slot = new_label;
1805
    }
1806
  else
1807
    new_label = (tree) *slot;
1808
 
1809
  /* Build: __builtin_nl_goto(new_label, &chain->nl_goto_field).  */
1810
  field = get_nl_goto_field (i);
1811
  x = get_frame_field (info, target_context, field, &wi->gsi);
1812
  x = build_addr (x, target_context);
1813
  x = gsi_gimplify_val (info, x, &wi->gsi);
1814
  call = gimple_build_call (builtin_decl_implicit (BUILT_IN_NONLOCAL_GOTO),
1815
                            2, build_addr (new_label, target_context), x);
1816
  gsi_replace (&wi->gsi, call, false);
1817
 
1818
  /* We have handled all of STMT's operands, no need to keep going.  */
1819
  *handled_ops_p = true;
1820
  return NULL_TREE;
1821
}
1822
 
1823
 
1824
/* Called via walk_function+walk_tree, rewrite all GIMPLE_LABELs whose labels
1825
   are referenced via nonlocal goto from a nested function.  The rewrite
1826
   will involve installing a newly generated DECL_NONLOCAL label, and
1827
   (potentially) a branch around the rtl gunk that is assumed to be
1828
   attached to such a label.  */
1829
 
1830
static tree
1831
convert_nl_goto_receiver (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1832
                          struct walk_stmt_info *wi)
1833
{
1834
  struct nesting_info *const info = (struct nesting_info *) wi->info;
1835
  tree label, new_label;
1836
  gimple_stmt_iterator tmp_gsi;
1837
  void **slot;
1838
  gimple stmt = gsi_stmt (*gsi);
1839
 
1840
  if (gimple_code (stmt) != GIMPLE_LABEL)
1841
    {
1842
      *handled_ops_p = false;
1843
      return NULL_TREE;
1844
    }
1845
 
1846
  label = gimple_label_label (stmt);
1847
 
1848
  slot = pointer_map_contains (info->var_map, label);
1849
  if (!slot)
1850
    {
1851
      *handled_ops_p = false;
1852
      return NULL_TREE;
1853
    }
1854
 
1855
  /* If there's any possibility that the previous statement falls through,
1856
     then we must branch around the new non-local label.  */
1857
  tmp_gsi = wi->gsi;
1858
  gsi_prev (&tmp_gsi);
1859
  if (gsi_end_p (tmp_gsi) || gimple_stmt_may_fallthru (gsi_stmt (tmp_gsi)))
1860
    {
1861
      gimple stmt = gimple_build_goto (label);
1862
      gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
1863
    }
1864
 
1865
  new_label = (tree) *slot;
1866
  stmt = gimple_build_label (new_label);
1867
  gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
1868
 
1869
  *handled_ops_p = true;
1870
  return NULL_TREE;
1871
}
1872
 
1873
 
1874
/* Called via walk_function+walk_stmt, rewrite all references to addresses
1875
   of nested functions that require the use of trampolines.  The rewrite
1876
   will involve a reference a trampoline generated for the occasion.  */
1877
 
1878
static tree
1879
convert_tramp_reference_op (tree *tp, int *walk_subtrees, void *data)
1880
{
1881
  struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
1882
  struct nesting_info *const info = (struct nesting_info *) wi->info, *i;
1883
  tree t = *tp, decl, target_context, x, builtin;
1884
  gimple call;
1885
 
1886
  *walk_subtrees = 0;
1887
  switch (TREE_CODE (t))
1888
    {
1889
    case ADDR_EXPR:
1890
      /* Build
1891
           T.1 = &CHAIN->tramp;
1892
           T.2 = __builtin_adjust_trampoline (T.1);
1893
           T.3 = (func_type)T.2;
1894
      */
1895
 
1896
      decl = TREE_OPERAND (t, 0);
1897
      if (TREE_CODE (decl) != FUNCTION_DECL)
1898
        break;
1899
 
1900
      /* Only need to process nested functions.  */
1901
      target_context = decl_function_context (decl);
1902
      if (!target_context)
1903
        break;
1904
 
1905
      /* If the nested function doesn't use a static chain, then
1906
         it doesn't need a trampoline.  */
1907
      if (!DECL_STATIC_CHAIN (decl))
1908
        break;
1909
 
1910
      /* If we don't want a trampoline, then don't build one.  */
1911
      if (TREE_NO_TRAMPOLINE (t))
1912
        break;
1913
 
1914
      /* Lookup the immediate parent of the callee, as that's where
1915
         we need to insert the trampoline.  */
1916
      for (i = info; i->context != target_context; i = i->outer)
1917
        continue;
1918
      x = lookup_tramp_for_decl (i, decl, INSERT);
1919
 
1920
      /* Compute the address of the field holding the trampoline.  */
1921
      x = get_frame_field (info, target_context, x, &wi->gsi);
1922
      x = build_addr (x, target_context);
1923
      x = gsi_gimplify_val (info, x, &wi->gsi);
1924
 
1925
      /* Do machine-specific ugliness.  Normally this will involve
1926
         computing extra alignment, but it can really be anything.  */
1927
      builtin = builtin_decl_implicit (BUILT_IN_ADJUST_TRAMPOLINE);
1928
      call = gimple_build_call (builtin, 1, x);
1929
      x = init_tmp_var_with_call (info, &wi->gsi, call);
1930
 
1931
      /* Cast back to the proper function type.  */
1932
      x = build1 (NOP_EXPR, TREE_TYPE (t), x);
1933
      x = init_tmp_var (info, x, &wi->gsi);
1934
 
1935
      *tp = x;
1936
      break;
1937
 
1938
    default:
1939
      if (!IS_TYPE_OR_DECL_P (t))
1940
        *walk_subtrees = 1;
1941
      break;
1942
    }
1943
 
1944
  return NULL_TREE;
1945
}
1946
 
1947
 
1948
/* Called via walk_function+walk_gimple_stmt, rewrite all references
1949
   to addresses of nested functions that require the use of
1950
   trampolines.  The rewrite will involve a reference a trampoline
1951
   generated for the occasion.  */
1952
 
1953
static tree
1954
convert_tramp_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1955
                              struct walk_stmt_info *wi)
1956
{
1957
  gimple stmt = gsi_stmt (*gsi);
1958
 
1959
  switch (gimple_code (stmt))
1960
    {
1961
    case GIMPLE_CALL:
1962
      {
1963
        /* Only walk call arguments, lest we generate trampolines for
1964
           direct calls.  */
1965
        unsigned long i, nargs = gimple_call_num_args (stmt);
1966
        for (i = 0; i < nargs; i++)
1967
          walk_tree (gimple_call_arg_ptr (stmt, i), convert_tramp_reference_op,
1968
                     wi, NULL);
1969
 
1970
        *handled_ops_p = true;
1971
        return NULL_TREE;
1972
      }
1973
 
1974
    default:
1975
      break;
1976
    }
1977
 
1978
  *handled_ops_p = false;
1979
  return NULL_TREE;
1980
}
1981
 
1982
 
1983
 
1984
/* Called via walk_function+walk_gimple_stmt, rewrite all GIMPLE_CALLs
1985
   that reference nested functions to make sure that the static chain
1986
   is set up properly for the call.  */
1987
 
1988
static tree
1989
convert_gimple_call (gimple_stmt_iterator *gsi, bool *handled_ops_p,
1990
                     struct walk_stmt_info *wi)
1991
{
1992
  struct nesting_info *const info = (struct nesting_info *) wi->info;
1993
  tree decl, target_context;
1994
  char save_static_chain_added;
1995
  int i;
1996
  gimple stmt = gsi_stmt (*gsi);
1997
 
1998
  switch (gimple_code (stmt))
1999
    {
2000
    case GIMPLE_CALL:
2001
      if (gimple_call_chain (stmt))
2002
        break;
2003
      decl = gimple_call_fndecl (stmt);
2004
      if (!decl)
2005
        break;
2006
      target_context = decl_function_context (decl);
2007
      if (target_context && DECL_STATIC_CHAIN (decl))
2008
        {
2009
          gimple_call_set_chain (stmt, get_static_chain (info, target_context,
2010
                                                         &wi->gsi));
2011
          info->static_chain_added |= (1 << (info->context != target_context));
2012
        }
2013
      break;
2014
 
2015
    case GIMPLE_OMP_PARALLEL:
2016
    case GIMPLE_OMP_TASK:
2017
      save_static_chain_added = info->static_chain_added;
2018
      info->static_chain_added = 0;
2019
      walk_body (convert_gimple_call, NULL, info, gimple_omp_body (stmt));
2020
      for (i = 0; i < 2; i++)
2021
        {
2022
          tree c, decl;
2023
          if ((info->static_chain_added & (1 << i)) == 0)
2024
            continue;
2025
          decl = i ? get_chain_decl (info) : info->frame_decl;
2026
          /* Don't add CHAIN.* or FRAME.* twice.  */
2027
          for (c = gimple_omp_taskreg_clauses (stmt);
2028
               c;
2029
               c = OMP_CLAUSE_CHAIN (c))
2030
            if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
2031
                 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED)
2032
                && OMP_CLAUSE_DECL (c) == decl)
2033
              break;
2034
          if (c == NULL)
2035
            {
2036
              c = build_omp_clause (gimple_location (stmt),
2037
                                    i ? OMP_CLAUSE_FIRSTPRIVATE
2038
                                    : OMP_CLAUSE_SHARED);
2039
              OMP_CLAUSE_DECL (c) = decl;
2040
              OMP_CLAUSE_CHAIN (c) = gimple_omp_taskreg_clauses (stmt);
2041
              gimple_omp_taskreg_set_clauses (stmt, c);
2042
            }
2043
        }
2044
      info->static_chain_added |= save_static_chain_added;
2045
      break;
2046
 
2047
    case GIMPLE_OMP_FOR:
2048
      walk_body (convert_gimple_call, NULL, info,
2049
                 gimple_omp_for_pre_body (stmt));
2050
      /* FALLTHRU */
2051
    case GIMPLE_OMP_SECTIONS:
2052
    case GIMPLE_OMP_SECTION:
2053
    case GIMPLE_OMP_SINGLE:
2054
    case GIMPLE_OMP_MASTER:
2055
    case GIMPLE_OMP_ORDERED:
2056
    case GIMPLE_OMP_CRITICAL:
2057
      walk_body (convert_gimple_call, NULL, info, gimple_omp_body (stmt));
2058
      break;
2059
 
2060
    default:
2061
      /* Keep looking for other operands.  */
2062
      *handled_ops_p = false;
2063
      return NULL_TREE;
2064
    }
2065
 
2066
  *handled_ops_p = true;
2067
  return NULL_TREE;
2068
}
2069
 
2070
/* Walk the nesting tree starting with ROOT.  Convert all trampolines and
2071
   call expressions.  At the same time, determine if a nested function
2072
   actually uses its static chain; if not, remember that.  */
2073
 
2074
static void
2075
convert_all_function_calls (struct nesting_info *root)
2076
{
2077
  unsigned int chain_count = 0, old_chain_count, iter_count;
2078
  struct nesting_info *n;
2079
 
2080
  /* First, optimistically clear static_chain for all decls that haven't
2081
     used the static chain already for variable access.  */
2082
  FOR_EACH_NEST_INFO (n, root)
2083
    {
2084
      tree decl = n->context;
2085
      if (!n->outer || (!n->chain_decl && !n->chain_field))
2086
        {
2087
          DECL_STATIC_CHAIN (decl) = 0;
2088
          if (dump_file && (dump_flags & TDF_DETAILS))
2089
            fprintf (dump_file, "Guessing no static-chain for %s\n",
2090
                     lang_hooks.decl_printable_name (decl, 2));
2091
        }
2092
      else
2093
        DECL_STATIC_CHAIN (decl) = 1;
2094
      chain_count += DECL_STATIC_CHAIN (decl);
2095
    }
2096
 
2097
  /* Walk the functions and perform transformations.  Note that these
2098
     transformations can induce new uses of the static chain, which in turn
2099
     require re-examining all users of the decl.  */
2100
  /* ??? It would make sense to try to use the call graph to speed this up,
2101
     but the call graph hasn't really been built yet.  Even if it did, we
2102
     would still need to iterate in this loop since address-of references
2103
     wouldn't show up in the callgraph anyway.  */
2104
  iter_count = 0;
2105
  do
2106
    {
2107
      old_chain_count = chain_count;
2108
      chain_count = 0;
2109
      iter_count++;
2110
 
2111
      if (dump_file && (dump_flags & TDF_DETAILS))
2112
        fputc ('\n', dump_file);
2113
 
2114
      FOR_EACH_NEST_INFO (n, root)
2115
        {
2116
          tree decl = n->context;
2117
          walk_function (convert_tramp_reference_stmt,
2118
                         convert_tramp_reference_op, n);
2119
          walk_function (convert_gimple_call, NULL, n);
2120
          chain_count += DECL_STATIC_CHAIN (decl);
2121
        }
2122
    }
2123
  while (chain_count != old_chain_count);
2124
 
2125
  if (dump_file && (dump_flags & TDF_DETAILS))
2126
    fprintf (dump_file, "convert_all_function_calls iterations: %u\n\n",
2127
             iter_count);
2128
}
2129
 
2130
struct nesting_copy_body_data
2131
{
2132
  copy_body_data cb;
2133
  struct nesting_info *root;
2134
};
2135
 
2136
/* A helper subroutine for debug_var_chain type remapping.  */
2137
 
2138
static tree
2139
nesting_copy_decl (tree decl, copy_body_data *id)
2140
{
2141
  struct nesting_copy_body_data *nid = (struct nesting_copy_body_data *) id;
2142
  void **slot = pointer_map_contains (nid->root->var_map, decl);
2143
 
2144
  if (slot)
2145
    return (tree) *slot;
2146
 
2147
  if (TREE_CODE (decl) == TYPE_DECL && DECL_ORIGINAL_TYPE (decl))
2148
    {
2149
      tree new_decl = copy_decl_no_change (decl, id);
2150
      DECL_ORIGINAL_TYPE (new_decl)
2151
        = remap_type (DECL_ORIGINAL_TYPE (decl), id);
2152
      return new_decl;
2153
    }
2154
 
2155
  if (TREE_CODE (decl) == VAR_DECL
2156
      || TREE_CODE (decl) == PARM_DECL
2157
      || TREE_CODE (decl) == RESULT_DECL)
2158
    return decl;
2159
 
2160
  return copy_decl_no_change (decl, id);
2161
}
2162
 
2163
/* A helper function for remap_vla_decls.  See if *TP contains
2164
   some remapped variables.  */
2165
 
2166
static tree
2167
contains_remapped_vars (tree *tp, int *walk_subtrees, void *data)
2168
{
2169
  struct nesting_info *root = (struct nesting_info *) data;
2170
  tree t = *tp;
2171
  void **slot;
2172
 
2173
  if (DECL_P (t))
2174
    {
2175
      *walk_subtrees = 0;
2176
      slot = pointer_map_contains (root->var_map, t);
2177
 
2178
      if (slot)
2179
        return (tree) *slot;
2180
    }
2181
  return NULL;
2182
}
2183
 
2184
/* Remap VLA decls in BLOCK and subblocks if remapped variables are
2185
   involved.  */
2186
 
2187
static void
2188
remap_vla_decls (tree block, struct nesting_info *root)
2189
{
2190
  tree var, subblock, val, type;
2191
  struct nesting_copy_body_data id;
2192
 
2193
  for (subblock = BLOCK_SUBBLOCKS (block);
2194
       subblock;
2195
       subblock = BLOCK_CHAIN (subblock))
2196
    remap_vla_decls (subblock, root);
2197
 
2198
  for (var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
2199
    if (TREE_CODE (var) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (var))
2200
      {
2201
        val = DECL_VALUE_EXPR (var);
2202
        type = TREE_TYPE (var);
2203
 
2204
        if (!(TREE_CODE (val) == INDIRECT_REF
2205
              && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
2206
              && variably_modified_type_p (type, NULL)))
2207
          continue;
2208
 
2209
        if (pointer_map_contains (root->var_map, TREE_OPERAND (val, 0))
2210
            || walk_tree (&type, contains_remapped_vars, root, NULL))
2211
          break;
2212
      }
2213
 
2214
  if (var == NULL_TREE)
2215
    return;
2216
 
2217
  memset (&id, 0, sizeof (id));
2218
  id.cb.copy_decl = nesting_copy_decl;
2219
  id.cb.decl_map = pointer_map_create ();
2220
  id.root = root;
2221
 
2222
  for (; var; var = DECL_CHAIN (var))
2223
    if (TREE_CODE (var) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (var))
2224
      {
2225
        struct nesting_info *i;
2226
        tree newt, context;
2227
        void **slot;
2228
 
2229
        val = DECL_VALUE_EXPR (var);
2230
        type = TREE_TYPE (var);
2231
 
2232
        if (!(TREE_CODE (val) == INDIRECT_REF
2233
              && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
2234
              && variably_modified_type_p (type, NULL)))
2235
          continue;
2236
 
2237
        slot = pointer_map_contains (root->var_map, TREE_OPERAND (val, 0));
2238
        if (!slot && !walk_tree (&type, contains_remapped_vars, root, NULL))
2239
          continue;
2240
 
2241
        context = decl_function_context (var);
2242
        for (i = root; i; i = i->outer)
2243
          if (i->context == context)
2244
            break;
2245
 
2246
        if (i == NULL)
2247
          continue;
2248
 
2249
        /* Fully expand value expressions.  This avoids having debug variables
2250
           only referenced from them and that can be swept during GC.  */
2251
        if (slot)
2252
          {
2253
            tree t = (tree) *slot;
2254
            gcc_assert (DECL_P (t) && DECL_HAS_VALUE_EXPR_P (t));
2255
            val = build1 (INDIRECT_REF, TREE_TYPE (val), DECL_VALUE_EXPR (t));
2256
          }
2257
 
2258
        id.cb.src_fn = i->context;
2259
        id.cb.dst_fn = i->context;
2260
        id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
2261
 
2262
        TREE_TYPE (var) = newt = remap_type (type, &id.cb);
2263
        while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
2264
          {
2265
            newt = TREE_TYPE (newt);
2266
            type = TREE_TYPE (type);
2267
          }
2268
        if (TYPE_NAME (newt)
2269
            && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
2270
            && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
2271
            && newt != type
2272
            && TYPE_NAME (newt) == TYPE_NAME (type))
2273
          TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
2274
 
2275
        walk_tree (&val, copy_tree_body_r, &id.cb, NULL);
2276
        if (val != DECL_VALUE_EXPR (var))
2277
          SET_DECL_VALUE_EXPR (var, val);
2278
      }
2279
 
2280
  pointer_map_destroy (id.cb.decl_map);
2281
}
2282
 
2283
/* Fold the MEM_REF *E.  */
2284
static bool
2285
fold_mem_refs (const void *e, void *data ATTRIBUTE_UNUSED)
2286
{
2287
  tree *ref_p = CONST_CAST2(tree *, const tree *, (const tree *)e);
2288
  *ref_p = fold (*ref_p);
2289
  return true;
2290
}
2291
 
2292
/* Do "everything else" to clean up or complete state collected by the
2293
   various walking passes -- lay out the types and decls, generate code
2294
   to initialize the frame decl, store critical expressions in the
2295
   struct function for rtl to find.  */
2296
 
2297
static void
2298
finalize_nesting_tree_1 (struct nesting_info *root)
2299
{
2300
  gimple_seq stmt_list;
2301
  gimple stmt;
2302
  tree context = root->context;
2303
  struct function *sf;
2304
 
2305
  stmt_list = NULL;
2306
 
2307
  /* If we created a non-local frame type or decl, we need to lay them
2308
     out at this time.  */
2309
  if (root->frame_type)
2310
    {
2311
      /* In some cases the frame type will trigger the -Wpadded warning.
2312
         This is not helpful; suppress it. */
2313
      int save_warn_padded = warn_padded;
2314
      tree *adjust;
2315
 
2316
      warn_padded = 0;
2317
      layout_type (root->frame_type);
2318
      warn_padded = save_warn_padded;
2319
      layout_decl (root->frame_decl, 0);
2320
 
2321
      /* Remove root->frame_decl from root->new_local_var_chain, so
2322
         that we can declare it also in the lexical blocks, which
2323
         helps ensure virtual regs that end up appearing in its RTL
2324
         expression get substituted in instantiate_virtual_regs().  */
2325
      for (adjust = &root->new_local_var_chain;
2326
           *adjust != root->frame_decl;
2327
           adjust = &DECL_CHAIN (*adjust))
2328
        gcc_assert (DECL_CHAIN (*adjust));
2329
      *adjust = DECL_CHAIN (*adjust);
2330
 
2331
      DECL_CHAIN (root->frame_decl) = NULL_TREE;
2332
      declare_vars (root->frame_decl,
2333
                    gimple_seq_first_stmt (gimple_body (context)), true);
2334
    }
2335
 
2336
  /* If any parameters were referenced non-locally, then we need to
2337
     insert a copy.  Likewise, if any variables were referenced by
2338
     pointer, we need to initialize the address.  */
2339
  if (root->any_parm_remapped)
2340
    {
2341
      tree p;
2342
      for (p = DECL_ARGUMENTS (context); p ; p = DECL_CHAIN (p))
2343
        {
2344
          tree field, x, y;
2345
 
2346
          field = lookup_field_for_decl (root, p, NO_INSERT);
2347
          if (!field)
2348
            continue;
2349
 
2350
          if (use_pointer_in_frame (p))
2351
            x = build_addr (p, context);
2352
          else
2353
            x = p;
2354
 
2355
          y = build3 (COMPONENT_REF, TREE_TYPE (field),
2356
                      root->frame_decl, field, NULL_TREE);
2357
          stmt = gimple_build_assign (y, x);
2358
          gimple_seq_add_stmt (&stmt_list, stmt);
2359
          /* If the assignment is from a non-register the stmt is
2360
             not valid gimple.  Make it so by using a temporary instead.  */
2361
          if (!is_gimple_reg (x)
2362
              && is_gimple_reg_type (TREE_TYPE (x)))
2363
            {
2364
              gimple_stmt_iterator gsi = gsi_last (stmt_list);
2365
              x = init_tmp_var (root, x, &gsi);
2366
              gimple_assign_set_rhs1 (stmt, x);
2367
            }
2368
        }
2369
    }
2370
 
2371
  /* If a chain_field was created, then it needs to be initialized
2372
     from chain_decl.  */
2373
  if (root->chain_field)
2374
    {
2375
      tree x = build3 (COMPONENT_REF, TREE_TYPE (root->chain_field),
2376
                       root->frame_decl, root->chain_field, NULL_TREE);
2377
      stmt = gimple_build_assign (x, get_chain_decl (root));
2378
      gimple_seq_add_stmt (&stmt_list, stmt);
2379
    }
2380
 
2381
  /* If trampolines were created, then we need to initialize them.  */
2382
  if (root->any_tramp_created)
2383
    {
2384
      struct nesting_info *i;
2385
      for (i = root->inner; i ; i = i->next)
2386
        {
2387
          tree arg1, arg2, arg3, x, field;
2388
 
2389
          field = lookup_tramp_for_decl (root, i->context, NO_INSERT);
2390
          if (!field)
2391
            continue;
2392
 
2393
          gcc_assert (DECL_STATIC_CHAIN (i->context));
2394
          arg3 = build_addr (root->frame_decl, context);
2395
 
2396
          arg2 = build_addr (i->context, context);
2397
 
2398
          x = build3 (COMPONENT_REF, TREE_TYPE (field),
2399
                      root->frame_decl, field, NULL_TREE);
2400
          arg1 = build_addr (x, context);
2401
 
2402
          x = builtin_decl_implicit (BUILT_IN_INIT_TRAMPOLINE);
2403
          stmt = gimple_build_call (x, 3, arg1, arg2, arg3);
2404
          gimple_seq_add_stmt (&stmt_list, stmt);
2405
        }
2406
    }
2407
 
2408
  /* If we created initialization statements, insert them.  */
2409
  if (stmt_list)
2410
    {
2411
      gimple bind;
2412
      annotate_all_with_location (stmt_list, DECL_SOURCE_LOCATION (context));
2413
      bind = gimple_seq_first_stmt (gimple_body (context));
2414
      gimple_seq_add_seq (&stmt_list, gimple_bind_body (bind));
2415
      gimple_bind_set_body (bind, stmt_list);
2416
    }
2417
 
2418
  /* If a chain_decl was created, then it needs to be registered with
2419
     struct function so that it gets initialized from the static chain
2420
     register at the beginning of the function.  */
2421
  sf = DECL_STRUCT_FUNCTION (root->context);
2422
  sf->static_chain_decl = root->chain_decl;
2423
 
2424
  /* Similarly for the non-local goto save area.  */
2425
  if (root->nl_goto_field)
2426
    {
2427
      sf->nonlocal_goto_save_area
2428
        = get_frame_field (root, context, root->nl_goto_field, NULL);
2429
      sf->has_nonlocal_label = 1;
2430
    }
2431
 
2432
  /* Make sure all new local variables get inserted into the
2433
     proper BIND_EXPR.  */
2434
  if (root->new_local_var_chain)
2435
    declare_vars (root->new_local_var_chain,
2436
                  gimple_seq_first_stmt (gimple_body (root->context)),
2437
                  false);
2438
 
2439
  if (root->debug_var_chain)
2440
    {
2441
      tree debug_var;
2442
      gimple scope;
2443
 
2444
      remap_vla_decls (DECL_INITIAL (root->context), root);
2445
 
2446
      for (debug_var = root->debug_var_chain; debug_var;
2447
           debug_var = DECL_CHAIN (debug_var))
2448
        if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
2449
          break;
2450
 
2451
      /* If there are any debug decls with variable length types,
2452
         remap those types using other debug_var_chain variables.  */
2453
      if (debug_var)
2454
        {
2455
          struct nesting_copy_body_data id;
2456
 
2457
          memset (&id, 0, sizeof (id));
2458
          id.cb.copy_decl = nesting_copy_decl;
2459
          id.cb.decl_map = pointer_map_create ();
2460
          id.root = root;
2461
 
2462
          for (; debug_var; debug_var = DECL_CHAIN (debug_var))
2463
            if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
2464
              {
2465
                tree type = TREE_TYPE (debug_var);
2466
                tree newt, t = type;
2467
                struct nesting_info *i;
2468
 
2469
                for (i = root; i; i = i->outer)
2470
                  if (variably_modified_type_p (type, i->context))
2471
                    break;
2472
 
2473
                if (i == NULL)
2474
                  continue;
2475
 
2476
                id.cb.src_fn = i->context;
2477
                id.cb.dst_fn = i->context;
2478
                id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
2479
 
2480
                TREE_TYPE (debug_var) = newt = remap_type (type, &id.cb);
2481
                while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
2482
                  {
2483
                    newt = TREE_TYPE (newt);
2484
                    t = TREE_TYPE (t);
2485
                  }
2486
                if (TYPE_NAME (newt)
2487
                    && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
2488
                    && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
2489
                    && newt != t
2490
                    && TYPE_NAME (newt) == TYPE_NAME (t))
2491
                  TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
2492
              }
2493
 
2494
          pointer_map_destroy (id.cb.decl_map);
2495
        }
2496
 
2497
      scope = gimple_seq_first_stmt (gimple_body (root->context));
2498
      if (gimple_bind_block (scope))
2499
        declare_vars (root->debug_var_chain, scope, true);
2500
      else
2501
        BLOCK_VARS (DECL_INITIAL (root->context))
2502
          = chainon (BLOCK_VARS (DECL_INITIAL (root->context)),
2503
                     root->debug_var_chain);
2504
    }
2505
 
2506
  /* Fold the rewritten MEM_REF trees.  */
2507
  pointer_set_traverse (root->mem_refs, fold_mem_refs, NULL);
2508
 
2509
  /* Dump the translated tree function.  */
2510
  if (dump_file)
2511
    {
2512
      fputs ("\n\n", dump_file);
2513
      dump_function_to_file (root->context, dump_file, dump_flags);
2514
    }
2515
}
2516
 
2517
static void
2518
finalize_nesting_tree (struct nesting_info *root)
2519
{
2520
  struct nesting_info *n;
2521
  FOR_EACH_NEST_INFO (n, root)
2522
    finalize_nesting_tree_1 (n);
2523
}
2524
 
2525
/* Unnest the nodes and pass them to cgraph.  */
2526
 
2527
static void
2528
unnest_nesting_tree_1 (struct nesting_info *root)
2529
{
2530
  struct cgraph_node *node = cgraph_get_node (root->context);
2531
 
2532
  /* For nested functions update the cgraph to reflect unnesting.
2533
     We also delay finalizing of these functions up to this point.  */
2534
  if (node->origin)
2535
    {
2536
       cgraph_unnest_node (node);
2537
       cgraph_finalize_function (root->context, true);
2538
    }
2539
}
2540
 
2541
static void
2542
unnest_nesting_tree (struct nesting_info *root)
2543
{
2544
  struct nesting_info *n;
2545
  FOR_EACH_NEST_INFO (n, root)
2546
    unnest_nesting_tree_1 (n);
2547
}
2548
 
2549
/* Free the data structures allocated during this pass.  */
2550
 
2551
static void
2552
free_nesting_tree (struct nesting_info *root)
2553
{
2554
  struct nesting_info *node, *next;
2555
 
2556
  node = iter_nestinfo_start (root);
2557
  do
2558
    {
2559
      next = iter_nestinfo_next (node);
2560
      pointer_map_destroy (node->var_map);
2561
      pointer_map_destroy (node->field_map);
2562
      pointer_set_destroy (node->mem_refs);
2563
      free (node);
2564
      node = next;
2565
    }
2566
  while (node);
2567
}
2568
 
2569
/* Gimplify a function and all its nested functions.  */
2570
static void
2571
gimplify_all_functions (struct cgraph_node *root)
2572
{
2573
  struct cgraph_node *iter;
2574
  if (!gimple_body (root->decl))
2575
    gimplify_function_tree (root->decl);
2576
  for (iter = root->nested; iter; iter = iter->next_nested)
2577
    gimplify_all_functions (iter);
2578
}
2579
 
2580
/* Main entry point for this pass.  Process FNDECL and all of its nested
2581
   subroutines and turn them into something less tightly bound.  */
2582
 
2583
void
2584
lower_nested_functions (tree fndecl)
2585
{
2586
  struct cgraph_node *cgn;
2587
  struct nesting_info *root;
2588
 
2589
  /* If there are no nested functions, there's nothing to do.  */
2590
  cgn = cgraph_get_node (fndecl);
2591
  if (!cgn->nested)
2592
    return;
2593
 
2594
  gimplify_all_functions (cgn);
2595
 
2596
  dump_file = dump_begin (TDI_nested, &dump_flags);
2597
  if (dump_file)
2598
    fprintf (dump_file, "\n;; Function %s\n\n",
2599
             lang_hooks.decl_printable_name (fndecl, 2));
2600
 
2601
  bitmap_obstack_initialize (&nesting_info_bitmap_obstack);
2602
  root = create_nesting_tree (cgn);
2603
 
2604
  walk_all_functions (convert_nonlocal_reference_stmt,
2605
                      convert_nonlocal_reference_op,
2606
                      root);
2607
  walk_all_functions (convert_local_reference_stmt,
2608
                      convert_local_reference_op,
2609
                      root);
2610
  walk_all_functions (convert_nl_goto_reference, NULL, root);
2611
  walk_all_functions (convert_nl_goto_receiver, NULL, root);
2612
 
2613
  convert_all_function_calls (root);
2614
  finalize_nesting_tree (root);
2615
  unnest_nesting_tree (root);
2616
 
2617
  free_nesting_tree (root);
2618
  bitmap_obstack_release (&nesting_info_bitmap_obstack);
2619
 
2620
  if (dump_file)
2621
    {
2622
      dump_end (TDI_nested, dump_file);
2623
      dump_file = NULL;
2624
    }
2625
}
2626
 
2627
#include "gt-tree-nested.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.