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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [gimplify.c] - Blame information for rev 856

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

Line No. Rev Author Line
1 38 julius
/* Tree lowering pass.  This pass converts the GENERIC functions-as-trees
2
   tree representation into the GIMPLE form.
3
   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
4
   Free Software Foundation, Inc.
5
   Major work done by Sebastian Pop <s.pop@laposte.net>,
6
   Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7
 
8
This file is part of GCC.
9
 
10
GCC is free software; you can redistribute it and/or modify it under
11
the terms of the GNU General Public License as published by the Free
12
Software Foundation; either version 3, or (at your option) any later
13
version.
14
 
15
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16
WARRANTY; without even the implied warranty of MERCHANTABILITY or
17
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18
for more details.
19
 
20
You should have received a copy of the GNU General Public License
21
along with GCC; see the file COPYING3.  If not see
22
<http://www.gnu.org/licenses/>.  */
23
 
24
#include "config.h"
25
#include "system.h"
26
#include "coretypes.h"
27
#include "tm.h"
28
#include "tree.h"
29
#include "rtl.h"
30
#include "varray.h"
31
#include "tree-gimple.h"
32
#include "tree-inline.h"
33
#include "diagnostic.h"
34
#include "langhooks.h"
35
#include "langhooks-def.h"
36
#include "tree-flow.h"
37
#include "cgraph.h"
38
#include "timevar.h"
39
#include "except.h"
40
#include "hashtab.h"
41
#include "flags.h"
42
#include "real.h"
43
#include "function.h"
44
#include "output.h"
45
#include "expr.h"
46
#include "ggc.h"
47
#include "toplev.h"
48
#include "target.h"
49
#include "optabs.h"
50
#include "pointer-set.h"
51
 
52
 
53
enum gimplify_omp_var_data
54
{
55
  GOVD_SEEN = 1,
56
  GOVD_EXPLICIT = 2,
57
  GOVD_SHARED = 4,
58
  GOVD_PRIVATE = 8,
59
  GOVD_FIRSTPRIVATE = 16,
60
  GOVD_LASTPRIVATE = 32,
61
  GOVD_REDUCTION = 64,
62
  GOVD_LOCAL = 128,
63
  GOVD_DEBUG_PRIVATE = 256,
64
  GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
65
                           | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
66
};
67
 
68
struct gimplify_omp_ctx
69
{
70
  struct gimplify_omp_ctx *outer_context;
71
  splay_tree variables;
72
  struct pointer_set_t *privatized_types;
73
  location_t location;
74
  enum omp_clause_default_kind default_kind;
75
  bool is_parallel;
76
  bool is_combined_parallel;
77
};
78
 
79
struct gimplify_ctx
80
{
81
  struct gimplify_ctx *prev_context;
82
 
83
  tree current_bind_expr;
84
  tree temps;
85
  tree conditional_cleanups;
86
  tree exit_label;
87
  tree return_temp;
88
 
89
  VEC(tree,heap) *case_labels;
90
  /* The formal temporary table.  Should this be persistent?  */
91
  htab_t temp_htab;
92
 
93
  int conditions;
94
  bool save_stack;
95
  bool into_ssa;
96
};
97
 
98
static struct gimplify_ctx *gimplify_ctxp;
99
static struct gimplify_omp_ctx *gimplify_omp_ctxp;
100
 
101
 
102
 
103
/* Formal (expression) temporary table handling: Multiple occurrences of
104
   the same scalar expression are evaluated into the same temporary.  */
105
 
106
typedef struct gimple_temp_hash_elt
107
{
108
  tree val;   /* Key */
109
  tree temp;  /* Value */
110
} elt_t;
111
 
112
/* Forward declarations.  */
113
static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool);
114
#ifdef ENABLE_CHECKING
115
static bool cpt_same_type (tree a, tree b);
116
#endif
117
 
118
 
119
/* Return a hash value for a formal temporary table entry.  */
120
 
121
static hashval_t
122
gimple_tree_hash (const void *p)
123
{
124
  tree t = ((const elt_t *) p)->val;
125
  return iterative_hash_expr (t, 0);
126
}
127
 
128
/* Compare two formal temporary table entries.  */
129
 
130
static int
131
gimple_tree_eq (const void *p1, const void *p2)
132
{
133
  tree t1 = ((const elt_t *) p1)->val;
134
  tree t2 = ((const elt_t *) p2)->val;
135
  enum tree_code code = TREE_CODE (t1);
136
 
137
  if (TREE_CODE (t2) != code
138
      || TREE_TYPE (t1) != TREE_TYPE (t2))
139
    return 0;
140
 
141
  if (!operand_equal_p (t1, t2, 0))
142
    return 0;
143
 
144
  /* Only allow them to compare equal if they also hash equal; otherwise
145
     results are nondeterminate, and we fail bootstrap comparison.  */
146
  gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
147
 
148
  return 1;
149
}
150
 
151
/* Set up a context for the gimplifier.  */
152
 
153
void
154
push_gimplify_context (void)
155
{
156
  struct gimplify_ctx *c;
157
 
158
  c = (struct gimplify_ctx *) xcalloc (1, sizeof (struct gimplify_ctx));
159
  c->prev_context = gimplify_ctxp;
160
  if (optimize)
161
    c->temp_htab = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
162
 
163
  gimplify_ctxp = c;
164
}
165
 
166
/* Tear down a context for the gimplifier.  If BODY is non-null, then
167
   put the temporaries into the outer BIND_EXPR.  Otherwise, put them
168
   in the unexpanded_var_list.  */
169
 
170
void
171
pop_gimplify_context (tree body)
172
{
173
  struct gimplify_ctx *c = gimplify_ctxp;
174
  tree t;
175
 
176
  gcc_assert (c && !c->current_bind_expr);
177
  gimplify_ctxp = c->prev_context;
178
 
179
  for (t = c->temps; t ; t = TREE_CHAIN (t))
180
    DECL_GIMPLE_FORMAL_TEMP_P (t) = 0;
181
 
182
  if (body)
183
    declare_vars (c->temps, body, false);
184
  else
185
    record_vars (c->temps);
186
 
187
  if (optimize)
188
    htab_delete (c->temp_htab);
189
  free (c);
190
}
191
 
192
static void
193
gimple_push_bind_expr (tree bind)
194
{
195
  TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr;
196
  gimplify_ctxp->current_bind_expr = bind;
197
}
198
 
199
static void
200
gimple_pop_bind_expr (void)
201
{
202
  gimplify_ctxp->current_bind_expr
203
    = TREE_CHAIN (gimplify_ctxp->current_bind_expr);
204
}
205
 
206
tree
207
gimple_current_bind_expr (void)
208
{
209
  return gimplify_ctxp->current_bind_expr;
210
}
211
 
212
/* Returns true iff there is a COND_EXPR between us and the innermost
213
   CLEANUP_POINT_EXPR.  This info is used by gimple_push_cleanup.  */
214
 
215
static bool
216
gimple_conditional_context (void)
217
{
218
  return gimplify_ctxp->conditions > 0;
219
}
220
 
221
/* Note that we've entered a COND_EXPR.  */
222
 
223
static void
224
gimple_push_condition (void)
225
{
226
#ifdef ENABLE_CHECKING
227
  if (gimplify_ctxp->conditions == 0)
228
    gcc_assert (!gimplify_ctxp->conditional_cleanups);
229
#endif
230
  ++(gimplify_ctxp->conditions);
231
}
232
 
233
/* Note that we've left a COND_EXPR.  If we're back at unconditional scope
234
   now, add any conditional cleanups we've seen to the prequeue.  */
235
 
236
static void
237
gimple_pop_condition (tree *pre_p)
238
{
239
  int conds = --(gimplify_ctxp->conditions);
240
 
241
  gcc_assert (conds >= 0);
242
  if (conds == 0)
243
    {
244
      append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p);
245
      gimplify_ctxp->conditional_cleanups = NULL_TREE;
246
    }
247
}
248
 
249
/* A stable comparison routine for use with splay trees and DECLs.  */
250
 
251
static int
252
splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
253
{
254
  tree a = (tree) xa;
255
  tree b = (tree) xb;
256
 
257
  return DECL_UID (a) - DECL_UID (b);
258
}
259
 
260
/* Create a new omp construct that deals with variable remapping.  */
261
 
262
static struct gimplify_omp_ctx *
263
new_omp_context (bool is_parallel, bool is_combined_parallel)
264
{
265
  struct gimplify_omp_ctx *c;
266
 
267
  c = XCNEW (struct gimplify_omp_ctx);
268
  c->outer_context = gimplify_omp_ctxp;
269
  c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
270
  c->privatized_types = pointer_set_create ();
271
  c->location = input_location;
272
  c->is_parallel = is_parallel;
273
  c->is_combined_parallel = is_combined_parallel;
274
  c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
275
 
276
  return c;
277
}
278
 
279
/* Destroy an omp construct that deals with variable remapping.  */
280
 
281
static void
282
delete_omp_context (struct gimplify_omp_ctx *c)
283
{
284
  splay_tree_delete (c->variables);
285
  pointer_set_destroy (c->privatized_types);
286
  XDELETE (c);
287
}
288
 
289
static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
290
static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
291
 
292
/* A subroutine of append_to_statement_list{,_force}.  T is not NULL.  */
293
 
294
static void
295
append_to_statement_list_1 (tree t, tree *list_p)
296
{
297
  tree list = *list_p;
298
  tree_stmt_iterator i;
299
 
300
  if (!list)
301
    {
302
      if (t && TREE_CODE (t) == STATEMENT_LIST)
303
        {
304
          *list_p = t;
305
          return;
306
        }
307
      *list_p = list = alloc_stmt_list ();
308
    }
309
 
310
  i = tsi_last (list);
311
  tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
312
}
313
 
314
/* Add T to the end of the list container pointed to by LIST_P.
315
   If T is an expression with no effects, it is ignored.  */
316
 
317
void
318
append_to_statement_list (tree t, tree *list_p)
319
{
320
  if (t && TREE_SIDE_EFFECTS (t))
321
    append_to_statement_list_1 (t, list_p);
322
}
323
 
324
/* Similar, but the statement is always added, regardless of side effects.  */
325
 
326
void
327
append_to_statement_list_force (tree t, tree *list_p)
328
{
329
  if (t != NULL_TREE)
330
    append_to_statement_list_1 (t, list_p);
331
}
332
 
333
/* Both gimplify the statement T and append it to LIST_P.  */
334
 
335
void
336
gimplify_and_add (tree t, tree *list_p)
337
{
338
  gimplify_stmt (&t);
339
  append_to_statement_list (t, list_p);
340
}
341
 
342
/* Strip off a legitimate source ending from the input string NAME of
343
   length LEN.  Rather than having to know the names used by all of
344
   our front ends, we strip off an ending of a period followed by
345
   up to five characters.  (Java uses ".class".)  */
346
 
347
static inline void
348
remove_suffix (char *name, int len)
349
{
350
  int i;
351
 
352
  for (i = 2;  i < 8 && len > i;  i++)
353
    {
354
      if (name[len - i] == '.')
355
        {
356
          name[len - i] = '\0';
357
          break;
358
        }
359
    }
360
}
361
 
362
/* Create a nameless artificial label and put it in the current function
363
   context.  Returns the newly created label.  */
364
 
365
tree
366
create_artificial_label (void)
367
{
368
  tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node);
369
 
370
  DECL_ARTIFICIAL (lab) = 1;
371
  DECL_IGNORED_P (lab) = 1;
372
  DECL_CONTEXT (lab) = current_function_decl;
373
  return lab;
374
}
375
 
376
/* Subroutine for find_single_pointer_decl.  */
377
 
378
static tree
379
find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
380
                            void *data)
381
{
382
  tree *pdecl = (tree *) data;
383
 
384
  if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp)))
385
    {
386
      if (*pdecl)
387
        {
388
          /* We already found a pointer decl; return anything other
389
             than NULL_TREE to unwind from walk_tree signalling that
390
             we have a duplicate.  */
391
          return *tp;
392
        }
393
      *pdecl = *tp;
394
    }
395
 
396
  return NULL_TREE;
397
}
398
 
399
/* Find the single DECL of pointer type in the tree T and return it.
400
   If there are zero or more than one such DECLs, return NULL.  */
401
 
402
static tree
403
find_single_pointer_decl (tree t)
404
{
405
  tree decl = NULL_TREE;
406
 
407
  if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL))
408
    {
409
      /* find_single_pointer_decl_1 returns a nonzero value, causing
410
         walk_tree to return a nonzero value, to indicate that it
411
         found more than one pointer DECL.  */
412
      return NULL_TREE;
413
    }
414
 
415
  return decl;
416
}
417
 
418
/* Create a new temporary name with PREFIX.  Returns an identifier.  */
419
 
420
static GTY(()) unsigned int tmp_var_id_num;
421
 
422
tree
423
create_tmp_var_name (const char *prefix)
424
{
425
  char *tmp_name;
426
 
427
  if (prefix)
428
    {
429
      char *preftmp = ASTRDUP (prefix);
430
 
431
      remove_suffix (preftmp, strlen (preftmp));
432
      prefix = preftmp;
433
    }
434
 
435
  ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
436
  return get_identifier (tmp_name);
437
}
438
 
439
 
440
/* Create a new temporary variable declaration of type TYPE.
441
   Does NOT push it into the current binding.  */
442
 
443
tree
444
create_tmp_var_raw (tree type, const char *prefix)
445
{
446
  tree tmp_var;
447
  tree new_type;
448
 
449
  /* Make the type of the variable writable.  */
450
  new_type = build_type_variant (type, 0, 0);
451
  TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
452
 
453
  tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
454
                        type);
455
 
456
  /* The variable was declared by the compiler.  */
457
  DECL_ARTIFICIAL (tmp_var) = 1;
458
  /* And we don't want debug info for it.  */
459
  DECL_IGNORED_P (tmp_var) = 1;
460
 
461
  /* Make the variable writable.  */
462
  TREE_READONLY (tmp_var) = 0;
463
 
464
  DECL_EXTERNAL (tmp_var) = 0;
465
  TREE_STATIC (tmp_var) = 0;
466
  TREE_USED (tmp_var) = 1;
467
 
468
  return tmp_var;
469
}
470
 
471
/* Create a new temporary variable declaration of type TYPE.  DOES push the
472
   variable into the current binding.  Further, assume that this is called
473
   only from gimplification or optimization, at which point the creation of
474
   certain types are bugs.  */
475
 
476
tree
477
create_tmp_var (tree type, const char *prefix)
478
{
479
  tree tmp_var;
480
 
481
  /* We don't allow types that are addressable (meaning we can't make copies),
482
     or incomplete.  We also used to reject every variable size objects here,
483
     but now support those for which a constant upper bound can be obtained.
484
     The processing for variable sizes is performed in gimple_add_tmp_var,
485
     point at which it really matters and possibly reached via paths not going
486
     through this function, e.g. after direct calls to create_tmp_var_raw.  */
487
  gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
488
 
489
  tmp_var = create_tmp_var_raw (type, prefix);
490
  gimple_add_tmp_var (tmp_var);
491
  return tmp_var;
492
}
493
 
494
/*  Given a tree, try to return a useful variable name that we can use
495
    to prefix a temporary that is being assigned the value of the tree.
496
    I.E. given  <temp> = &A, return A.  */
497
 
498
const char *
499
get_name (tree t)
500
{
501
  tree stripped_decl;
502
 
503
  stripped_decl = t;
504
  STRIP_NOPS (stripped_decl);
505
  if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
506
    return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
507
  else
508
    {
509
      switch (TREE_CODE (stripped_decl))
510
        {
511
        case ADDR_EXPR:
512
          return get_name (TREE_OPERAND (stripped_decl, 0));
513
          break;
514
        default:
515
          return NULL;
516
        }
517
    }
518
}
519
 
520
/* Create a temporary with a name derived from VAL.  Subroutine of
521
   lookup_tmp_var; nobody else should call this function.  */
522
 
523
static inline tree
524
create_tmp_from_val (tree val)
525
{
526
  return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val));
527
}
528
 
529
/* Create a temporary to hold the value of VAL.  If IS_FORMAL, try to reuse
530
   an existing expression temporary.  */
531
 
532
static tree
533
lookup_tmp_var (tree val, bool is_formal)
534
{
535
  tree ret;
536
 
537
  /* If not optimizing, never really reuse a temporary.  local-alloc
538
     won't allocate any variable that is used in more than one basic
539
     block, which means it will go into memory, causing much extra
540
     work in reload and final and poorer code generation, outweighing
541
     the extra memory allocation here.  */
542
  if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
543
    ret = create_tmp_from_val (val);
544
  else
545
    {
546
      elt_t elt, *elt_p;
547
      void **slot;
548
 
549
      elt.val = val;
550
      slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
551
      if (*slot == NULL)
552
        {
553
          elt_p = XNEW (elt_t);
554
          elt_p->val = val;
555
          elt_p->temp = ret = create_tmp_from_val (val);
556
          *slot = (void *) elt_p;
557
        }
558
      else
559
        {
560
          elt_p = (elt_t *) *slot;
561
          ret = elt_p->temp;
562
        }
563
    }
564
 
565
  if (is_formal)
566
    DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1;
567
 
568
  return ret;
569
}
570
 
571
/* Returns a formal temporary variable initialized with VAL.  PRE_P is as
572
   in gimplify_expr.  Only use this function if:
573
 
574
   1) The value of the unfactored expression represented by VAL will not
575
      change between the initialization and use of the temporary, and
576
   2) The temporary will not be otherwise modified.
577
 
578
   For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
579
   and #2 means it is inappropriate for && temps.
580
 
581
   For other cases, use get_initialized_tmp_var instead.  */
582
 
583
static tree
584
internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal)
585
{
586
  tree t, mod;
587
 
588
  gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_rhs, fb_rvalue);
589
 
590
  t = lookup_tmp_var (val, is_formal);
591
 
592
  if (is_formal)
593
    {
594
      tree u = find_single_pointer_decl (val);
595
 
596
      if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u))
597
        u = DECL_GET_RESTRICT_BASE (u);
598
      if (u && TYPE_RESTRICT (TREE_TYPE (u)))
599
        {
600
          if (DECL_BASED_ON_RESTRICT_P (t))
601
            gcc_assert (u == DECL_GET_RESTRICT_BASE (t));
602
          else
603
            {
604
              DECL_BASED_ON_RESTRICT_P (t) = 1;
605
              SET_DECL_RESTRICT_BASE (t, u);
606
            }
607
        }
608
    }
609
 
610
  if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE)
611
    DECL_COMPLEX_GIMPLE_REG_P (t) = 1;
612
 
613
  mod = build2 (INIT_EXPR, TREE_TYPE (t), t, val);
614
 
615
  if (EXPR_HAS_LOCATION (val))
616
    SET_EXPR_LOCUS (mod, EXPR_LOCUS (val));
617
  else
618
    SET_EXPR_LOCATION (mod, input_location);
619
 
620
  /* gimplify_modify_expr might want to reduce this further.  */
621
  gimplify_and_add (mod, pre_p);
622
 
623
  /* If we're gimplifying into ssa, gimplify_modify_expr will have
624
     given our temporary an ssa name.  Find and return it.  */
625
  if (gimplify_ctxp->into_ssa)
626
    t = TREE_OPERAND (mod, 0);
627
 
628
  return t;
629
}
630
 
631
/* Returns a formal temporary variable initialized with VAL.  PRE_P
632
   points to a statement list where side-effects needed to compute VAL
633
   should be stored.  */
634
 
635
tree
636
get_formal_tmp_var (tree val, tree *pre_p)
637
{
638
  return internal_get_tmp_var (val, pre_p, NULL, true);
639
}
640
 
641
/* Returns a temporary variable initialized with VAL.  PRE_P and POST_P
642
   are as in gimplify_expr.  */
643
 
644
tree
645
get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p)
646
{
647
  return internal_get_tmp_var (val, pre_p, post_p, false);
648
}
649
 
650
/* Declares all the variables in VARS in SCOPE.  If DEBUG_INFO is
651
   true, generate debug info for them; otherwise don't.  */
652
 
653
void
654
declare_vars (tree vars, tree scope, bool debug_info)
655
{
656
  tree last = vars;
657
  if (last)
658
    {
659
      tree temps, block;
660
 
661
      /* C99 mode puts the default 'return 0;' for main outside the outer
662
         braces.  So drill down until we find an actual scope.  */
663
      while (TREE_CODE (scope) == COMPOUND_EXPR)
664
        scope = TREE_OPERAND (scope, 0);
665
 
666
      gcc_assert (TREE_CODE (scope) == BIND_EXPR);
667
 
668
      temps = nreverse (last);
669
 
670
      block = BIND_EXPR_BLOCK (scope);
671
      if (!block || !debug_info)
672
        {
673
          TREE_CHAIN (last) = BIND_EXPR_VARS (scope);
674
          BIND_EXPR_VARS (scope) = temps;
675
        }
676
      else
677
        {
678
          /* We need to attach the nodes both to the BIND_EXPR and to its
679
             associated BLOCK for debugging purposes.  The key point here
680
             is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
681
             is a subchain of the BIND_EXPR_VARS of the BIND_EXPR.  */
682
          if (BLOCK_VARS (block))
683
            BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
684
          else
685
            {
686
              BIND_EXPR_VARS (scope) = chainon (BIND_EXPR_VARS (scope), temps);
687
              BLOCK_VARS (block) = temps;
688
            }
689
        }
690
    }
691
}
692
 
693
/* For VAR a VAR_DECL of variable size, try to find a constant upper bound
694
   for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly.  Abort if
695
   no such upper bound can be obtained.  */
696
 
697
static void
698
force_constant_size (tree var)
699
{
700
  /* The only attempt we make is by querying the maximum size of objects
701
     of the variable's type.  */
702
 
703
  HOST_WIDE_INT max_size;
704
 
705
  gcc_assert (TREE_CODE (var) == VAR_DECL);
706
 
707
  max_size = max_int_size_in_bytes (TREE_TYPE (var));
708
 
709
  gcc_assert (max_size >= 0);
710
 
711
  DECL_SIZE_UNIT (var)
712
    = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
713
  DECL_SIZE (var)
714
    = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
715
}
716
 
717
void
718
gimple_add_tmp_var (tree tmp)
719
{
720
  gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
721
 
722
  /* Later processing assumes that the object size is constant, which might
723
     not be true at this point.  Force the use of a constant upper bound in
724
     this case.  */
725
  if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
726
    force_constant_size (tmp);
727
 
728
  DECL_CONTEXT (tmp) = current_function_decl;
729
  DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
730
 
731
  if (gimplify_ctxp)
732
    {
733
      TREE_CHAIN (tmp) = gimplify_ctxp->temps;
734
      gimplify_ctxp->temps = tmp;
735
 
736
      /* Mark temporaries local within the nearest enclosing parallel.  */
737
      if (gimplify_omp_ctxp)
738
        {
739
          struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
740
          while (ctx && !ctx->is_parallel)
741
            ctx = ctx->outer_context;
742
          if (ctx)
743
            omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
744
        }
745
    }
746
  else if (cfun)
747
    record_vars (tmp);
748
  else
749
    declare_vars (tmp, DECL_SAVED_TREE (current_function_decl), false);
750
}
751
 
752
/* Determines whether to assign a locus to the statement STMT.  */
753
 
754
static bool
755
should_carry_locus_p (tree stmt)
756
{
757
  /* Don't emit a line note for a label.  We particularly don't want to
758
     emit one for the break label, since it doesn't actually correspond
759
     to the beginning of the loop/switch.  */
760
  if (TREE_CODE (stmt) == LABEL_EXPR)
761
    return false;
762
 
763
  /* Do not annotate empty statements, since it confuses gcov.  */
764
  if (!TREE_SIDE_EFFECTS (stmt))
765
    return false;
766
 
767
  return true;
768
}
769
 
770
static void
771
annotate_one_with_locus (tree t, location_t locus)
772
{
773
  if (EXPR_P (t) && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t))
774
    SET_EXPR_LOCATION (t, locus);
775
}
776
 
777
void
778
annotate_all_with_locus (tree *stmt_p, location_t locus)
779
{
780
  tree_stmt_iterator i;
781
 
782
  if (!*stmt_p)
783
    return;
784
 
785
  for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i))
786
    {
787
      tree t = tsi_stmt (i);
788
 
789
      /* Assuming we've already been gimplified, we shouldn't
790
          see nested chaining constructs anymore.  */
791
      gcc_assert (TREE_CODE (t) != STATEMENT_LIST
792
                  && TREE_CODE (t) != COMPOUND_EXPR);
793
 
794
      annotate_one_with_locus (t, locus);
795
    }
796
}
797
 
798
/* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
799
   These nodes model computations that should only be done once.  If we
800
   were to unshare something like SAVE_EXPR(i++), the gimplification
801
   process would create wrong code.  */
802
 
803
static tree
804
mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
805
{
806
  enum tree_code code = TREE_CODE (*tp);
807
  /* Don't unshare types, decls, constants and SAVE_EXPR nodes.  */
808
  if (TREE_CODE_CLASS (code) == tcc_type
809
      || TREE_CODE_CLASS (code) == tcc_declaration
810
      || TREE_CODE_CLASS (code) == tcc_constant
811
      || code == SAVE_EXPR || code == TARGET_EXPR
812
      /* We can't do anything sensible with a BLOCK used as an expression,
813
         but we also can't just die when we see it because of non-expression
814
         uses.  So just avert our eyes and cross our fingers.  Silly Java.  */
815
      || code == BLOCK)
816
    *walk_subtrees = 0;
817
  else
818
    {
819
      gcc_assert (code != BIND_EXPR);
820
      copy_tree_r (tp, walk_subtrees, data);
821
    }
822
 
823
  return NULL_TREE;
824
}
825
 
826
/* Callback for walk_tree to unshare most of the shared trees rooted at
827
   *TP.  If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
828
   then *TP is deep copied by calling copy_tree_r.
829
 
830
   This unshares the same trees as copy_tree_r with the exception of
831
   SAVE_EXPR nodes.  These nodes model computations that should only be
832
   done once.  If we were to unshare something like SAVE_EXPR(i++), the
833
   gimplification process would create wrong code.  */
834
 
835
static tree
836
copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
837
                  void *data ATTRIBUTE_UNUSED)
838
{
839
  tree t = *tp;
840
  enum tree_code code = TREE_CODE (t);
841
 
842
  /* Skip types, decls, and constants.  But we do want to look at their
843
     types and the bounds of types.  Mark them as visited so we properly
844
     unmark their subtrees on the unmark pass.  If we've already seen them,
845
     don't look down further.  */
846
  if (TREE_CODE_CLASS (code) == tcc_type
847
      || TREE_CODE_CLASS (code) == tcc_declaration
848
      || TREE_CODE_CLASS (code) == tcc_constant)
849
    {
850
      if (TREE_VISITED (t))
851
        *walk_subtrees = 0;
852
      else
853
        TREE_VISITED (t) = 1;
854
    }
855
 
856
  /* If this node has been visited already, unshare it and don't look
857
     any deeper.  */
858
  else if (TREE_VISITED (t))
859
    {
860
      walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
861
      *walk_subtrees = 0;
862
    }
863
 
864
  /* Otherwise, mark the tree as visited and keep looking.  */
865
  else
866
    TREE_VISITED (t) = 1;
867
 
868
  return NULL_TREE;
869
}
870
 
871
static tree
872
unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
873
                  void *data ATTRIBUTE_UNUSED)
874
{
875
  if (TREE_VISITED (*tp))
876
    TREE_VISITED (*tp) = 0;
877
  else
878
    *walk_subtrees = 0;
879
 
880
  return NULL_TREE;
881
}
882
 
883
/* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
884
   bodies of any nested functions if we are unsharing the entire body of
885
   FNDECL.  */
886
 
887
static void
888
unshare_body (tree *body_p, tree fndecl)
889
{
890
  struct cgraph_node *cgn = cgraph_node (fndecl);
891
 
892
  walk_tree (body_p, copy_if_shared_r, NULL, NULL);
893
  if (body_p == &DECL_SAVED_TREE (fndecl))
894
    for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
895
      unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
896
}
897
 
898
/* Likewise, but mark all trees as not visited.  */
899
 
900
static void
901
unvisit_body (tree *body_p, tree fndecl)
902
{
903
  struct cgraph_node *cgn = cgraph_node (fndecl);
904
 
905
  walk_tree (body_p, unmark_visited_r, NULL, NULL);
906
  if (body_p == &DECL_SAVED_TREE (fndecl))
907
    for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
908
      unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
909
}
910
 
911
/* Unshare T and all the trees reached from T via TREE_CHAIN.  */
912
 
913
static void
914
unshare_all_trees (tree t)
915
{
916
  walk_tree (&t, copy_if_shared_r, NULL, NULL);
917
  walk_tree (&t, unmark_visited_r, NULL, NULL);
918
}
919
 
920
/* Unconditionally make an unshared copy of EXPR.  This is used when using
921
   stored expressions which span multiple functions, such as BINFO_VTABLE,
922
   as the normal unsharing process can't tell that they're shared.  */
923
 
924
tree
925
unshare_expr (tree expr)
926
{
927
  walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
928
  return expr;
929
}
930
 
931
/* A terser interface for building a representation of an exception
932
   specification.  */
933
 
934
tree
935
gimple_build_eh_filter (tree body, tree allowed, tree failure)
936
{
937
  tree t;
938
 
939
  /* FIXME should the allowed types go in TREE_TYPE?  */
940
  t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
941
  append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
942
 
943
  t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
944
  append_to_statement_list (body, &TREE_OPERAND (t, 0));
945
 
946
  return t;
947
}
948
 
949
 
950
/* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
951
   contain statements and have a value.  Assign its value to a temporary
952
   and give it void_type_node.  Returns the temporary, or NULL_TREE if
953
   WRAPPER was already void.  */
954
 
955
tree
956
voidify_wrapper_expr (tree wrapper, tree temp)
957
{
958
  tree type = TREE_TYPE (wrapper);
959
  if (type && !VOID_TYPE_P (type))
960
    {
961
      tree *p;
962
 
963
      /* Set p to point to the body of the wrapper.  Loop until we find
964
         something that isn't a wrapper.  */
965
      for (p = &wrapper; p && *p; )
966
        {
967
          switch (TREE_CODE (*p))
968
            {
969
            case BIND_EXPR:
970
              TREE_SIDE_EFFECTS (*p) = 1;
971
              TREE_TYPE (*p) = void_type_node;
972
              /* For a BIND_EXPR, the body is operand 1.  */
973
              p = &BIND_EXPR_BODY (*p);
974
              break;
975
 
976
            case CLEANUP_POINT_EXPR:
977
            case TRY_FINALLY_EXPR:
978
            case TRY_CATCH_EXPR:
979
              TREE_SIDE_EFFECTS (*p) = 1;
980
              TREE_TYPE (*p) = void_type_node;
981
              p = &TREE_OPERAND (*p, 0);
982
              break;
983
 
984
            case STATEMENT_LIST:
985
              {
986
                tree_stmt_iterator i = tsi_last (*p);
987
                TREE_SIDE_EFFECTS (*p) = 1;
988
                TREE_TYPE (*p) = void_type_node;
989
                p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
990
              }
991
              break;
992
 
993
            case COMPOUND_EXPR:
994
              /* Advance to the last statement.  Set all container types to void.  */
995
              for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
996
                {
997
                  TREE_SIDE_EFFECTS (*p) = 1;
998
                  TREE_TYPE (*p) = void_type_node;
999
                }
1000
              break;
1001
 
1002
            default:
1003
              goto out;
1004
            }
1005
        }
1006
 
1007
    out:
1008
      if (p == NULL || IS_EMPTY_STMT (*p))
1009
        temp = NULL_TREE;
1010
      else if (temp)
1011
        {
1012
          /* The wrapper is on the RHS of an assignment that we're pushing
1013
             down.  */
1014
          gcc_assert (TREE_CODE (temp) == INIT_EXPR
1015
                      || TREE_CODE (temp) == MODIFY_EXPR);
1016
          TREE_OPERAND (temp, 1) = *p;
1017
          *p = temp;
1018
        }
1019
      else
1020
        {
1021
          temp = create_tmp_var (type, "retval");
1022
          *p = build2 (INIT_EXPR, type, temp, *p);
1023
        }
1024
 
1025
      return temp;
1026
    }
1027
 
1028
  return NULL_TREE;
1029
}
1030
 
1031
/* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1032
   a temporary through which they communicate.  */
1033
 
1034
static void
1035
build_stack_save_restore (tree *save, tree *restore)
1036
{
1037
  tree save_call, tmp_var;
1038
 
1039
  save_call =
1040
      build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE],
1041
                                NULL_TREE);
1042
  tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1043
 
1044
  *save = build2 (MODIFY_EXPR, ptr_type_node, tmp_var, save_call);
1045
  *restore =
1046
    build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
1047
                              tree_cons (NULL_TREE, tmp_var, NULL_TREE));
1048
}
1049
 
1050
/* Gimplify a BIND_EXPR.  Just voidify and recurse.  */
1051
 
1052
static enum gimplify_status
1053
gimplify_bind_expr (tree *expr_p, tree *pre_p)
1054
{
1055
  tree bind_expr = *expr_p;
1056
  bool old_save_stack = gimplify_ctxp->save_stack;
1057
  tree t;
1058
 
1059
  tree temp = voidify_wrapper_expr (bind_expr, NULL);
1060
 
1061
  /* Mark variables seen in this bind expr.  */
1062
  for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
1063
    {
1064
      if (TREE_CODE (t) == VAR_DECL)
1065
        {
1066
          struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1067
 
1068
          /* Mark variable as local.  */
1069
          if (ctx && !is_global_var (t)
1070
              && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1071
                  || splay_tree_lookup (ctx->variables,
1072
                                        (splay_tree_key) t) == NULL))
1073
            omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1074
 
1075
          DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1076
        }
1077
 
1078
      /* Preliminarily mark non-addressed complex variables as eligible
1079
         for promotion to gimple registers.  We'll transform their uses
1080
         as we find them.  */
1081
      if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1082
          && !TREE_THIS_VOLATILE (t)
1083
          && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1084
          && !needs_to_live_in_memory (t))
1085
        DECL_COMPLEX_GIMPLE_REG_P (t) = 1;
1086
    }
1087
 
1088
  gimple_push_bind_expr (bind_expr);
1089
  gimplify_ctxp->save_stack = false;
1090
 
1091
  gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr));
1092
 
1093
  if (gimplify_ctxp->save_stack)
1094
    {
1095
      tree stack_save, stack_restore;
1096
 
1097
      /* Save stack on entry and restore it on exit.  Add a try_finally
1098
         block to achieve this.  Note that mudflap depends on the
1099
         format of the emitted code: see mx_register_decls().  */
1100
      build_stack_save_restore (&stack_save, &stack_restore);
1101
 
1102
      t = build2 (TRY_FINALLY_EXPR, void_type_node,
1103
                  BIND_EXPR_BODY (bind_expr), NULL_TREE);
1104
      append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1));
1105
 
1106
      BIND_EXPR_BODY (bind_expr) = NULL_TREE;
1107
      append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr));
1108
      append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr));
1109
    }
1110
 
1111
  gimplify_ctxp->save_stack = old_save_stack;
1112
  gimple_pop_bind_expr ();
1113
 
1114
  if (temp)
1115
    {
1116
      *expr_p = temp;
1117
      append_to_statement_list (bind_expr, pre_p);
1118
      return GS_OK;
1119
    }
1120
  else
1121
    return GS_ALL_DONE;
1122
}
1123
 
1124
/* Gimplify a RETURN_EXPR.  If the expression to be returned is not a
1125
   GIMPLE value, it is assigned to a new temporary and the statement is
1126
   re-written to return the temporary.
1127
 
1128
   PRE_P points to the list where side effects that must happen before
1129
   STMT should be stored.  */
1130
 
1131
static enum gimplify_status
1132
gimplify_return_expr (tree stmt, tree *pre_p)
1133
{
1134
  tree ret_expr = TREE_OPERAND (stmt, 0);
1135
  tree result_decl, result;
1136
 
1137
  if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL
1138
      || ret_expr == error_mark_node)
1139
    return GS_ALL_DONE;
1140
 
1141
  if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1142
    result_decl = NULL_TREE;
1143
  else
1144
    {
1145
      result_decl = TREE_OPERAND (ret_expr, 0);
1146
      if (TREE_CODE (result_decl) == INDIRECT_REF)
1147
        /* See through a return by reference.  */
1148
        result_decl = TREE_OPERAND (result_decl, 0);
1149
 
1150
      gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1151
                   || TREE_CODE (ret_expr) == INIT_EXPR)
1152
                  && TREE_CODE (result_decl) == RESULT_DECL);
1153
    }
1154
 
1155
  /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1156
     Recall that aggregate_value_p is FALSE for any aggregate type that is
1157
     returned in registers.  If we're returning values in registers, then
1158
     we don't want to extend the lifetime of the RESULT_DECL, particularly
1159
     across another call.  In addition, for those aggregates for which
1160
     hard_function_value generates a PARALLEL, we'll die during normal
1161
     expansion of structure assignments; there's special code in expand_return
1162
     to handle this case that does not exist in expand_expr.  */
1163
  if (!result_decl
1164
      || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1165
    result = result_decl;
1166
  else if (gimplify_ctxp->return_temp)
1167
    result = gimplify_ctxp->return_temp;
1168
  else
1169
    {
1170
      result = create_tmp_var (TREE_TYPE (result_decl), NULL);
1171
 
1172
      /* ??? With complex control flow (usually involving abnormal edges),
1173
         we can wind up warning about an uninitialized value for this.  Due
1174
         to how this variable is constructed and initialized, this is never
1175
         true.  Give up and never warn.  */
1176
      TREE_NO_WARNING (result) = 1;
1177
 
1178
      gimplify_ctxp->return_temp = result;
1179
    }
1180
 
1181
  /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1182
     Then gimplify the whole thing.  */
1183
  if (result != result_decl)
1184
    TREE_OPERAND (ret_expr, 0) = result;
1185
 
1186
  gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1187
 
1188
  /* If we didn't use a temporary, then the result is just the result_decl.
1189
     Otherwise we need a simple copy.  This should already be gimple.  */
1190
  if (result == result_decl)
1191
    ret_expr = result;
1192
  else
1193
    ret_expr = build2 (MODIFY_EXPR, TREE_TYPE (result), result_decl, result);
1194
  TREE_OPERAND (stmt, 0) = ret_expr;
1195
 
1196
  return GS_ALL_DONE;
1197
}
1198
 
1199
/* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1200
   and initialization explicit.  */
1201
 
1202
static enum gimplify_status
1203
gimplify_decl_expr (tree *stmt_p)
1204
{
1205
  tree stmt = *stmt_p;
1206
  tree decl = DECL_EXPR_DECL (stmt);
1207
 
1208
  *stmt_p = NULL_TREE;
1209
 
1210
  if (TREE_TYPE (decl) == error_mark_node)
1211
    return GS_ERROR;
1212
 
1213
  if ((TREE_CODE (decl) == TYPE_DECL
1214
       || TREE_CODE (decl) == VAR_DECL)
1215
      && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1216
    gimplify_type_sizes (TREE_TYPE (decl), stmt_p);
1217
 
1218
  if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1219
    {
1220
      tree init = DECL_INITIAL (decl);
1221
 
1222
      if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
1223
        {
1224
          /* This is a variable-sized decl.  Simplify its size and mark it
1225
             for deferred expansion.  Note that mudflap depends on the format
1226
             of the emitted code: see mx_register_decls().  */
1227
          tree t, args, addr, ptr_type;
1228
 
1229
          gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p);
1230
          gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p);
1231
 
1232
          /* All occurrences of this decl in final gimplified code will be
1233
             replaced by indirection.  Setting DECL_VALUE_EXPR does two
1234
             things: First, it lets the rest of the gimplifier know what
1235
             replacement to use.  Second, it lets the debug info know
1236
             where to find the value.  */
1237
          ptr_type = build_pointer_type (TREE_TYPE (decl));
1238
          addr = create_tmp_var (ptr_type, get_name (decl));
1239
          DECL_IGNORED_P (addr) = 0;
1240
          t = build_fold_indirect_ref (addr);
1241
          SET_DECL_VALUE_EXPR (decl, t);
1242
          DECL_HAS_VALUE_EXPR_P (decl) = 1;
1243
 
1244
          args = tree_cons (NULL, DECL_SIZE_UNIT (decl), NULL);
1245
          t = built_in_decls[BUILT_IN_ALLOCA];
1246
          t = build_function_call_expr (t, args);
1247
          t = fold_convert (ptr_type, t);
1248
          t = build2 (MODIFY_EXPR, void_type_node, addr, t);
1249
 
1250
          gimplify_and_add (t, stmt_p);
1251
 
1252
          /* Indicate that we need to restore the stack level when the
1253
             enclosing BIND_EXPR is exited.  */
1254
          gimplify_ctxp->save_stack = true;
1255
        }
1256
 
1257
      if (init && init != error_mark_node)
1258
        {
1259
          if (!TREE_STATIC (decl))
1260
            {
1261
              DECL_INITIAL (decl) = NULL_TREE;
1262
              init = build2 (INIT_EXPR, void_type_node, decl, init);
1263
              gimplify_and_add (init, stmt_p);
1264
            }
1265
          else
1266
            /* We must still examine initializers for static variables
1267
               as they may contain a label address.  */
1268
            walk_tree (&init, force_labels_r, NULL, NULL);
1269
        }
1270
 
1271
      /* Some front ends do not explicitly declare all anonymous
1272
         artificial variables.  We compensate here by declaring the
1273
         variables, though it would be better if the front ends would
1274
         explicitly declare them.  */
1275
      if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1276
          && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1277
        gimple_add_tmp_var (decl);
1278
    }
1279
 
1280
  return GS_ALL_DONE;
1281
}
1282
 
1283
/* Gimplify a LOOP_EXPR.  Normally this just involves gimplifying the body
1284
   and replacing the LOOP_EXPR with goto, but if the loop contains an
1285
   EXIT_EXPR, we need to append a label for it to jump to.  */
1286
 
1287
static enum gimplify_status
1288
gimplify_loop_expr (tree *expr_p, tree *pre_p)
1289
{
1290
  tree saved_label = gimplify_ctxp->exit_label;
1291
  tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
1292
  tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label));
1293
 
1294
  append_to_statement_list (start_label, pre_p);
1295
 
1296
  gimplify_ctxp->exit_label = NULL_TREE;
1297
 
1298
  gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1299
 
1300
  if (gimplify_ctxp->exit_label)
1301
    {
1302
      append_to_statement_list (jump_stmt, pre_p);
1303
      *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label);
1304
    }
1305
  else
1306
    *expr_p = jump_stmt;
1307
 
1308
  gimplify_ctxp->exit_label = saved_label;
1309
 
1310
  return GS_ALL_DONE;
1311
}
1312
 
1313
/* Compare two case labels.  Because the front end should already have
1314
   made sure that case ranges do not overlap, it is enough to only compare
1315
   the CASE_LOW values of each case label.  */
1316
 
1317
static int
1318
compare_case_labels (const void *p1, const void *p2)
1319
{
1320
  tree case1 = *(tree *)p1;
1321
  tree case2 = *(tree *)p2;
1322
 
1323
  return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1324
}
1325
 
1326
/* Sort the case labels in LABEL_VEC in place in ascending order.  */
1327
 
1328
void
1329
sort_case_labels (tree label_vec)
1330
{
1331
  size_t len = TREE_VEC_LENGTH (label_vec);
1332
  tree default_case = TREE_VEC_ELT (label_vec, len - 1);
1333
 
1334
  if (CASE_LOW (default_case))
1335
    {
1336
      size_t i;
1337
 
1338
      /* The last label in the vector should be the default case
1339
         but it is not.  */
1340
      for (i = 0; i < len; ++i)
1341
        {
1342
          tree t = TREE_VEC_ELT (label_vec, i);
1343
          if (!CASE_LOW (t))
1344
            {
1345
              default_case = t;
1346
              TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1);
1347
              TREE_VEC_ELT (label_vec, len - 1) = default_case;
1348
              break;
1349
            }
1350
        }
1351
    }
1352
 
1353
  qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree),
1354
         compare_case_labels);
1355
}
1356
 
1357
/* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1358
   branch to.  */
1359
 
1360
static enum gimplify_status
1361
gimplify_switch_expr (tree *expr_p, tree *pre_p)
1362
{
1363
  tree switch_expr = *expr_p;
1364
  enum gimplify_status ret;
1365
 
1366
  ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL,
1367
                       is_gimple_val, fb_rvalue);
1368
 
1369
  if (SWITCH_BODY (switch_expr))
1370
    {
1371
      VEC(tree,heap) *labels, *saved_labels;
1372
      tree label_vec, default_case = NULL_TREE;
1373
      size_t i, len;
1374
 
1375
      /* If someone can be bothered to fill in the labels, they can
1376
         be bothered to null out the body too.  */
1377
      gcc_assert (!SWITCH_LABELS (switch_expr));
1378
 
1379
      saved_labels = gimplify_ctxp->case_labels;
1380
      gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1381
 
1382
      gimplify_to_stmt_list (&SWITCH_BODY (switch_expr));
1383
 
1384
      labels = gimplify_ctxp->case_labels;
1385
      gimplify_ctxp->case_labels = saved_labels;
1386
 
1387
      i = 0;
1388
      while (i < VEC_length (tree, labels))
1389
        {
1390
          tree elt = VEC_index (tree, labels, i);
1391
          tree low = CASE_LOW (elt);
1392
          bool remove_element = FALSE;
1393
 
1394
          if (low)
1395
            {
1396
              /* Discard empty ranges.  */
1397
              tree high = CASE_HIGH (elt);
1398
              if (high && INT_CST_LT (high, low))
1399
                remove_element = TRUE;
1400
            }
1401
          else
1402
            {
1403
              /* The default case must be the last label in the list.  */
1404
              gcc_assert (!default_case);
1405
              default_case = elt;
1406
              remove_element = TRUE;
1407
            }
1408
 
1409
          if (remove_element)
1410
            VEC_ordered_remove (tree, labels, i);
1411
          else
1412
            i++;
1413
        }
1414
      len = i;
1415
 
1416
      label_vec = make_tree_vec (len + 1);
1417
      SWITCH_LABELS (*expr_p) = label_vec;
1418
      append_to_statement_list (switch_expr, pre_p);
1419
 
1420
      if (! default_case)
1421
        {
1422
          /* If the switch has no default label, add one, so that we jump
1423
             around the switch body.  */
1424
          default_case = build3 (CASE_LABEL_EXPR, void_type_node, NULL_TREE,
1425
                                 NULL_TREE, create_artificial_label ());
1426
          append_to_statement_list (SWITCH_BODY (switch_expr), pre_p);
1427
          *expr_p = build1 (LABEL_EXPR, void_type_node,
1428
                            CASE_LABEL (default_case));
1429
        }
1430
      else
1431
        *expr_p = SWITCH_BODY (switch_expr);
1432
 
1433
      for (i = 0; i < len; ++i)
1434
        TREE_VEC_ELT (label_vec, i) = VEC_index (tree, labels, i);
1435
      TREE_VEC_ELT (label_vec, len) = default_case;
1436
 
1437
      VEC_free (tree, heap, labels);
1438
 
1439
      sort_case_labels (label_vec);
1440
 
1441
      SWITCH_BODY (switch_expr) = NULL;
1442
    }
1443
  else
1444
    gcc_assert (SWITCH_LABELS (switch_expr));
1445
 
1446
  return ret;
1447
}
1448
 
1449
static enum gimplify_status
1450
gimplify_case_label_expr (tree *expr_p)
1451
{
1452
  tree expr = *expr_p;
1453
  struct gimplify_ctx *ctxp;
1454
 
1455
  /* Invalid OpenMP programs can play Duff's Device type games with
1456
     #pragma omp parallel.  At least in the C front end, we don't
1457
     detect such invalid branches until after gimplification.  */
1458
  for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1459
    if (ctxp->case_labels)
1460
      break;
1461
 
1462
  VEC_safe_push (tree, heap, ctxp->case_labels, expr);
1463
  *expr_p = build1 (LABEL_EXPR, void_type_node, CASE_LABEL (expr));
1464
  return GS_ALL_DONE;
1465
}
1466
 
1467
/* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1468
   if necessary.  */
1469
 
1470
tree
1471
build_and_jump (tree *label_p)
1472
{
1473
  if (label_p == NULL)
1474
    /* If there's nowhere to jump, just fall through.  */
1475
    return NULL_TREE;
1476
 
1477
  if (*label_p == NULL_TREE)
1478
    {
1479
      tree label = create_artificial_label ();
1480
      *label_p = label;
1481
    }
1482
 
1483
  return build1 (GOTO_EXPR, void_type_node, *label_p);
1484
}
1485
 
1486
/* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1487
   This also involves building a label to jump to and communicating it to
1488
   gimplify_loop_expr through gimplify_ctxp->exit_label.  */
1489
 
1490
static enum gimplify_status
1491
gimplify_exit_expr (tree *expr_p)
1492
{
1493
  tree cond = TREE_OPERAND (*expr_p, 0);
1494
  tree expr;
1495
 
1496
  expr = build_and_jump (&gimplify_ctxp->exit_label);
1497
  expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1498
  *expr_p = expr;
1499
 
1500
  return GS_OK;
1501
}
1502
 
1503
/* A helper function to be called via walk_tree.  Mark all labels under *TP
1504
   as being forced.  To be called for DECL_INITIAL of static variables.  */
1505
 
1506
tree
1507
force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1508
{
1509
  if (TYPE_P (*tp))
1510
    *walk_subtrees = 0;
1511
  if (TREE_CODE (*tp) == LABEL_DECL)
1512
    FORCED_LABEL (*tp) = 1;
1513
 
1514
  return NULL_TREE;
1515
}
1516
 
1517
/* *EXPR_P is a COMPONENT_REF being used as an rvalue.  If its type is
1518
   different from its canonical type, wrap the whole thing inside a
1519
   NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1520
   type.
1521
 
1522
   The canonical type of a COMPONENT_REF is the type of the field being
1523
   referenced--unless the field is a bit-field which can be read directly
1524
   in a smaller mode, in which case the canonical type is the
1525
   sign-appropriate type corresponding to that mode.  */
1526
 
1527
static void
1528
canonicalize_component_ref (tree *expr_p)
1529
{
1530
  tree expr = *expr_p;
1531
  tree type;
1532
 
1533
  gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1534
 
1535
  if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1536
    type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1537
  else
1538
    type = TREE_TYPE (TREE_OPERAND (expr, 1));
1539
 
1540
  if (TREE_TYPE (expr) != type)
1541
    {
1542
      tree old_type = TREE_TYPE (expr);
1543
 
1544
      /* Set the type of the COMPONENT_REF to the underlying type.  */
1545
      TREE_TYPE (expr) = type;
1546
 
1547
      /* And wrap the whole thing inside a NOP_EXPR.  */
1548
      expr = build1 (NOP_EXPR, old_type, expr);
1549
 
1550
      *expr_p = expr;
1551
    }
1552
}
1553
 
1554
/* If a NOP conversion is changing a pointer to array of foo to a pointer
1555
   to foo, embed that change in the ADDR_EXPR by converting
1556
      T array[U];
1557
      (T *)&array
1558
   ==>
1559
      &array[L]
1560
   where L is the lower bound.  For simplicity, only do this for constant
1561
   lower bound.  */
1562
 
1563
static void
1564
canonicalize_addr_expr (tree *expr_p)
1565
{
1566
  tree expr = *expr_p;
1567
  tree ctype = TREE_TYPE (expr);
1568
  tree addr_expr = TREE_OPERAND (expr, 0);
1569
  tree atype = TREE_TYPE (addr_expr);
1570
  tree dctype, datype, ddatype, otype, obj_expr;
1571
 
1572
  /* Both cast and addr_expr types should be pointers.  */
1573
  if (!POINTER_TYPE_P (ctype) || !POINTER_TYPE_P (atype))
1574
    return;
1575
 
1576
  /* The addr_expr type should be a pointer to an array.  */
1577
  datype = TREE_TYPE (atype);
1578
  if (TREE_CODE (datype) != ARRAY_TYPE)
1579
    return;
1580
 
1581
  /* Both cast and addr_expr types should address the same object type.  */
1582
  dctype = TREE_TYPE (ctype);
1583
  ddatype = TREE_TYPE (datype);
1584
  if (!lang_hooks.types_compatible_p (ddatype, dctype))
1585
    return;
1586
 
1587
  /* The addr_expr and the object type should match.  */
1588
  obj_expr = TREE_OPERAND (addr_expr, 0);
1589
  otype = TREE_TYPE (obj_expr);
1590
  if (!lang_hooks.types_compatible_p (otype, datype))
1591
    return;
1592
 
1593
  /* The lower bound and element sizes must be constant.  */
1594
  if (!TYPE_SIZE_UNIT (dctype)
1595
      || TREE_CODE (TYPE_SIZE_UNIT (dctype)) != INTEGER_CST
1596
      || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1597
      || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1598
    return;
1599
 
1600
  /* All checks succeeded.  Build a new node to merge the cast.  */
1601
  *expr_p = build4 (ARRAY_REF, dctype, obj_expr,
1602
                    TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1603
                    TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1604
                    size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (dctype),
1605
                                size_int (TYPE_ALIGN_UNIT (dctype))));
1606
  *expr_p = build1 (ADDR_EXPR, ctype, *expr_p);
1607
}
1608
 
1609
/* *EXPR_P is a NOP_EXPR or CONVERT_EXPR.  Remove it and/or other conversions
1610
   underneath as appropriate.  */
1611
 
1612
static enum gimplify_status
1613
gimplify_conversion (tree *expr_p)
1614
{
1615
  gcc_assert (TREE_CODE (*expr_p) == NOP_EXPR
1616
              || TREE_CODE (*expr_p) == CONVERT_EXPR);
1617
 
1618
  /* Then strip away all but the outermost conversion.  */
1619
  STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1620
 
1621
  /* And remove the outermost conversion if it's useless.  */
1622
  if (tree_ssa_useless_type_conversion (*expr_p))
1623
    *expr_p = TREE_OPERAND (*expr_p, 0);
1624
 
1625
  /* If we still have a conversion at the toplevel,
1626
     then canonicalize some constructs.  */
1627
  if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR)
1628
    {
1629
      tree sub = TREE_OPERAND (*expr_p, 0);
1630
 
1631
      /* If a NOP conversion is changing the type of a COMPONENT_REF
1632
         expression, then canonicalize its type now in order to expose more
1633
         redundant conversions.  */
1634
      if (TREE_CODE (sub) == COMPONENT_REF)
1635
        canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1636
 
1637
      /* If a NOP conversion is changing a pointer to array of foo
1638
         to a pointer to foo, embed that change in the ADDR_EXPR.  */
1639
      else if (TREE_CODE (sub) == ADDR_EXPR)
1640
        canonicalize_addr_expr (expr_p);
1641
    }
1642
 
1643
  return GS_OK;
1644
}
1645
 
1646
/* Gimplify a VAR_DECL or PARM_DECL.  Returns GS_OK if we expanded a
1647
   DECL_VALUE_EXPR, and it's worth re-examining things.  */
1648
 
1649
static enum gimplify_status
1650
gimplify_var_or_parm_decl (tree *expr_p)
1651
{
1652
  tree decl = *expr_p;
1653
 
1654
  /* ??? If this is a local variable, and it has not been seen in any
1655
     outer BIND_EXPR, then it's probably the result of a duplicate
1656
     declaration, for which we've already issued an error.  It would
1657
     be really nice if the front end wouldn't leak these at all.
1658
     Currently the only known culprit is C++ destructors, as seen
1659
     in g++.old-deja/g++.jason/binding.C.  */
1660
  if (TREE_CODE (decl) == VAR_DECL
1661
      && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1662
      && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1663
      && decl_function_context (decl) == current_function_decl)
1664
    {
1665
      gcc_assert (errorcount || sorrycount);
1666
      return GS_ERROR;
1667
    }
1668
 
1669
  /* When within an OpenMP context, notice uses of variables.  */
1670
  if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1671
    return GS_ALL_DONE;
1672
 
1673
  /* If the decl is an alias for another expression, substitute it now.  */
1674
  if (DECL_HAS_VALUE_EXPR_P (decl))
1675
    {
1676
      *expr_p = unshare_expr (DECL_VALUE_EXPR (decl));
1677
      return GS_OK;
1678
    }
1679
 
1680
  return GS_ALL_DONE;
1681
}
1682
 
1683
 
1684
/* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1685
   node pointed to by EXPR_P.
1686
 
1687
      compound_lval
1688
              : min_lval '[' val ']'
1689
              | min_lval '.' ID
1690
              | compound_lval '[' val ']'
1691
              | compound_lval '.' ID
1692
 
1693
   This is not part of the original SIMPLE definition, which separates
1694
   array and member references, but it seems reasonable to handle them
1695
   together.  Also, this way we don't run into problems with union
1696
   aliasing; gcc requires that for accesses through a union to alias, the
1697
   union reference must be explicit, which was not always the case when we
1698
   were splitting up array and member refs.
1699
 
1700
   PRE_P points to the list where side effects that must happen before
1701
     *EXPR_P should be stored.
1702
 
1703
   POST_P points to the list where side effects that must happen after
1704
     *EXPR_P should be stored.  */
1705
 
1706
static enum gimplify_status
1707
gimplify_compound_lval (tree *expr_p, tree *pre_p,
1708
                        tree *post_p, fallback_t fallback)
1709
{
1710
  tree *p;
1711
  VEC(tree,heap) *stack;
1712
  enum gimplify_status ret = GS_OK, tret;
1713
  int i;
1714
 
1715
  /* Create a stack of the subexpressions so later we can walk them in
1716
     order from inner to outer.  */
1717
  stack = VEC_alloc (tree, heap, 10);
1718
 
1719
  /* We can handle anything that get_inner_reference can deal with.  */
1720
  for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
1721
    {
1722
    restart:
1723
      /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs.  */
1724
      if (TREE_CODE (*p) == INDIRECT_REF)
1725
        *p = fold_indirect_ref (*p);
1726
 
1727
      if (handled_component_p (*p))
1728
        ;
1729
      /* Expand DECL_VALUE_EXPR now.  In some cases that may expose
1730
         additional COMPONENT_REFs.  */
1731
      else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
1732
               && gimplify_var_or_parm_decl (p) == GS_OK)
1733
        goto restart;
1734
      else
1735
        break;
1736
 
1737
      VEC_safe_push (tree, heap, stack, *p);
1738
    }
1739
 
1740
  gcc_assert (VEC_length (tree, stack));
1741
 
1742
  /* Now STACK is a stack of pointers to all the refs we've walked through
1743
     and P points to the innermost expression.
1744
 
1745
     Java requires that we elaborated nodes in source order.  That
1746
     means we must gimplify the inner expression followed by each of
1747
     the indices, in order.  But we can't gimplify the inner
1748
     expression until we deal with any variable bounds, sizes, or
1749
     positions in order to deal with PLACEHOLDER_EXPRs.
1750
 
1751
     So we do this in three steps.  First we deal with the annotations
1752
     for any variables in the components, then we gimplify the base,
1753
     then we gimplify any indices, from left to right.  */
1754
  for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
1755
    {
1756
      tree t = VEC_index (tree, stack, i);
1757
 
1758
      if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1759
        {
1760
          /* Gimplify the low bound and element type size and put them into
1761
             the ARRAY_REF.  If these values are set, they have already been
1762
             gimplified.  */
1763
          if (!TREE_OPERAND (t, 2))
1764
            {
1765
              tree low = unshare_expr (array_ref_low_bound (t));
1766
              if (!is_gimple_min_invariant (low))
1767
                {
1768
                  TREE_OPERAND (t, 2) = low;
1769
                  tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1770
                                        is_gimple_formal_tmp_reg, fb_rvalue);
1771
                  ret = MIN (ret, tret);
1772
                }
1773
            }
1774
 
1775
          if (!TREE_OPERAND (t, 3))
1776
            {
1777
              tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1778
              tree elmt_size = unshare_expr (array_ref_element_size (t));
1779
              tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
1780
 
1781
              /* Divide the element size by the alignment of the element
1782
                 type (above).  */
1783
              elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor);
1784
 
1785
              if (!is_gimple_min_invariant (elmt_size))
1786
                {
1787
                  TREE_OPERAND (t, 3) = elmt_size;
1788
                  tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
1789
                                        is_gimple_formal_tmp_reg, fb_rvalue);
1790
                  ret = MIN (ret, tret);
1791
                }
1792
            }
1793
        }
1794
      else if (TREE_CODE (t) == COMPONENT_REF)
1795
        {
1796
          /* Set the field offset into T and gimplify it.  */
1797
          if (!TREE_OPERAND (t, 2))
1798
            {
1799
              tree offset = unshare_expr (component_ref_field_offset (t));
1800
              tree field = TREE_OPERAND (t, 1);
1801
              tree factor
1802
                = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
1803
 
1804
              /* Divide the offset by its alignment.  */
1805
              offset = size_binop (EXACT_DIV_EXPR, offset, factor);
1806
 
1807
              if (!is_gimple_min_invariant (offset))
1808
                {
1809
                  TREE_OPERAND (t, 2) = offset;
1810
                  tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1811
                                        is_gimple_formal_tmp_reg, fb_rvalue);
1812
                  ret = MIN (ret, tret);
1813
                }
1814
            }
1815
        }
1816
    }
1817
 
1818
  /* Step 2 is to gimplify the base expression.  Make sure lvalue is set
1819
     so as to match the min_lval predicate.  Failure to do so may result
1820
     in the creation of large aggregate temporaries.  */
1821
  tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
1822
                        fallback | fb_lvalue);
1823
  ret = MIN (ret, tret);
1824
 
1825
  /* And finally, the indices and operands to BIT_FIELD_REF.  During this
1826
     loop we also remove any useless conversions.  */
1827
  for (; VEC_length (tree, stack) > 0; )
1828
    {
1829
      tree t = VEC_pop (tree, stack);
1830
 
1831
      if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1832
        {
1833
          /* Gimplify the dimension.
1834
             Temporary fix for gcc.c-torture/execute/20040313-1.c.
1835
             Gimplify non-constant array indices into a temporary
1836
             variable.
1837
             FIXME - The real fix is to gimplify post-modify
1838
             expressions into a minimal gimple lvalue.  However, that
1839
             exposes bugs in alias analysis.  The alias analyzer does
1840
             not handle &PTR->FIELD very well.  Will fix after the
1841
             branch is merged into mainline (dnovillo 2004-05-03).  */
1842
          if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
1843
            {
1844
              tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1845
                                    is_gimple_formal_tmp_reg, fb_rvalue);
1846
              ret = MIN (ret, tret);
1847
            }
1848
        }
1849
      else if (TREE_CODE (t) == BIT_FIELD_REF)
1850
        {
1851
          tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1852
                                is_gimple_val, fb_rvalue);
1853
          ret = MIN (ret, tret);
1854
          tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1855
                                is_gimple_val, fb_rvalue);
1856
          ret = MIN (ret, tret);
1857
        }
1858
 
1859
      STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
1860
 
1861
      /* The innermost expression P may have originally had TREE_SIDE_EFFECTS
1862
         set which would have caused all the outer expressions in EXPR_P
1863
         leading to P to also have had TREE_SIDE_EFFECTS set.  */
1864
      recalculate_side_effects (t);
1865
    }
1866
 
1867
  tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, fallback);
1868
  ret = MIN (ret, tret);
1869
 
1870
  /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
1871
  if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
1872
    {
1873
      canonicalize_component_ref (expr_p);
1874
      ret = MIN (ret, GS_OK);
1875
    }
1876
 
1877
  VEC_free (tree, heap, stack);
1878
 
1879
  return ret;
1880
}
1881
 
1882
/*  Gimplify the self modifying expression pointed to by EXPR_P
1883
    (++, --, +=, -=).
1884
 
1885
    PRE_P points to the list where side effects that must happen before
1886
        *EXPR_P should be stored.
1887
 
1888
    POST_P points to the list where side effects that must happen after
1889
        *EXPR_P should be stored.
1890
 
1891
    WANT_VALUE is nonzero iff we want to use the value of this expression
1892
        in another expression.  */
1893
 
1894
static enum gimplify_status
1895
gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p,
1896
                        bool want_value)
1897
{
1898
  enum tree_code code;
1899
  tree lhs, lvalue, rhs, t1, post = NULL, *orig_post_p = post_p;
1900
  bool postfix;
1901
  enum tree_code arith_code;
1902
  enum gimplify_status ret;
1903
 
1904
  code = TREE_CODE (*expr_p);
1905
 
1906
  gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
1907
              || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
1908
 
1909
  /* Prefix or postfix?  */
1910
  if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1911
    /* Faster to treat as prefix if result is not used.  */
1912
    postfix = want_value;
1913
  else
1914
    postfix = false;
1915
 
1916
  /* For postfix, make sure the inner expression's post side effects
1917
     are executed after side effects from this expression.  */
1918
  if (postfix)
1919
    post_p = &post;
1920
 
1921
  /* Add or subtract?  */
1922
  if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
1923
    arith_code = PLUS_EXPR;
1924
  else
1925
    arith_code = MINUS_EXPR;
1926
 
1927
  /* Gimplify the LHS into a GIMPLE lvalue.  */
1928
  lvalue = TREE_OPERAND (*expr_p, 0);
1929
  ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
1930
  if (ret == GS_ERROR)
1931
    return ret;
1932
 
1933
  /* Extract the operands to the arithmetic operation.  */
1934
  lhs = lvalue;
1935
  rhs = TREE_OPERAND (*expr_p, 1);
1936
 
1937
  /* For postfix operator, we evaluate the LHS to an rvalue and then use
1938
     that as the result value and in the postqueue operation.  */
1939
  if (postfix)
1940
    {
1941
      ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
1942
      if (ret == GS_ERROR)
1943
        return ret;
1944
    }
1945
 
1946
  t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
1947
  t1 = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
1948
 
1949
  if (postfix)
1950
    {
1951
      gimplify_and_add (t1, orig_post_p);
1952
      append_to_statement_list (post, orig_post_p);
1953
      *expr_p = lhs;
1954
      return GS_ALL_DONE;
1955
    }
1956
  else
1957
    {
1958
      *expr_p = t1;
1959
      return GS_OK;
1960
    }
1961
}
1962
 
1963
/* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR.  */
1964
 
1965
static void
1966
maybe_with_size_expr (tree *expr_p)
1967
{
1968
  tree expr = *expr_p;
1969
  tree type = TREE_TYPE (expr);
1970
  tree size;
1971
 
1972
  /* If we've already wrapped this or the type is error_mark_node, we can't do
1973
     anything.  */
1974
  if (TREE_CODE (expr) == WITH_SIZE_EXPR
1975
      || type == error_mark_node)
1976
    return;
1977
 
1978
  /* If the size isn't known or is a constant, we have nothing to do.  */
1979
  size = TYPE_SIZE_UNIT (type);
1980
  if (!size || TREE_CODE (size) == INTEGER_CST)
1981
    return;
1982
 
1983
  /* Otherwise, make a WITH_SIZE_EXPR.  */
1984
  size = unshare_expr (size);
1985
  size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
1986
  *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
1987
}
1988
 
1989
/* Subroutine of gimplify_call_expr:  Gimplify a single argument.  */
1990
 
1991
static enum gimplify_status
1992
gimplify_arg (tree *expr_p, tree *pre_p)
1993
{
1994
  bool (*test) (tree);
1995
  fallback_t fb;
1996
 
1997
  /* In general, we allow lvalues for function arguments to avoid
1998
     extra overhead of copying large aggregates out of even larger
1999
     aggregates into temporaries only to copy the temporaries to
2000
     the argument list.  Make optimizers happy by pulling out to
2001
     temporaries those types that fit in registers.  */
2002
  if (is_gimple_reg_type (TREE_TYPE (*expr_p)))
2003
    test = is_gimple_val, fb = fb_rvalue;
2004
  else
2005
    test = is_gimple_lvalue, fb = fb_either;
2006
 
2007
  /* If this is a variable sized type, we must remember the size.  */
2008
  maybe_with_size_expr (expr_p);
2009
 
2010
  /* There is a sequence point before a function call.  Side effects in
2011
     the argument list must occur before the actual call. So, when
2012
     gimplifying arguments, force gimplify_expr to use an internal
2013
     post queue which is then appended to the end of PRE_P.  */
2014
  return gimplify_expr (expr_p, pre_p, NULL, test, fb);
2015
}
2016
 
2017
/* Gimplify the CALL_EXPR node pointed to by EXPR_P.  PRE_P points to the
2018
   list where side effects that must happen before *EXPR_P should be stored.
2019
   WANT_VALUE is true if the result of the call is desired.  */
2020
 
2021
static enum gimplify_status
2022
gimplify_call_expr (tree *expr_p, tree *pre_p, bool want_value)
2023
{
2024
  tree decl;
2025
  tree arglist;
2026
  enum gimplify_status ret;
2027
 
2028
  gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2029
 
2030
  /* For reliable diagnostics during inlining, it is necessary that
2031
     every call_expr be annotated with file and line.  */
2032
  if (! EXPR_HAS_LOCATION (*expr_p))
2033
    SET_EXPR_LOCATION (*expr_p, input_location);
2034
 
2035
  /* This may be a call to a builtin function.
2036
 
2037
     Builtin function calls may be transformed into different
2038
     (and more efficient) builtin function calls under certain
2039
     circumstances.  Unfortunately, gimplification can muck things
2040
     up enough that the builtin expanders are not aware that certain
2041
     transformations are still valid.
2042
 
2043
     So we attempt transformation/gimplification of the call before
2044
     we gimplify the CALL_EXPR.  At this time we do not manage to
2045
     transform all calls in the same manner as the expanders do, but
2046
     we do transform most of them.  */
2047
  decl = get_callee_fndecl (*expr_p);
2048
  if (decl && DECL_BUILT_IN (decl))
2049
    {
2050
      tree arglist = TREE_OPERAND (*expr_p, 1);
2051
      tree new = fold_builtin (decl, arglist, !want_value);
2052
 
2053
      if (new && new != *expr_p)
2054
        {
2055
          /* There was a transformation of this call which computes the
2056
             same value, but in a more efficient way.  Return and try
2057
             again.  */
2058
          *expr_p = new;
2059
          return GS_OK;
2060
        }
2061
 
2062
      if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2063
          && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_START)
2064
        {
2065
          if (!arglist || !TREE_CHAIN (arglist))
2066
            {
2067
              error ("too few arguments to function %<va_start%>");
2068
              *expr_p = build_empty_stmt ();
2069
              return GS_OK;
2070
            }
2071
 
2072
          if (fold_builtin_next_arg (TREE_CHAIN (arglist)))
2073
            {
2074
              *expr_p = build_empty_stmt ();
2075
              return GS_OK;
2076
            }
2077
          /* Avoid gimplifying the second argument to va_start, which needs
2078
             to be the plain PARM_DECL.  */
2079
          return gimplify_arg (&TREE_VALUE (TREE_OPERAND (*expr_p, 1)), pre_p);
2080
        }
2081
    }
2082
 
2083
  /* There is a sequence point before the call, so any side effects in
2084
     the calling expression must occur before the actual call.  Force
2085
     gimplify_expr to use an internal post queue.  */
2086
  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, NULL,
2087
                       is_gimple_call_addr, fb_rvalue);
2088
 
2089
  if (PUSH_ARGS_REVERSED)
2090
    TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1));
2091
  for (arglist = TREE_OPERAND (*expr_p, 1); arglist;
2092
       arglist = TREE_CHAIN (arglist))
2093
    {
2094
      enum gimplify_status t;
2095
 
2096
      t = gimplify_arg (&TREE_VALUE (arglist), pre_p);
2097
 
2098
      if (t == GS_ERROR)
2099
        ret = GS_ERROR;
2100
    }
2101
  if (PUSH_ARGS_REVERSED)
2102
    TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1));
2103
 
2104
  /* Try this again in case gimplification exposed something.  */
2105
  if (ret != GS_ERROR)
2106
    {
2107
      decl = get_callee_fndecl (*expr_p);
2108
      if (decl && DECL_BUILT_IN (decl))
2109
        {
2110
          tree arglist = TREE_OPERAND (*expr_p, 1);
2111
          tree new = fold_builtin (decl, arglist, !want_value);
2112
 
2113
          if (new && new != *expr_p)
2114
            {
2115
              /* There was a transformation of this call which computes the
2116
                 same value, but in a more efficient way.  Return and try
2117
                 again.  */
2118
              *expr_p = new;
2119
              return GS_OK;
2120
            }
2121
        }
2122
    }
2123
 
2124
  /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2125
     decl.  This allows us to eliminate redundant or useless
2126
     calls to "const" functions.  */
2127
  if (TREE_CODE (*expr_p) == CALL_EXPR
2128
      && (call_expr_flags (*expr_p) & (ECF_CONST | ECF_PURE)))
2129
    TREE_SIDE_EFFECTS (*expr_p) = 0;
2130
 
2131
  return ret;
2132
}
2133
 
2134
/* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2135
   rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2136
 
2137
   TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2138
   condition is true or false, respectively.  If null, we should generate
2139
   our own to skip over the evaluation of this specific expression.
2140
 
2141
   This function is the tree equivalent of do_jump.
2142
 
2143
   shortcut_cond_r should only be called by shortcut_cond_expr.  */
2144
 
2145
static tree
2146
shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p)
2147
{
2148
  tree local_label = NULL_TREE;
2149
  tree t, expr = NULL;
2150
 
2151
  /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2152
     retain the shortcut semantics.  Just insert the gotos here;
2153
     shortcut_cond_expr will append the real blocks later.  */
2154
  if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2155
    {
2156
      /* Turn if (a && b) into
2157
 
2158
         if (a); else goto no;
2159
         if (b) goto yes; else goto no;
2160
         (no:) */
2161
 
2162
      if (false_label_p == NULL)
2163
        false_label_p = &local_label;
2164
 
2165
      t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p);
2166
      append_to_statement_list (t, &expr);
2167
 
2168
      t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2169
                           false_label_p);
2170
      append_to_statement_list (t, &expr);
2171
    }
2172
  else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2173
    {
2174
      /* Turn if (a || b) into
2175
 
2176
         if (a) goto yes;
2177
         if (b) goto yes; else goto no;
2178
         (yes:) */
2179
 
2180
      if (true_label_p == NULL)
2181
        true_label_p = &local_label;
2182
 
2183
      t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL);
2184
      append_to_statement_list (t, &expr);
2185
 
2186
      t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2187
                           false_label_p);
2188
      append_to_statement_list (t, &expr);
2189
    }
2190
  else if (TREE_CODE (pred) == COND_EXPR)
2191
    {
2192
      /* As long as we're messing with gotos, turn if (a ? b : c) into
2193
         if (a)
2194
           if (b) goto yes; else goto no;
2195
         else
2196
           if (c) goto yes; else goto no;  */
2197
      expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2198
                     shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2199
                                      false_label_p),
2200
                     shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2201
                                      false_label_p));
2202
    }
2203
  else
2204
    {
2205
      expr = build3 (COND_EXPR, void_type_node, pred,
2206
                     build_and_jump (true_label_p),
2207
                     build_and_jump (false_label_p));
2208
    }
2209
 
2210
  if (local_label)
2211
    {
2212
      t = build1 (LABEL_EXPR, void_type_node, local_label);
2213
      append_to_statement_list (t, &expr);
2214
    }
2215
 
2216
  return expr;
2217
}
2218
 
2219
static tree
2220
shortcut_cond_expr (tree expr)
2221
{
2222
  tree pred = TREE_OPERAND (expr, 0);
2223
  tree then_ = TREE_OPERAND (expr, 1);
2224
  tree else_ = TREE_OPERAND (expr, 2);
2225
  tree true_label, false_label, end_label, t;
2226
  tree *true_label_p;
2227
  tree *false_label_p;
2228
  bool emit_end, emit_false, jump_over_else;
2229
  bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2230
  bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2231
 
2232
  /* First do simple transformations.  */
2233
  if (!else_se)
2234
    {
2235
      /* If there is no 'else', turn (a && b) into if (a) if (b).  */
2236
      while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2237
        {
2238
          TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2239
          then_ = shortcut_cond_expr (expr);
2240
          then_se = then_ && TREE_SIDE_EFFECTS (then_);
2241
          pred = TREE_OPERAND (pred, 0);
2242
          expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2243
        }
2244
    }
2245
  if (!then_se)
2246
    {
2247
      /* If there is no 'then', turn
2248
           if (a || b); else d
2249
         into
2250
           if (a); else if (b); else d.  */
2251
      while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2252
        {
2253
          TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2254
          else_ = shortcut_cond_expr (expr);
2255
          else_se = else_ && TREE_SIDE_EFFECTS (else_);
2256
          pred = TREE_OPERAND (pred, 0);
2257
          expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2258
        }
2259
    }
2260
 
2261
  /* If we're done, great.  */
2262
  if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2263
      && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2264
    return expr;
2265
 
2266
  /* Otherwise we need to mess with gotos.  Change
2267
       if (a) c; else d;
2268
     to
2269
       if (a); else goto no;
2270
       c; goto end;
2271
       no: d; end:
2272
     and recursively gimplify the condition.  */
2273
 
2274
  true_label = false_label = end_label = NULL_TREE;
2275
 
2276
  /* If our arms just jump somewhere, hijack those labels so we don't
2277
     generate jumps to jumps.  */
2278
 
2279
  if (then_
2280
      && TREE_CODE (then_) == GOTO_EXPR
2281
      && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2282
    {
2283
      true_label = GOTO_DESTINATION (then_);
2284
      then_ = NULL;
2285
      then_se = false;
2286
    }
2287
 
2288
  if (else_
2289
      && TREE_CODE (else_) == GOTO_EXPR
2290
      && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2291
    {
2292
      false_label = GOTO_DESTINATION (else_);
2293
      else_ = NULL;
2294
      else_se = false;
2295
    }
2296
 
2297
  /* If we aren't hijacking a label for the 'then' branch, it falls through.  */
2298
  if (true_label)
2299
    true_label_p = &true_label;
2300
  else
2301
    true_label_p = NULL;
2302
 
2303
  /* The 'else' branch also needs a label if it contains interesting code.  */
2304
  if (false_label || else_se)
2305
    false_label_p = &false_label;
2306
  else
2307
    false_label_p = NULL;
2308
 
2309
  /* If there was nothing else in our arms, just forward the label(s).  */
2310
  if (!then_se && !else_se)
2311
    return shortcut_cond_r (pred, true_label_p, false_label_p);
2312
 
2313
  /* If our last subexpression already has a terminal label, reuse it.  */
2314
  if (else_se)
2315
    expr = expr_last (else_);
2316
  else if (then_se)
2317
    expr = expr_last (then_);
2318
  else
2319
    expr = NULL;
2320
  if (expr && TREE_CODE (expr) == LABEL_EXPR)
2321
    end_label = LABEL_EXPR_LABEL (expr);
2322
 
2323
  /* If we don't care about jumping to the 'else' branch, jump to the end
2324
     if the condition is false.  */
2325
  if (!false_label_p)
2326
    false_label_p = &end_label;
2327
 
2328
  /* We only want to emit these labels if we aren't hijacking them.  */
2329
  emit_end = (end_label == NULL_TREE);
2330
  emit_false = (false_label == NULL_TREE);
2331
 
2332
  /* We only emit the jump over the else clause if we have to--if the
2333
     then clause may fall through.  Otherwise we can wind up with a
2334
     useless jump and a useless label at the end of gimplified code,
2335
     which will cause us to think that this conditional as a whole
2336
     falls through even if it doesn't.  If we then inline a function
2337
     which ends with such a condition, that can cause us to issue an
2338
     inappropriate warning about control reaching the end of a
2339
     non-void function.  */
2340
  jump_over_else = block_may_fallthru (then_);
2341
 
2342
  pred = shortcut_cond_r (pred, true_label_p, false_label_p);
2343
 
2344
  expr = NULL;
2345
  append_to_statement_list (pred, &expr);
2346
 
2347
  append_to_statement_list (then_, &expr);
2348
  if (else_se)
2349
    {
2350
      if (jump_over_else)
2351
        {
2352
          t = build_and_jump (&end_label);
2353
          append_to_statement_list (t, &expr);
2354
        }
2355
      if (emit_false)
2356
        {
2357
          t = build1 (LABEL_EXPR, void_type_node, false_label);
2358
          append_to_statement_list (t, &expr);
2359
        }
2360
      append_to_statement_list (else_, &expr);
2361
    }
2362
  if (emit_end && end_label)
2363
    {
2364
      t = build1 (LABEL_EXPR, void_type_node, end_label);
2365
      append_to_statement_list (t, &expr);
2366
    }
2367
 
2368
  return expr;
2369
}
2370
 
2371
/* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE.  */
2372
 
2373
tree
2374
gimple_boolify (tree expr)
2375
{
2376
  tree type = TREE_TYPE (expr);
2377
 
2378
  if (TREE_CODE (type) == BOOLEAN_TYPE)
2379
    return expr;
2380
 
2381
  switch (TREE_CODE (expr))
2382
    {
2383
    case TRUTH_AND_EXPR:
2384
    case TRUTH_OR_EXPR:
2385
    case TRUTH_XOR_EXPR:
2386
    case TRUTH_ANDIF_EXPR:
2387
    case TRUTH_ORIF_EXPR:
2388
      /* Also boolify the arguments of truth exprs.  */
2389
      TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2390
      /* FALLTHRU */
2391
 
2392
    case TRUTH_NOT_EXPR:
2393
      TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2394
      /* FALLTHRU */
2395
 
2396
    case EQ_EXPR: case NE_EXPR:
2397
    case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2398
      /* These expressions always produce boolean results.  */
2399
      TREE_TYPE (expr) = boolean_type_node;
2400
      return expr;
2401
 
2402
    default:
2403
      /* Other expressions that get here must have boolean values, but
2404
         might need to be converted to the appropriate mode.  */
2405
      return fold_convert (boolean_type_node, expr);
2406
    }
2407
}
2408
 
2409
/*  Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2410
    into
2411
 
2412
    if (p)                      if (p)
2413
      t1 = a;                     a;
2414
    else                or      else
2415
      t1 = b;                     b;
2416
    t1;
2417
 
2418
    The second form is used when *EXPR_P is of type void.
2419
 
2420
    TARGET is the tree for T1 above.
2421
 
2422
    PRE_P points to the list where side effects that must happen before
2423
      *EXPR_P should be stored.  */
2424
 
2425
static enum gimplify_status
2426
gimplify_cond_expr (tree *expr_p, tree *pre_p, fallback_t fallback)
2427
{
2428
  tree expr = *expr_p;
2429
  tree tmp, tmp2, type;
2430
  enum gimplify_status ret;
2431
 
2432
  type = TREE_TYPE (expr);
2433
 
2434
  /* If this COND_EXPR has a value, copy the values into a temporary within
2435
     the arms.  */
2436
  if (! VOID_TYPE_P (type))
2437
    {
2438
      tree result;
2439
 
2440
      if ((fallback & fb_lvalue) == 0)
2441
        {
2442
          result = tmp2 = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
2443
          ret = GS_ALL_DONE;
2444
        }
2445
      else
2446
        {
2447
          tree type = build_pointer_type (TREE_TYPE (expr));
2448
 
2449
          if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2450
            TREE_OPERAND (expr, 1) =
2451
              build_fold_addr_expr (TREE_OPERAND (expr, 1));
2452
 
2453
          if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2454
            TREE_OPERAND (expr, 2) =
2455
              build_fold_addr_expr (TREE_OPERAND (expr, 2));
2456
 
2457
          tmp2 = tmp = create_tmp_var (type, "iftmp");
2458
 
2459
          expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
2460
                         TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
2461
 
2462
          result = build_fold_indirect_ref (tmp);
2463
          ret = GS_ALL_DONE;
2464
        }
2465
 
2466
      /* Build the then clause, 't1 = a;'.  But don't build an assignment
2467
         if this branch is void; in C++ it can be, if it's a throw.  */
2468
      if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2469
        TREE_OPERAND (expr, 1)
2470
          = build2 (MODIFY_EXPR, void_type_node, tmp, TREE_OPERAND (expr, 1));
2471
 
2472
      /* Build the else clause, 't1 = b;'.  */
2473
      if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2474
        TREE_OPERAND (expr, 2)
2475
          = build2 (MODIFY_EXPR, void_type_node, tmp2, TREE_OPERAND (expr, 2));
2476
 
2477
      TREE_TYPE (expr) = void_type_node;
2478
      recalculate_side_effects (expr);
2479
 
2480
      /* Move the COND_EXPR to the prequeue.  */
2481
      gimplify_and_add (expr, pre_p);
2482
 
2483
      *expr_p = result;
2484
      return ret;
2485
    }
2486
 
2487
  /* Make sure the condition has BOOLEAN_TYPE.  */
2488
  TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2489
 
2490
  /* Break apart && and || conditions.  */
2491
  if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2492
      || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2493
    {
2494
      expr = shortcut_cond_expr (expr);
2495
 
2496
      if (expr != *expr_p)
2497
        {
2498
          *expr_p = expr;
2499
 
2500
          /* We can't rely on gimplify_expr to re-gimplify the expanded
2501
             form properly, as cleanups might cause the target labels to be
2502
             wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
2503
             set up a conditional context.  */
2504
          gimple_push_condition ();
2505
          gimplify_stmt (expr_p);
2506
          gimple_pop_condition (pre_p);
2507
 
2508
          return GS_ALL_DONE;
2509
        }
2510
    }
2511
 
2512
  /* Now do the normal gimplification.  */
2513
  ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2514
                       is_gimple_condexpr, fb_rvalue);
2515
 
2516
  gimple_push_condition ();
2517
 
2518
  gimplify_to_stmt_list (&TREE_OPERAND (expr, 1));
2519
  gimplify_to_stmt_list (&TREE_OPERAND (expr, 2));
2520
  recalculate_side_effects (expr);
2521
 
2522
  gimple_pop_condition (pre_p);
2523
 
2524
  if (ret == GS_ERROR)
2525
    ;
2526
  else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2527
    ret = GS_ALL_DONE;
2528
  else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2)))
2529
    /* Rewrite "if (a); else b" to "if (!a) b"  */
2530
    {
2531
      TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0));
2532
      ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2533
                           is_gimple_condexpr, fb_rvalue);
2534
 
2535
      tmp = TREE_OPERAND (expr, 1);
2536
      TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2);
2537
      TREE_OPERAND (expr, 2) = tmp;
2538
    }
2539
  else
2540
    /* Both arms are empty; replace the COND_EXPR with its predicate.  */
2541
    expr = TREE_OPERAND (expr, 0);
2542
 
2543
  *expr_p = expr;
2544
  return ret;
2545
}
2546
 
2547
/* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
2548
   a call to __builtin_memcpy.  */
2549
 
2550
static enum gimplify_status
2551
gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value)
2552
{
2553
  tree args, t, to, to_ptr, from;
2554
 
2555
  to = TREE_OPERAND (*expr_p, 0);
2556
  from = TREE_OPERAND (*expr_p, 1);
2557
 
2558
  args = tree_cons (NULL, size, NULL);
2559
 
2560
  t = build_fold_addr_expr (from);
2561
  args = tree_cons (NULL, t, args);
2562
 
2563
  to_ptr = build_fold_addr_expr (to);
2564
  args = tree_cons (NULL, to_ptr, args);
2565
  t = implicit_built_in_decls[BUILT_IN_MEMCPY];
2566
  t = build_function_call_expr (t, args);
2567
 
2568
  if (want_value)
2569
    {
2570
      t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2571
      t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2572
    }
2573
 
2574
  *expr_p = t;
2575
  return GS_OK;
2576
}
2577
 
2578
/* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
2579
   a call to __builtin_memset.  In this case we know that the RHS is
2580
   a CONSTRUCTOR with an empty element list.  */
2581
 
2582
static enum gimplify_status
2583
gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value)
2584
{
2585
  tree args, t, to, to_ptr;
2586
 
2587
  to = TREE_OPERAND (*expr_p, 0);
2588
 
2589
  args = tree_cons (NULL, size, NULL);
2590
 
2591
  args = tree_cons (NULL, integer_zero_node, args);
2592
 
2593
  to_ptr = build_fold_addr_expr (to);
2594
  args = tree_cons (NULL, to_ptr, args);
2595
  t = implicit_built_in_decls[BUILT_IN_MEMSET];
2596
  t = build_function_call_expr (t, args);
2597
 
2598
  if (want_value)
2599
    {
2600
      t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2601
      t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2602
    }
2603
 
2604
  *expr_p = t;
2605
  return GS_OK;
2606
}
2607
 
2608
/* A subroutine of gimplify_init_ctor_preeval.  Called via walk_tree,
2609
   determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
2610
   assignment.  Returns non-null if we detect a potential overlap.  */
2611
 
2612
struct gimplify_init_ctor_preeval_data
2613
{
2614
  /* The base decl of the lhs object.  May be NULL, in which case we
2615
     have to assume the lhs is indirect.  */
2616
  tree lhs_base_decl;
2617
 
2618
  /* The alias set of the lhs object.  */
2619
  int lhs_alias_set;
2620
};
2621
 
2622
static tree
2623
gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
2624
{
2625
  struct gimplify_init_ctor_preeval_data *data
2626
    = (struct gimplify_init_ctor_preeval_data *) xdata;
2627
  tree t = *tp;
2628
 
2629
  /* If we find the base object, obviously we have overlap.  */
2630
  if (data->lhs_base_decl == t)
2631
    return t;
2632
 
2633
  /* If the constructor component is indirect, determine if we have a
2634
     potential overlap with the lhs.  The only bits of information we
2635
     have to go on at this point are addressability and alias sets.  */
2636
  if (TREE_CODE (t) == INDIRECT_REF
2637
      && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
2638
      && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
2639
    return t;
2640
 
2641
  /* If the constructor component is a call, determine if it can hide a
2642
     potential overlap with the lhs through an INDIRECT_REF like above.  */
2643
  if (TREE_CODE (t) == CALL_EXPR)
2644
    {
2645
      tree type, fntype = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
2646
 
2647
      for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
2648
        if (POINTER_TYPE_P (TREE_VALUE (type))
2649
            && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
2650
            && alias_sets_conflict_p (data->lhs_alias_set,
2651
                                      get_alias_set
2652
                                        (TREE_TYPE (TREE_VALUE (type)))))
2653
          return t;
2654
    }
2655
 
2656
  if (IS_TYPE_OR_DECL_P (t))
2657
    *walk_subtrees = 0;
2658
  return NULL;
2659
}
2660
 
2661
/* A subroutine of gimplify_init_constructor.  Pre-evaluate *EXPR_P,
2662
   force values that overlap with the lhs (as described by *DATA)
2663
   into temporaries.  */
2664
 
2665
static void
2666
gimplify_init_ctor_preeval (tree *expr_p, tree *pre_p, tree *post_p,
2667
                            struct gimplify_init_ctor_preeval_data *data)
2668
{
2669
  enum gimplify_status one;
2670
 
2671
  /* If the value is invariant, then there's nothing to pre-evaluate.
2672
     But ensure it doesn't have any side-effects since a SAVE_EXPR is
2673
     invariant but has side effects and might contain a reference to
2674
     the object we're initializing.  */
2675
  if (TREE_INVARIANT (*expr_p) && !TREE_SIDE_EFFECTS (*expr_p))
2676
    return;
2677
 
2678
  /* If the type has non-trivial constructors, we can't pre-evaluate.  */
2679
  if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
2680
    return;
2681
 
2682
  /* Recurse for nested constructors.  */
2683
  if (TREE_CODE (*expr_p) == CONSTRUCTOR)
2684
    {
2685
      unsigned HOST_WIDE_INT ix;
2686
      constructor_elt *ce;
2687
      VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
2688
 
2689
      for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
2690
        gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
2691
      return;
2692
    }
2693
 
2694
  /* If this is a variable sized type, we must remember the size.  */
2695
  maybe_with_size_expr (expr_p);
2696
 
2697
  /* Gimplify the constructor element to something appropriate for the rhs
2698
     of a MODIFY_EXPR.  Given that we know the lhs is an aggregate, we know
2699
     the gimplifier will consider this a store to memory.  Doing this
2700
     gimplification now means that we won't have to deal with complicated
2701
     language-specific trees, nor trees like SAVE_EXPR that can induce
2702
     exponential search behavior.  */
2703
  one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
2704
  if (one == GS_ERROR)
2705
    {
2706
      *expr_p = NULL;
2707
      return;
2708
    }
2709
 
2710
  /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
2711
     with the lhs, since "a = { .x=a }" doesn't make sense.  This will
2712
     always be true for all scalars, since is_gimple_mem_rhs insists on a
2713
     temporary variable for them.  */
2714
  if (DECL_P (*expr_p))
2715
    return;
2716
 
2717
  /* If this is of variable size, we have no choice but to assume it doesn't
2718
     overlap since we can't make a temporary for it.  */
2719
  if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
2720
    return;
2721
 
2722
  /* Otherwise, we must search for overlap ...  */
2723
  if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
2724
    return;
2725
 
2726
  /* ... and if found, force the value into a temporary.  */
2727
  *expr_p = get_formal_tmp_var (*expr_p, pre_p);
2728
}
2729
 
2730
/* A subroutine of gimplify_init_ctor_eval.  Create a loop for
2731
   a RANGE_EXPR in a CONSTRUCTOR for an array.
2732
 
2733
      var = lower;
2734
    loop_entry:
2735
      object[var] = value;
2736
      if (var == upper)
2737
        goto loop_exit;
2738
      var = var + 1;
2739
      goto loop_entry;
2740
    loop_exit:
2741
 
2742
   We increment var _after_ the loop exit check because we might otherwise
2743
   fail if upper == TYPE_MAX_VALUE (type for upper).
2744
 
2745
   Note that we never have to deal with SAVE_EXPRs here, because this has
2746
   already been taken care of for us, in gimplify_init_ctor_preeval().  */
2747
 
2748
static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
2749
                                     tree *, bool);
2750
 
2751
static void
2752
gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
2753
                               tree value, tree array_elt_type,
2754
                               tree *pre_p, bool cleared)
2755
{
2756
  tree loop_entry_label, loop_exit_label;
2757
  tree var, var_type, cref;
2758
 
2759
  loop_entry_label = create_artificial_label ();
2760
  loop_exit_label = create_artificial_label ();
2761
 
2762
  /* Create and initialize the index variable.  */
2763
  var_type = TREE_TYPE (upper);
2764
  var = create_tmp_var (var_type, NULL);
2765
  append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, lower), pre_p);
2766
 
2767
  /* Add the loop entry label.  */
2768
  append_to_statement_list (build1 (LABEL_EXPR,
2769
                                    void_type_node,
2770
                                    loop_entry_label),
2771
                            pre_p);
2772
 
2773
  /* Build the reference.  */
2774
  cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
2775
                 var, NULL_TREE, NULL_TREE);
2776
 
2777
  /* If we are a constructor, just call gimplify_init_ctor_eval to do
2778
     the store.  Otherwise just assign value to the reference.  */
2779
 
2780
  if (TREE_CODE (value) == CONSTRUCTOR)
2781
    /* NB we might have to call ourself recursively through
2782
       gimplify_init_ctor_eval if the value is a constructor.  */
2783
    gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2784
                             pre_p, cleared);
2785
  else
2786
    append_to_statement_list (build2 (MODIFY_EXPR, TREE_TYPE (cref),
2787
                                      cref, value),
2788
                              pre_p);
2789
 
2790
  /* We exit the loop when the index var is equal to the upper bound.  */
2791
  gimplify_and_add (build3 (COND_EXPR, void_type_node,
2792
                            build2 (EQ_EXPR, boolean_type_node,
2793
                                    var, upper),
2794
                            build1 (GOTO_EXPR,
2795
                                    void_type_node,
2796
                                    loop_exit_label),
2797
                            NULL_TREE),
2798
                    pre_p);
2799
 
2800
  /* Otherwise, increment the index var...  */
2801
  append_to_statement_list (build2 (MODIFY_EXPR, var_type, var,
2802
                                    build2 (PLUS_EXPR, var_type, var,
2803
                                            fold_convert (var_type,
2804
                                                          integer_one_node))),
2805
                            pre_p);
2806
 
2807
  /* ...and jump back to the loop entry.  */
2808
  append_to_statement_list (build1 (GOTO_EXPR,
2809
                                    void_type_node,
2810
                                    loop_entry_label),
2811
                            pre_p);
2812
 
2813
  /* Add the loop exit label.  */
2814
  append_to_statement_list (build1 (LABEL_EXPR,
2815
                                    void_type_node,
2816
                                    loop_exit_label),
2817
                            pre_p);
2818
}
2819
 
2820
/* Return true if FDECL is accessing a field that is zero sized.  */
2821
 
2822
static bool
2823
zero_sized_field_decl (tree fdecl)
2824
{
2825
  if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
2826
      && integer_zerop (DECL_SIZE (fdecl)))
2827
    return true;
2828
  return false;
2829
}
2830
 
2831
/* Return true if TYPE is zero sized.  */
2832
 
2833
static bool
2834
zero_sized_type (tree type)
2835
{
2836
  if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
2837
      && integer_zerop (TYPE_SIZE (type)))
2838
    return true;
2839
  return false;
2840
}
2841
 
2842
/* A subroutine of gimplify_init_constructor.  Generate individual
2843
   MODIFY_EXPRs for a CONSTRUCTOR.  OBJECT is the LHS against which the
2844
   assignments should happen.  ELTS is the CONSTRUCTOR_ELTS of the
2845
   CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
2846
   zeroed first.  */
2847
 
2848
static void
2849
gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
2850
                         tree *pre_p, bool cleared)
2851
{
2852
  tree array_elt_type = NULL;
2853
  unsigned HOST_WIDE_INT ix;
2854
  tree purpose, value;
2855
 
2856
  if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
2857
    array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
2858
 
2859
  FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
2860
    {
2861
      tree cref, init;
2862
 
2863
      /* NULL values are created above for gimplification errors.  */
2864
      if (value == NULL)
2865
        continue;
2866
 
2867
      if (cleared && initializer_zerop (value))
2868
        continue;
2869
 
2870
      /* ??? Here's to hoping the front end fills in all of the indices,
2871
         so we don't have to figure out what's missing ourselves.  */
2872
      gcc_assert (purpose);
2873
 
2874
      /* Skip zero-sized fields, unless value has side-effects.  This can
2875
         happen with calls to functions returning a zero-sized type, which
2876
         we shouldn't discard.  As a number of downstream passes don't
2877
         expect sets of zero-sized fields, we rely on the gimplification of
2878
         the MODIFY_EXPR we make below to drop the assignment statement.  */
2879
      if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
2880
        continue;
2881
 
2882
      /* If we have a RANGE_EXPR, we have to build a loop to assign the
2883
         whole range.  */
2884
      if (TREE_CODE (purpose) == RANGE_EXPR)
2885
        {
2886
          tree lower = TREE_OPERAND (purpose, 0);
2887
          tree upper = TREE_OPERAND (purpose, 1);
2888
 
2889
          /* If the lower bound is equal to upper, just treat it as if
2890
             upper was the index.  */
2891
          if (simple_cst_equal (lower, upper))
2892
            purpose = upper;
2893
          else
2894
            {
2895
              gimplify_init_ctor_eval_range (object, lower, upper, value,
2896
                                             array_elt_type, pre_p, cleared);
2897
              continue;
2898
            }
2899
        }
2900
 
2901
      if (array_elt_type)
2902
        {
2903
          cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
2904
                         purpose, NULL_TREE, NULL_TREE);
2905
        }
2906
      else
2907
        {
2908
          gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
2909
          cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
2910
                         unshare_expr (object), purpose, NULL_TREE);
2911
        }
2912
 
2913
      if (TREE_CODE (value) == CONSTRUCTOR
2914
          && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
2915
        gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2916
                                 pre_p, cleared);
2917
      else
2918
        {
2919
          init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
2920
          gimplify_and_add (init, pre_p);
2921
        }
2922
    }
2923
}
2924
 
2925
/* A subroutine of gimplify_modify_expr.  Break out elements of a
2926
   CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
2927
 
2928
   Note that we still need to clear any elements that don't have explicit
2929
   initializers, so if not all elements are initialized we keep the
2930
   original MODIFY_EXPR, we just remove all of the constructor elements.  */
2931
 
2932
static enum gimplify_status
2933
gimplify_init_constructor (tree *expr_p, tree *pre_p,
2934
                           tree *post_p, bool want_value)
2935
{
2936
  tree object;
2937
  tree ctor = TREE_OPERAND (*expr_p, 1);
2938
  tree type = TREE_TYPE (ctor);
2939
  enum gimplify_status ret;
2940
  VEC(constructor_elt,gc) *elts;
2941
 
2942
  if (TREE_CODE (ctor) != CONSTRUCTOR)
2943
    return GS_UNHANDLED;
2944
 
2945
  ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
2946
                       is_gimple_lvalue, fb_lvalue);
2947
  if (ret == GS_ERROR)
2948
    return ret;
2949
  object = TREE_OPERAND (*expr_p, 0);
2950
 
2951
  elts = CONSTRUCTOR_ELTS (ctor);
2952
 
2953
  ret = GS_ALL_DONE;
2954
  switch (TREE_CODE (type))
2955
    {
2956
    case RECORD_TYPE:
2957
    case UNION_TYPE:
2958
    case QUAL_UNION_TYPE:
2959
    case ARRAY_TYPE:
2960
      {
2961
        struct gimplify_init_ctor_preeval_data preeval_data;
2962
        HOST_WIDE_INT num_type_elements, num_ctor_elements;
2963
        HOST_WIDE_INT num_nonzero_elements;
2964
        bool cleared, valid_const_initializer;
2965
 
2966
        /* Aggregate types must lower constructors to initialization of
2967
           individual elements.  The exception is that a CONSTRUCTOR node
2968
           with no elements indicates zero-initialization of the whole.  */
2969
        if (VEC_empty (constructor_elt, elts))
2970
          break;
2971
 
2972
        /* Fetch information about the constructor to direct later processing.
2973
           We might want to make static versions of it in various cases, and
2974
           can only do so if it known to be a valid constant initializer.  */
2975
        valid_const_initializer
2976
          = categorize_ctor_elements (ctor, &num_nonzero_elements,
2977
                                      &num_ctor_elements, &cleared);
2978
 
2979
        /* If a const aggregate variable is being initialized, then it
2980
           should never be a lose to promote the variable to be static.  */
2981
        if (valid_const_initializer
2982
            && num_nonzero_elements > 1
2983
            && TREE_READONLY (object)
2984
            && TREE_CODE (object) == VAR_DECL)
2985
          {
2986
            DECL_INITIAL (object) = ctor;
2987
            TREE_STATIC (object) = 1;
2988
            if (!DECL_NAME (object))
2989
              DECL_NAME (object) = create_tmp_var_name ("C");
2990
            walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
2991
 
2992
            /* ??? C++ doesn't automatically append a .<number> to the
2993
               assembler name, and even when it does, it looks a FE private
2994
               data structures to figure out what that number should be,
2995
               which are not set for this variable.  I suppose this is
2996
               important for local statics for inline functions, which aren't
2997
               "local" in the object file sense.  So in order to get a unique
2998
               TU-local symbol, we must invoke the lhd version now.  */
2999
            lhd_set_decl_assembler_name (object);
3000
 
3001
            *expr_p = NULL_TREE;
3002
            break;
3003
          }
3004
 
3005
        /* If there are "lots" of initialized elements, even discounting
3006
           those that are not address constants (and thus *must* be
3007
           computed at runtime), then partition the constructor into
3008
           constant and non-constant parts.  Block copy the constant
3009
           parts in, then generate code for the non-constant parts.  */
3010
        /* TODO.  There's code in cp/typeck.c to do this.  */
3011
 
3012
        num_type_elements = count_type_elements (type, true);
3013
 
3014
        /* If count_type_elements could not determine number of type elements
3015
           for a constant-sized object, assume clearing is needed.
3016
           Don't do this for variable-sized objects, as store_constructor
3017
           will ignore the clearing of variable-sized objects.  */
3018
        if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
3019
          cleared = true;
3020
        /* If there are "lots" of zeros, then block clear the object first.  */
3021
        else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO
3022
                 && num_nonzero_elements < num_type_elements/4)
3023
          cleared = true;
3024
        /* ??? This bit ought not be needed.  For any element not present
3025
           in the initializer, we should simply set them to zero.  Except
3026
           we'd need to *find* the elements that are not present, and that
3027
           requires trickery to avoid quadratic compile-time behavior in
3028
           large cases or excessive memory use in small cases.  */
3029
        else if (num_ctor_elements < num_type_elements)
3030
          cleared = true;
3031
 
3032
        /* If there are "lots" of initialized elements, and all of them
3033
           are valid address constants, then the entire initializer can
3034
           be dropped to memory, and then memcpy'd out.  Don't do this
3035
           for sparse arrays, though, as it's more efficient to follow
3036
           the standard CONSTRUCTOR behavior of memset followed by
3037
           individual element initialization.  */
3038
        if (valid_const_initializer && !cleared)
3039
          {
3040
            HOST_WIDE_INT size = int_size_in_bytes (type);
3041
            unsigned int align;
3042
 
3043
            /* ??? We can still get unbounded array types, at least
3044
               from the C++ front end.  This seems wrong, but attempt
3045
               to work around it for now.  */
3046
            if (size < 0)
3047
              {
3048
                size = int_size_in_bytes (TREE_TYPE (object));
3049
                if (size >= 0)
3050
                  TREE_TYPE (ctor) = type = TREE_TYPE (object);
3051
              }
3052
 
3053
            /* Find the maximum alignment we can assume for the object.  */
3054
            /* ??? Make use of DECL_OFFSET_ALIGN.  */
3055
            if (DECL_P (object))
3056
              align = DECL_ALIGN (object);
3057
            else
3058
              align = TYPE_ALIGN (type);
3059
 
3060
            if (size > 0 && !can_move_by_pieces (size, align))
3061
              {
3062
                tree new = create_tmp_var_raw (type, "C");
3063
 
3064
                gimple_add_tmp_var (new);
3065
                TREE_STATIC (new) = 1;
3066
                TREE_READONLY (new) = 1;
3067
                DECL_INITIAL (new) = ctor;
3068
                if (align > DECL_ALIGN (new))
3069
                  {
3070
                    DECL_ALIGN (new) = align;
3071
                    DECL_USER_ALIGN (new) = 1;
3072
                  }
3073
                walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
3074
 
3075
                TREE_OPERAND (*expr_p, 1) = new;
3076
 
3077
                /* This is no longer an assignment of a CONSTRUCTOR, but
3078
                   we still may have processing to do on the LHS.  So
3079
                   pretend we didn't do anything here to let that happen.  */
3080
                return GS_UNHANDLED;
3081
              }
3082
          }
3083
 
3084
        /* If there are nonzero elements, pre-evaluate to capture elements
3085
           overlapping with the lhs into temporaries.  We must do this before
3086
           clearing to fetch the values before they are zeroed-out.  */
3087
        if (num_nonzero_elements > 0)
3088
          {
3089
            preeval_data.lhs_base_decl = get_base_address (object);
3090
            if (!DECL_P (preeval_data.lhs_base_decl))
3091
              preeval_data.lhs_base_decl = NULL;
3092
            preeval_data.lhs_alias_set = get_alias_set (object);
3093
 
3094
            gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
3095
                                        pre_p, post_p, &preeval_data);
3096
          }
3097
 
3098
        if (cleared)
3099
          {
3100
            /* Zap the CONSTRUCTOR element list, which simplifies this case.
3101
               Note that we still have to gimplify, in order to handle the
3102
               case of variable sized types.  Avoid shared tree structures.  */
3103
            CONSTRUCTOR_ELTS (ctor) = NULL;
3104
            object = unshare_expr (object);
3105
            gimplify_stmt (expr_p);
3106
            append_to_statement_list (*expr_p, pre_p);
3107
          }
3108
 
3109
        /* If we have not block cleared the object, or if there are nonzero
3110
           elements in the constructor, add assignments to the individual
3111
           scalar fields of the object.  */
3112
        if (!cleared || num_nonzero_elements > 0)
3113
          gimplify_init_ctor_eval (object, elts, pre_p, cleared);
3114
 
3115
        *expr_p = NULL_TREE;
3116
      }
3117
      break;
3118
 
3119
    case COMPLEX_TYPE:
3120
      {
3121
        tree r, i;
3122
 
3123
        /* Extract the real and imaginary parts out of the ctor.  */
3124
        gcc_assert (VEC_length (constructor_elt, elts) == 2);
3125
        r = VEC_index (constructor_elt, elts, 0)->value;
3126
        i = VEC_index (constructor_elt, elts, 1)->value;
3127
        if (r == NULL || i == NULL)
3128
          {
3129
            tree zero = fold_convert (TREE_TYPE (type), integer_zero_node);
3130
            if (r == NULL)
3131
              r = zero;
3132
            if (i == NULL)
3133
              i = zero;
3134
          }
3135
 
3136
        /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
3137
           represent creation of a complex value.  */
3138
        if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
3139
          {
3140
            ctor = build_complex (type, r, i);
3141
            TREE_OPERAND (*expr_p, 1) = ctor;
3142
          }
3143
        else
3144
          {
3145
            ctor = build2 (COMPLEX_EXPR, type, r, i);
3146
            TREE_OPERAND (*expr_p, 1) = ctor;
3147
            ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3148
                                 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
3149
                                 fb_rvalue);
3150
          }
3151
      }
3152
      break;
3153
 
3154
    case VECTOR_TYPE:
3155
      {
3156
        unsigned HOST_WIDE_INT ix;
3157
        constructor_elt *ce;
3158
 
3159
        /* Go ahead and simplify constant constructors to VECTOR_CST.  */
3160
        if (TREE_CONSTANT (ctor))
3161
          {
3162
            bool constant_p = true;
3163
            tree value;
3164
 
3165
            /* Even when ctor is constant, it might contain non-*_CST
3166
              elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
3167
              belong into VECTOR_CST nodes.  */
3168
            FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
3169
              if (!CONSTANT_CLASS_P (value))
3170
                {
3171
                  constant_p = false;
3172
                  break;
3173
                }
3174
 
3175
            if (constant_p)
3176
              {
3177
                TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
3178
                break;
3179
              }
3180
 
3181
            /* Don't reduce a TREE_CONSTANT vector ctor even if we can't
3182
               make a VECTOR_CST.  It won't do anything for us, and it'll
3183
               prevent us from representing it as a single constant.  */
3184
            break;
3185
          }
3186
 
3187
        /* Vector types use CONSTRUCTOR all the way through gimple
3188
          compilation as a general initializer.  */
3189
        for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++)
3190
          {
3191
            enum gimplify_status tret;
3192
            tret = gimplify_expr (&ce->value, pre_p, post_p,
3193
                                  is_gimple_val, fb_rvalue);
3194
            if (tret == GS_ERROR)
3195
              ret = GS_ERROR;
3196
          }
3197
      }
3198
      break;
3199
 
3200
    default:
3201
      /* So how did we get a CONSTRUCTOR for a scalar type?  */
3202
      gcc_unreachable ();
3203
    }
3204
 
3205
  if (ret == GS_ERROR)
3206
    return GS_ERROR;
3207
  else if (want_value)
3208
    {
3209
      append_to_statement_list (*expr_p, pre_p);
3210
      *expr_p = object;
3211
      return GS_OK;
3212
    }
3213
  else
3214
    return GS_ALL_DONE;
3215
}
3216
 
3217
/* Given a pointer value OP0, return a simplified version of an
3218
   indirection through OP0, or NULL_TREE if no simplification is
3219
   possible.  This may only be applied to a rhs of an expression.
3220
   Note that the resulting type may be different from the type pointed
3221
   to in the sense that it is still compatible from the langhooks
3222
   point of view. */
3223
 
3224
static tree
3225
fold_indirect_ref_rhs (tree t)
3226
{
3227
  tree type = TREE_TYPE (TREE_TYPE (t));
3228
  tree sub = t;
3229
  tree subtype;
3230
 
3231
  STRIP_USELESS_TYPE_CONVERSION (sub);
3232
  subtype = TREE_TYPE (sub);
3233
  if (!POINTER_TYPE_P (subtype))
3234
    return NULL_TREE;
3235
 
3236
  if (TREE_CODE (sub) == ADDR_EXPR)
3237
    {
3238
      tree op = TREE_OPERAND (sub, 0);
3239
      tree optype = TREE_TYPE (op);
3240
      /* *&p => p */
3241
      if (lang_hooks.types_compatible_p (type, optype))
3242
        return op;
3243
      /* *(foo *)&fooarray => fooarray[0] */
3244
      else if (TREE_CODE (optype) == ARRAY_TYPE
3245
               && lang_hooks.types_compatible_p (type, TREE_TYPE (optype)))
3246
       {
3247
         tree type_domain = TYPE_DOMAIN (optype);
3248
         tree min_val = size_zero_node;
3249
         if (type_domain && TYPE_MIN_VALUE (type_domain))
3250
           min_val = TYPE_MIN_VALUE (type_domain);
3251
         return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
3252
       }
3253
    }
3254
 
3255
  /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3256
  if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
3257
      && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype))))
3258
    {
3259
      tree type_domain;
3260
      tree min_val = size_zero_node;
3261
      tree osub = sub;
3262
      sub = fold_indirect_ref_rhs (sub);
3263
      if (! sub)
3264
        sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
3265
      type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
3266
      if (type_domain && TYPE_MIN_VALUE (type_domain))
3267
        min_val = TYPE_MIN_VALUE (type_domain);
3268
      return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
3269
    }
3270
 
3271
  return NULL_TREE;
3272
}
3273
 
3274
/* Subroutine of gimplify_modify_expr to do simplifications of MODIFY_EXPRs
3275
   based on the code of the RHS.  We loop for as long as something changes.  */
3276
 
3277
static enum gimplify_status
3278
gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
3279
                          tree *post_p, bool want_value)
3280
{
3281
  enum gimplify_status ret = GS_OK;
3282
 
3283
  while (ret != GS_UNHANDLED)
3284
    switch (TREE_CODE (*from_p))
3285
      {
3286
      case INDIRECT_REF:
3287
        {
3288
          /* If we have code like
3289
 
3290
                *(const A*)(A*)&x
3291
 
3292
             where the type of "x" is a (possibly cv-qualified variant
3293
             of "A"), treat the entire expression as identical to "x".
3294
             This kind of code arises in C++ when an object is bound
3295
             to a const reference, and if "x" is a TARGET_EXPR we want
3296
             to take advantage of the optimization below.  */
3297
          tree t = fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
3298
          if (t)
3299
            {
3300
              *from_p = t;
3301
              ret = GS_OK;
3302
            }
3303
          else
3304
            ret = GS_UNHANDLED;
3305
          break;
3306
        }
3307
 
3308
      case TARGET_EXPR:
3309
        {
3310
          /* If we are initializing something from a TARGET_EXPR, strip the
3311
             TARGET_EXPR and initialize it directly, if possible.  This can't
3312
             be done if the initializer is void, since that implies that the
3313
             temporary is set in some non-trivial way.
3314
 
3315
             ??? What about code that pulls out the temp and uses it
3316
             elsewhere? I think that such code never uses the TARGET_EXPR as
3317
             an initializer.  If I'm wrong, we'll die because the temp won't
3318
             have any RTL.  In that case, I guess we'll need to replace
3319
             references somehow.  */
3320
          tree init = TARGET_EXPR_INITIAL (*from_p);
3321
 
3322
          if (!VOID_TYPE_P (TREE_TYPE (init)))
3323
            {
3324
              *from_p = init;
3325
              ret = GS_OK;
3326
            }
3327
          else
3328
            ret = GS_UNHANDLED;
3329
        }
3330
        break;
3331
 
3332
      case COMPOUND_EXPR:
3333
        /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
3334
           caught.  */
3335
        gimplify_compound_expr (from_p, pre_p, true);
3336
        ret = GS_OK;
3337
        break;
3338
 
3339
      case CONSTRUCTOR:
3340
        /* If we're initializing from a CONSTRUCTOR, break this into
3341
           individual MODIFY_EXPRs.  */
3342
        return gimplify_init_constructor (expr_p, pre_p, post_p, want_value);
3343
 
3344
      case COND_EXPR:
3345
        /* If we're assigning to a non-register type, push the assignment
3346
           down into the branches.  This is mandatory for ADDRESSABLE types,
3347
           since we cannot generate temporaries for such, but it saves a
3348
           copy in other cases as well.  */
3349
        if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
3350
          {
3351
            /* This code should mirror the code in gimplify_cond_expr. */
3352
            enum tree_code code = TREE_CODE (*expr_p);
3353
            tree cond = *from_p;
3354
            tree result = *to_p;
3355
 
3356
            ret = gimplify_expr (&result, pre_p, post_p,
3357
                                 is_gimple_min_lval, fb_lvalue);
3358
            if (ret != GS_ERROR)
3359
              ret = GS_OK;
3360
 
3361
            if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
3362
              TREE_OPERAND (cond, 1)
3363
                = build2 (code, void_type_node, result,
3364
                          TREE_OPERAND (cond, 1));
3365
            if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
3366
              TREE_OPERAND (cond, 2)
3367
                = build2 (code, void_type_node, unshare_expr (result),
3368
                          TREE_OPERAND (cond, 2));
3369
 
3370
            TREE_TYPE (cond) = void_type_node;
3371
            recalculate_side_effects (cond);
3372
 
3373
            if (want_value)
3374
              {
3375
                gimplify_and_add (cond, pre_p);
3376
                *expr_p = unshare_expr (result);
3377
              }
3378
            else
3379
              *expr_p = cond;
3380
            return ret;
3381
          }
3382
        else
3383
          ret = GS_UNHANDLED;
3384
        break;
3385
 
3386
      case CALL_EXPR:
3387
        /* For calls that return in memory, give *to_p as the CALL_EXPR's
3388
           return slot so that we don't generate a temporary.  */
3389
        if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
3390
            && aggregate_value_p (*from_p, *from_p))
3391
          {
3392
            bool use_target;
3393
 
3394
            if (!(rhs_predicate_for (*to_p))(*from_p))
3395
              /* If we need a temporary, *to_p isn't accurate.  */
3396
              use_target = false;
3397
            else if (TREE_CODE (*to_p) == RESULT_DECL
3398
                     && DECL_NAME (*to_p) == NULL_TREE
3399
                     && needs_to_live_in_memory (*to_p))
3400
              /* It's OK to use the return slot directly unless it's an NRV. */
3401
              use_target = true;
3402
            else if (is_gimple_reg_type (TREE_TYPE (*to_p))
3403
                     || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
3404
              /* Don't force regs into memory.  */
3405
              use_target = false;
3406
            else if (TREE_CODE (*to_p) == VAR_DECL
3407
                     && DECL_GIMPLE_FORMAL_TEMP_P (*to_p))
3408
              /* Don't use the original target if it's a formal temp; we
3409
                 don't want to take their addresses.  */
3410
              use_target = false;
3411
            else if (TREE_CODE (*expr_p) == INIT_EXPR)
3412
              /* It's OK to use the target directly if it's being
3413
                 initialized. */
3414
              use_target = true;
3415
            else if (!is_gimple_non_addressable (*to_p))
3416
              /* Don't use the original target if it's already addressable;
3417
                 if its address escapes, and the called function uses the
3418
                 NRV optimization, a conforming program could see *to_p
3419
                 change before the called function returns; see c++/19317.
3420
                 When optimizing, the return_slot pass marks more functions
3421
                 as safe after we have escape info.  */
3422
              use_target = false;
3423
            else
3424
              use_target = true;
3425
 
3426
            if (use_target)
3427
              {
3428
                CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
3429
                lang_hooks.mark_addressable (*to_p);
3430
              }
3431
          }
3432
 
3433
        ret = GS_UNHANDLED;
3434
        break;
3435
 
3436
        /* If we're initializing from a container, push the initialization
3437
           inside it.  */
3438
      case CLEANUP_POINT_EXPR:
3439
      case BIND_EXPR:
3440
      case STATEMENT_LIST:
3441
        {
3442
          tree wrap = *from_p;
3443
          tree t;
3444
 
3445
          ret = gimplify_expr (to_p, pre_p, post_p,
3446
                               is_gimple_min_lval, fb_lvalue);
3447
          if (ret != GS_ERROR)
3448
            ret = GS_OK;
3449
 
3450
          t = voidify_wrapper_expr (wrap, *expr_p);
3451
          gcc_assert (t == *expr_p);
3452
 
3453
          if (want_value)
3454
            {
3455
              gimplify_and_add (wrap, pre_p);
3456
              *expr_p = unshare_expr (*to_p);
3457
            }
3458
          else
3459
            *expr_p = wrap;
3460
          return GS_OK;
3461
        }
3462
 
3463
      default:
3464
        ret = GS_UNHANDLED;
3465
        break;
3466
      }
3467
 
3468
  return ret;
3469
}
3470
 
3471
/* Promote partial stores to COMPLEX variables to total stores.  *EXPR_P is
3472
   a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
3473
   DECL_COMPLEX_GIMPLE_REG_P set.  */
3474
 
3475
static enum gimplify_status
3476
gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
3477
{
3478
  enum tree_code code, ocode;
3479
  tree lhs, rhs, new_rhs, other, realpart, imagpart;
3480
 
3481
  lhs = TREE_OPERAND (*expr_p, 0);
3482
  rhs = TREE_OPERAND (*expr_p, 1);
3483
  code = TREE_CODE (lhs);
3484
  lhs = TREE_OPERAND (lhs, 0);
3485
 
3486
  ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
3487
  other = build1 (ocode, TREE_TYPE (rhs), lhs);
3488
  other = get_formal_tmp_var (other, pre_p);
3489
 
3490
  realpart = code == REALPART_EXPR ? rhs : other;
3491
  imagpart = code == REALPART_EXPR ? other : rhs;
3492
 
3493
  if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
3494
    new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
3495
  else
3496
    new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
3497
 
3498
  TREE_OPERAND (*expr_p, 0) = lhs;
3499
  TREE_OPERAND (*expr_p, 1) = new_rhs;
3500
 
3501
  if (want_value)
3502
    {
3503
      append_to_statement_list (*expr_p, pre_p);
3504
      *expr_p = rhs;
3505
    }
3506
 
3507
  return GS_ALL_DONE;
3508
}
3509
 
3510
/* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
3511
 
3512
      modify_expr
3513
              : varname '=' rhs
3514
              | '*' ID '=' rhs
3515
 
3516
    PRE_P points to the list where side effects that must happen before
3517
        *EXPR_P should be stored.
3518
 
3519
    POST_P points to the list where side effects that must happen after
3520
        *EXPR_P should be stored.
3521
 
3522
    WANT_VALUE is nonzero iff we want to use the value of this expression
3523
        in another expression.  */
3524
 
3525
static enum gimplify_status
3526
gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
3527
{
3528
  tree *from_p = &TREE_OPERAND (*expr_p, 1);
3529
  tree *to_p = &TREE_OPERAND (*expr_p, 0);
3530
  enum gimplify_status ret = GS_UNHANDLED;
3531
 
3532
  gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
3533
              || TREE_CODE (*expr_p) == INIT_EXPR);
3534
 
3535
  /* See if any simplifications can be done based on what the RHS is.  */
3536
  ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3537
                                  want_value);
3538
  if (ret != GS_UNHANDLED)
3539
    return ret;
3540
 
3541
  /* For zero sized types only gimplify the left hand side and right hand
3542
     side as statements and throw away the assignment.  Do this after
3543
     gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
3544
     types properly.  */
3545
  if (zero_sized_type (TREE_TYPE (*from_p)))
3546
    {
3547
      gimplify_stmt (from_p);
3548
      gimplify_stmt (to_p);
3549
      append_to_statement_list (*from_p, pre_p);
3550
      append_to_statement_list (*to_p, pre_p);
3551
      *expr_p = NULL_TREE;
3552
      return GS_ALL_DONE;
3553
    }
3554
 
3555
  /* If the value being copied is of variable width, compute the length
3556
     of the copy into a WITH_SIZE_EXPR.   Note that we need to do this
3557
     before gimplifying any of the operands so that we can resolve any
3558
     PLACEHOLDER_EXPRs in the size.  Also note that the RTL expander uses
3559
     the size of the expression to be copied, not of the destination, so
3560
     that is what we must here.  */
3561
  maybe_with_size_expr (from_p);
3562
 
3563
  ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
3564
  if (ret == GS_ERROR)
3565
    return ret;
3566
 
3567
  ret = gimplify_expr (from_p, pre_p, post_p,
3568
                       rhs_predicate_for (*to_p), fb_rvalue);
3569
  if (ret == GS_ERROR)
3570
    return ret;
3571
 
3572
  /* Now see if the above changed *from_p to something we handle specially.  */
3573
  ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3574
                                  want_value);
3575
  if (ret != GS_UNHANDLED)
3576
    return ret;
3577
 
3578
  /* If we've got a variable sized assignment between two lvalues (i.e. does
3579
     not involve a call), then we can make things a bit more straightforward
3580
     by converting the assignment to memcpy or memset.  */
3581
  if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
3582
    {
3583
      tree from = TREE_OPERAND (*from_p, 0);
3584
      tree size = TREE_OPERAND (*from_p, 1);
3585
 
3586
      if (TREE_CODE (from) == CONSTRUCTOR)
3587
        return gimplify_modify_expr_to_memset (expr_p, size, want_value);
3588
      if (is_gimple_addressable (from))
3589
        {
3590
          *from_p = from;
3591
          return gimplify_modify_expr_to_memcpy (expr_p, size, want_value);
3592
        }
3593
    }
3594
 
3595
  /* Transform partial stores to non-addressable complex variables into
3596
     total stores.  This allows us to use real instead of virtual operands
3597
     for these variables, which improves optimization.  */
3598
  if ((TREE_CODE (*to_p) == REALPART_EXPR
3599
       || TREE_CODE (*to_p) == IMAGPART_EXPR)
3600
      && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
3601
    return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
3602
 
3603
  if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
3604
    {
3605
      /* If we've somehow already got an SSA_NAME on the LHS, then
3606
         we're probably modified it twice.  Not good.  */
3607
      gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
3608
      *to_p = make_ssa_name (*to_p, *expr_p);
3609
    }
3610
 
3611
  if (want_value)
3612
    {
3613
      append_to_statement_list (*expr_p, pre_p);
3614
      *expr_p = *to_p;
3615
      return GS_OK;
3616
    }
3617
 
3618
  return GS_ALL_DONE;
3619
}
3620
 
3621
/*  Gimplify a comparison between two variable-sized objects.  Do this
3622
    with a call to BUILT_IN_MEMCMP.  */
3623
 
3624
static enum gimplify_status
3625
gimplify_variable_sized_compare (tree *expr_p)
3626
{
3627
  tree op0 = TREE_OPERAND (*expr_p, 0);
3628
  tree op1 = TREE_OPERAND (*expr_p, 1);
3629
  tree args, t, dest;
3630
 
3631
  t = TYPE_SIZE_UNIT (TREE_TYPE (op0));
3632
  t = unshare_expr (t);
3633
  t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, op0);
3634
  args = tree_cons (NULL, t, NULL);
3635
  t = build_fold_addr_expr (op1);
3636
  args = tree_cons (NULL, t, args);
3637
  dest = build_fold_addr_expr (op0);
3638
  args = tree_cons (NULL, dest, args);
3639
  t = implicit_built_in_decls[BUILT_IN_MEMCMP];
3640
  t = build_function_call_expr (t, args);
3641
  *expr_p
3642
    = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
3643
 
3644
  return GS_OK;
3645
}
3646
 
3647
/*  Gimplify a comparison between two aggregate objects of integral scalar
3648
    mode as a comparison between the bitwise equivalent scalar values.  */
3649
 
3650
static enum gimplify_status
3651
gimplify_scalar_mode_aggregate_compare (tree *expr_p)
3652
{
3653
  tree op0 = TREE_OPERAND (*expr_p, 0);
3654
  tree op1 = TREE_OPERAND (*expr_p, 1);
3655
 
3656
  tree type = TREE_TYPE (op0);
3657
  tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
3658
 
3659
  op0 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op0);
3660
  op1 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op1);
3661
 
3662
  *expr_p
3663
    = fold_build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
3664
 
3665
  return GS_OK;
3666
}
3667
 
3668
/*  Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions.  EXPR_P
3669
    points to the expression to gimplify.
3670
 
3671
    Expressions of the form 'a && b' are gimplified to:
3672
 
3673
        a && b ? true : false
3674
 
3675
    gimplify_cond_expr will do the rest.
3676
 
3677
    PRE_P points to the list where side effects that must happen before
3678
        *EXPR_P should be stored.  */
3679
 
3680
static enum gimplify_status
3681
gimplify_boolean_expr (tree *expr_p)
3682
{
3683
  /* Preserve the original type of the expression.  */
3684
  tree type = TREE_TYPE (*expr_p);
3685
 
3686
  *expr_p = build3 (COND_EXPR, type, *expr_p,
3687
                    fold_convert (type, boolean_true_node),
3688
                    fold_convert (type, boolean_false_node));
3689
 
3690
  return GS_OK;
3691
}
3692
 
3693
/* Gimplifies an expression sequence.  This function gimplifies each
3694
   expression and re-writes the original expression with the last
3695
   expression of the sequence in GIMPLE form.
3696
 
3697
   PRE_P points to the list where the side effects for all the
3698
       expressions in the sequence will be emitted.
3699
 
3700
   WANT_VALUE is true when the result of the last COMPOUND_EXPR is used.  */
3701
/* ??? Should rearrange to share the pre-queue with all the indirect
3702
   invocations of gimplify_expr.  Would probably save on creations
3703
   of statement_list nodes.  */
3704
 
3705
static enum gimplify_status
3706
gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value)
3707
{
3708
  tree t = *expr_p;
3709
 
3710
  do
3711
    {
3712
      tree *sub_p = &TREE_OPERAND (t, 0);
3713
 
3714
      if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
3715
        gimplify_compound_expr (sub_p, pre_p, false);
3716
      else
3717
        gimplify_stmt (sub_p);
3718
      append_to_statement_list (*sub_p, pre_p);
3719
 
3720
      t = TREE_OPERAND (t, 1);
3721
    }
3722
  while (TREE_CODE (t) == COMPOUND_EXPR);
3723
 
3724
  *expr_p = t;
3725
  if (want_value)
3726
    return GS_OK;
3727
  else
3728
    {
3729
      gimplify_stmt (expr_p);
3730
      return GS_ALL_DONE;
3731
    }
3732
}
3733
 
3734
/* Gimplifies a statement list.  These may be created either by an
3735
   enlightened front-end, or by shortcut_cond_expr.  */
3736
 
3737
static enum gimplify_status
3738
gimplify_statement_list (tree *expr_p, tree *pre_p)
3739
{
3740
  tree temp = voidify_wrapper_expr (*expr_p, NULL);
3741
 
3742
  tree_stmt_iterator i = tsi_start (*expr_p);
3743
 
3744
  while (!tsi_end_p (i))
3745
    {
3746
      tree t;
3747
 
3748
      gimplify_stmt (tsi_stmt_ptr (i));
3749
 
3750
      t = tsi_stmt (i);
3751
      if (t == NULL)
3752
        tsi_delink (&i);
3753
      else if (TREE_CODE (t) == STATEMENT_LIST)
3754
        {
3755
          tsi_link_before (&i, t, TSI_SAME_STMT);
3756
          tsi_delink (&i);
3757
        }
3758
      else
3759
        tsi_next (&i);
3760
    }
3761
 
3762
  if (temp)
3763
    {
3764
      append_to_statement_list (*expr_p, pre_p);
3765
      *expr_p = temp;
3766
      return GS_OK;
3767
    }
3768
 
3769
  return GS_ALL_DONE;
3770
}
3771
 
3772
/*  Gimplify a SAVE_EXPR node.  EXPR_P points to the expression to
3773
    gimplify.  After gimplification, EXPR_P will point to a new temporary
3774
    that holds the original value of the SAVE_EXPR node.
3775
 
3776
    PRE_P points to the list where side effects that must happen before
3777
        *EXPR_P should be stored.  */
3778
 
3779
static enum gimplify_status
3780
gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p)
3781
{
3782
  enum gimplify_status ret = GS_ALL_DONE;
3783
  tree val;
3784
 
3785
  gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
3786
  val = TREE_OPERAND (*expr_p, 0);
3787
 
3788
  /* If the SAVE_EXPR has not been resolved, then evaluate it once.  */
3789
  if (!SAVE_EXPR_RESOLVED_P (*expr_p))
3790
    {
3791
      /* The operand may be a void-valued expression such as SAVE_EXPRs
3792
         generated by the Java frontend for class initialization.  It is
3793
         being executed only for its side-effects.  */
3794
      if (TREE_TYPE (val) == void_type_node)
3795
        {
3796
          ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3797
                               is_gimple_stmt, fb_none);
3798
          append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p);
3799
          val = NULL;
3800
        }
3801
      else
3802
        val = get_initialized_tmp_var (val, pre_p, post_p);
3803
 
3804
      TREE_OPERAND (*expr_p, 0) = val;
3805
      SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
3806
    }
3807
 
3808
  *expr_p = val;
3809
 
3810
  return ret;
3811
}
3812
 
3813
/*  Re-write the ADDR_EXPR node pointed to by EXPR_P
3814
 
3815
      unary_expr
3816
              : ...
3817
              | '&' varname
3818
              ...
3819
 
3820
    PRE_P points to the list where side effects that must happen before
3821
        *EXPR_P should be stored.
3822
 
3823
    POST_P points to the list where side effects that must happen after
3824
        *EXPR_P should be stored.  */
3825
 
3826
static enum gimplify_status
3827
gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
3828
{
3829
  tree expr = *expr_p;
3830
  tree op0 = TREE_OPERAND (expr, 0);
3831
  enum gimplify_status ret;
3832
 
3833
  switch (TREE_CODE (op0))
3834
    {
3835
    case INDIRECT_REF:
3836
    case MISALIGNED_INDIRECT_REF:
3837
    do_indirect_ref:
3838
      /* Check if we are dealing with an expression of the form '&*ptr'.
3839
         While the front end folds away '&*ptr' into 'ptr', these
3840
         expressions may be generated internally by the compiler (e.g.,
3841
         builtins like __builtin_va_end).  */
3842
      /* Caution: the silent array decomposition semantics we allow for
3843
         ADDR_EXPR means we can't always discard the pair.  */
3844
      /* Gimplification of the ADDR_EXPR operand may drop
3845
         cv-qualification conversions, so make sure we add them if
3846
         needed.  */
3847
      {
3848
        tree op00 = TREE_OPERAND (op0, 0);
3849
        tree t_expr = TREE_TYPE (expr);
3850
        tree t_op00 = TREE_TYPE (op00);
3851
 
3852
        if (!lang_hooks.types_compatible_p (t_expr, t_op00))
3853
          {
3854
#ifdef ENABLE_CHECKING
3855
            tree t_op0 = TREE_TYPE (op0);
3856
            gcc_assert (POINTER_TYPE_P (t_expr)
3857
                        && cpt_same_type (TREE_CODE (t_op0) == ARRAY_TYPE
3858
                                          ? TREE_TYPE (t_op0) : t_op0,
3859
                                          TREE_TYPE (t_expr))
3860
                        && POINTER_TYPE_P (t_op00)
3861
                        && cpt_same_type (t_op0, TREE_TYPE (t_op00)));
3862
#endif
3863
            op00 = fold_convert (TREE_TYPE (expr), op00);
3864
          }
3865
        *expr_p = op00;
3866
        ret = GS_OK;
3867
      }
3868
      break;
3869
 
3870
    case VIEW_CONVERT_EXPR:
3871
      /* Take the address of our operand and then convert it to the type of
3872
         this ADDR_EXPR.
3873
 
3874
         ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
3875
         all clear.  The impact of this transformation is even less clear.  */
3876
 
3877
      /* If the operand is a useless conversion, look through it.  Doing so
3878
         guarantees that the ADDR_EXPR and its operand will remain of the
3879
         same type.  */
3880
      if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
3881
        op0 = TREE_OPERAND (op0, 0);
3882
 
3883
      *expr_p = fold_convert (TREE_TYPE (expr),
3884
                              build_fold_addr_expr (TREE_OPERAND (op0, 0)));
3885
      ret = GS_OK;
3886
      break;
3887
 
3888
    default:
3889
      /* We use fb_either here because the C frontend sometimes takes
3890
         the address of a call that returns a struct; see
3891
         gcc.dg/c99-array-lval-1.c.  The gimplifier will correctly make
3892
         the implied temporary explicit.  */
3893
      ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
3894
                           is_gimple_addressable, fb_either);
3895
      if (ret != GS_ERROR)
3896
        {
3897
          op0 = TREE_OPERAND (expr, 0);
3898
 
3899
          /* For various reasons, the gimplification of the expression
3900
             may have made a new INDIRECT_REF.  */
3901
          if (TREE_CODE (op0) == INDIRECT_REF)
3902
            goto do_indirect_ref;
3903
 
3904
          /* Make sure TREE_INVARIANT, TREE_CONSTANT, and TREE_SIDE_EFFECTS
3905
             is set properly.  */
3906
          recompute_tree_invariant_for_addr_expr (expr);
3907
 
3908
          /* Mark the RHS addressable.  */
3909
          lang_hooks.mark_addressable (TREE_OPERAND (expr, 0));
3910
        }
3911
      break;
3912
    }
3913
 
3914
  return ret;
3915
}
3916
 
3917
/* Gimplify the operands of an ASM_EXPR.  Input operands should be a gimple
3918
   value; output operands should be a gimple lvalue.  */
3919
 
3920
static enum gimplify_status
3921
gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p)
3922
{
3923
  tree expr = *expr_p;
3924
  int noutputs = list_length (ASM_OUTPUTS (expr));
3925
  const char **oconstraints
3926
    = (const char **) alloca ((noutputs) * sizeof (const char *));
3927
  int i;
3928
  tree link;
3929
  const char *constraint;
3930
  bool allows_mem, allows_reg, is_inout;
3931
  enum gimplify_status ret, tret;
3932
 
3933
  ret = GS_ALL_DONE;
3934
  for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link))
3935
    {
3936
      size_t constraint_len;
3937
      oconstraints[i] = constraint
3938
        = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
3939
      constraint_len = strlen (constraint);
3940
      if (constraint_len == 0)
3941
        continue;
3942
 
3943
      parse_output_constraint (&constraint, i, 0, 0,
3944
                               &allows_mem, &allows_reg, &is_inout);
3945
 
3946
      if (!allows_reg && allows_mem)
3947
        lang_hooks.mark_addressable (TREE_VALUE (link));
3948
 
3949
      tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3950
                            is_inout ? is_gimple_min_lval : is_gimple_lvalue,
3951
                            fb_lvalue | fb_mayfail);
3952
      if (tret == GS_ERROR)
3953
        {
3954
          error ("invalid lvalue in asm output %d", i);
3955
          ret = tret;
3956
        }
3957
 
3958
      if (is_inout)
3959
        {
3960
          /* An input/output operand.  To give the optimizers more
3961
             flexibility, split it into separate input and output
3962
             operands.  */
3963
          tree input;
3964
          char buf[10];
3965
 
3966
          /* Turn the in/out constraint into an output constraint.  */
3967
          char *p = xstrdup (constraint);
3968
          p[0] = '=';
3969
          TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
3970
 
3971
          /* And add a matching input constraint.  */
3972
          if (allows_reg)
3973
            {
3974
              sprintf (buf, "%d", i);
3975
 
3976
              /* If there are multiple alternatives in the constraint,
3977
                 handle each of them individually.  Those that allow register
3978
                 will be replaced with operand number, the others will stay
3979
                 unchanged.  */
3980
              if (strchr (p, ',') != NULL)
3981
                {
3982
                  size_t len = 0, buflen = strlen (buf);
3983
                  char *beg, *end, *str, *dst;
3984
 
3985
                  for (beg = p + 1;;)
3986
                    {
3987
                      end = strchr (beg, ',');
3988
                      if (end == NULL)
3989
                        end = strchr (beg, '\0');
3990
                      if ((size_t) (end - beg) < buflen)
3991
                        len += buflen + 1;
3992
                      else
3993
                        len += end - beg + 1;
3994
                      if (*end)
3995
                        beg = end + 1;
3996
                      else
3997
                        break;
3998
                    }
3999
 
4000
                  str = (char *) alloca (len);
4001
                  for (beg = p + 1, dst = str;;)
4002
                    {
4003
                      const char *tem;
4004
                      bool mem_p, reg_p, inout_p;
4005
 
4006
                      end = strchr (beg, ',');
4007
                      if (end)
4008
                        *end = '\0';
4009
                      beg[-1] = '=';
4010
                      tem = beg - 1;
4011
                      parse_output_constraint (&tem, i, 0, 0,
4012
                                               &mem_p, &reg_p, &inout_p);
4013
                      if (dst != str)
4014
                        *dst++ = ',';
4015
                      if (reg_p)
4016
                        {
4017
                          memcpy (dst, buf, buflen);
4018
                          dst += buflen;
4019
                        }
4020
                      else
4021
                        {
4022
                          if (end)
4023
                            len = end - beg;
4024
                          else
4025
                            len = strlen (beg);
4026
                          memcpy (dst, beg, len);
4027
                          dst += len;
4028
                        }
4029
                      if (end)
4030
                        beg = end + 1;
4031
                      else
4032
                        break;
4033
                    }
4034
                  *dst = '\0';
4035
                  input = build_string (dst - str, str);
4036
                }
4037
              else
4038
                input = build_string (strlen (buf), buf);
4039
            }
4040
          else
4041
            input = build_string (constraint_len - 1, constraint + 1);
4042
 
4043
          free (p);
4044
 
4045
          input = build_tree_list (build_tree_list (NULL_TREE, input),
4046
                                   unshare_expr (TREE_VALUE (link)));
4047
          ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
4048
        }
4049
    }
4050
 
4051
  for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link))
4052
    {
4053
      constraint
4054
        = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
4055
      parse_input_constraint (&constraint, 0, 0, noutputs, 0,
4056
                              oconstraints, &allows_mem, &allows_reg);
4057
 
4058
      /* If we can't make copies, we can only accept memory.  */
4059
      if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
4060
        {
4061
          if (allows_mem)
4062
            allows_reg = 0;
4063
          else
4064
            {
4065
              error ("impossible constraint in %<asm%>");
4066
              error ("non-memory input %d must stay in memory", i);
4067
              return GS_ERROR;
4068
            }
4069
        }
4070
 
4071
      /* If the operand is a memory input, it should be an lvalue.  */
4072
      if (!allows_reg && allows_mem)
4073
        {
4074
          tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4075
                                is_gimple_lvalue, fb_lvalue | fb_mayfail);
4076
          lang_hooks.mark_addressable (TREE_VALUE (link));
4077
          if (tret == GS_ERROR)
4078
            {
4079
              error ("memory input %d is not directly addressable", i);
4080
              ret = tret;
4081
            }
4082
        }
4083
      else
4084
        {
4085
          tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4086
                                is_gimple_asm_val, fb_rvalue);
4087
          if (tret == GS_ERROR)
4088
            ret = tret;
4089
        }
4090
    }
4091
 
4092
  return ret;
4093
}
4094
 
4095
/* Gimplify a CLEANUP_POINT_EXPR.  Currently this works by adding
4096
   WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
4097
   gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
4098
   return to this function.
4099
 
4100
   FIXME should we complexify the prequeue handling instead?  Or use flags
4101
   for all the cleanups and let the optimizer tighten them up?  The current
4102
   code seems pretty fragile; it will break on a cleanup within any
4103
   non-conditional nesting.  But any such nesting would be broken, anyway;
4104
   we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
4105
   and continues out of it.  We can do that at the RTL level, though, so
4106
   having an optimizer to tighten up try/finally regions would be a Good
4107
   Thing.  */
4108
 
4109
static enum gimplify_status
4110
gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p)
4111
{
4112
  tree_stmt_iterator iter;
4113
  tree body;
4114
 
4115
  tree temp = voidify_wrapper_expr (*expr_p, NULL);
4116
 
4117
  /* We only care about the number of conditions between the innermost
4118
     CLEANUP_POINT_EXPR and the cleanup.  So save and reset the count and
4119
     any cleanups collected outside the CLEANUP_POINT_EXPR.  */
4120
  int old_conds = gimplify_ctxp->conditions;
4121
  tree old_cleanups = gimplify_ctxp->conditional_cleanups;
4122
  gimplify_ctxp->conditions = 0;
4123
  gimplify_ctxp->conditional_cleanups = NULL_TREE;
4124
 
4125
  body = TREE_OPERAND (*expr_p, 0);
4126
  gimplify_to_stmt_list (&body);
4127
 
4128
  gimplify_ctxp->conditions = old_conds;
4129
  gimplify_ctxp->conditional_cleanups = old_cleanups;
4130
 
4131
  for (iter = tsi_start (body); !tsi_end_p (iter); )
4132
    {
4133
      tree *wce_p = tsi_stmt_ptr (iter);
4134
      tree wce = *wce_p;
4135
 
4136
      if (TREE_CODE (wce) == WITH_CLEANUP_EXPR)
4137
        {
4138
          if (tsi_one_before_end_p (iter))
4139
            {
4140
              tsi_link_before (&iter, TREE_OPERAND (wce, 0), TSI_SAME_STMT);
4141
              tsi_delink (&iter);
4142
              break;
4143
            }
4144
          else
4145
            {
4146
              tree sl, tfe;
4147
              enum tree_code code;
4148
 
4149
              if (CLEANUP_EH_ONLY (wce))
4150
                code = TRY_CATCH_EXPR;
4151
              else
4152
                code = TRY_FINALLY_EXPR;
4153
 
4154
              sl = tsi_split_statement_list_after (&iter);
4155
              tfe = build2 (code, void_type_node, sl, NULL_TREE);
4156
              append_to_statement_list (TREE_OPERAND (wce, 0),
4157
                                        &TREE_OPERAND (tfe, 1));
4158
              *wce_p = tfe;
4159
              iter = tsi_start (sl);
4160
            }
4161
        }
4162
      else
4163
        tsi_next (&iter);
4164
    }
4165
 
4166
  if (temp)
4167
    {
4168
      *expr_p = temp;
4169
      append_to_statement_list (body, pre_p);
4170
      return GS_OK;
4171
    }
4172
  else
4173
    {
4174
      *expr_p = body;
4175
      return GS_ALL_DONE;
4176
    }
4177
}
4178
 
4179
/* Insert a cleanup marker for gimplify_cleanup_point_expr.  CLEANUP
4180
   is the cleanup action required.  */
4181
 
4182
static void
4183
gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p)
4184
{
4185
  tree wce;
4186
 
4187
  /* Errors can result in improperly nested cleanups.  Which results in
4188
     confusion when trying to resolve the WITH_CLEANUP_EXPR.  */
4189
  if (errorcount || sorrycount)
4190
    return;
4191
 
4192
  if (gimple_conditional_context ())
4193
    {
4194
      /* If we're in a conditional context, this is more complex.  We only
4195
         want to run the cleanup if we actually ran the initialization that
4196
         necessitates it, but we want to run it after the end of the
4197
         conditional context.  So we wrap the try/finally around the
4198
         condition and use a flag to determine whether or not to actually
4199
         run the destructor.  Thus
4200
 
4201
           test ? f(A()) : 0
4202
 
4203
         becomes (approximately)
4204
 
4205
           flag = 0;
4206
           try {
4207
             if (test) { A::A(temp); flag = 1; val = f(temp); }
4208
             else { val = 0; }
4209
           } finally {
4210
             if (flag) A::~A(temp);
4211
           }
4212
           val
4213
      */
4214
 
4215
      tree flag = create_tmp_var (boolean_type_node, "cleanup");
4216
      tree ffalse = build2 (MODIFY_EXPR, void_type_node, flag,
4217
                            boolean_false_node);
4218
      tree ftrue = build2 (MODIFY_EXPR, void_type_node, flag,
4219
                           boolean_true_node);
4220
      cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
4221
      wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4222
      append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups);
4223
      append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups);
4224
      append_to_statement_list (ftrue, pre_p);
4225
 
4226
      /* Because of this manipulation, and the EH edges that jump
4227
         threading cannot redirect, the temporary (VAR) will appear
4228
         to be used uninitialized.  Don't warn.  */
4229
      TREE_NO_WARNING (var) = 1;
4230
    }
4231
  else
4232
    {
4233
      wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4234
      CLEANUP_EH_ONLY (wce) = eh_only;
4235
      append_to_statement_list (wce, pre_p);
4236
    }
4237
 
4238
  gimplify_stmt (&TREE_OPERAND (wce, 0));
4239
}
4240
 
4241
/* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR.  */
4242
 
4243
static enum gimplify_status
4244
gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p)
4245
{
4246
  tree targ = *expr_p;
4247
  tree temp = TARGET_EXPR_SLOT (targ);
4248
  tree init = TARGET_EXPR_INITIAL (targ);
4249
  enum gimplify_status ret;
4250
 
4251
  if (init)
4252
    {
4253
      /* TARGET_EXPR temps aren't part of the enclosing block, so add it
4254
         to the temps list.  */
4255
      gimple_add_tmp_var (temp);
4256
 
4257
      /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
4258
         expression is supposed to initialize the slot.  */
4259
      if (VOID_TYPE_P (TREE_TYPE (init)))
4260
        ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
4261
      else
4262
        {
4263
          init = build2 (INIT_EXPR, void_type_node, temp, init);
4264
          ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt,
4265
                               fb_none);
4266
        }
4267
      if (ret == GS_ERROR)
4268
        {
4269
          /* PR c++/28266 Make sure this is expanded only once. */
4270
          TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4271
          return GS_ERROR;
4272
        }
4273
      append_to_statement_list (init, pre_p);
4274
 
4275
      /* If needed, push the cleanup for the temp.  */
4276
      if (TARGET_EXPR_CLEANUP (targ))
4277
        {
4278
          gimplify_stmt (&TARGET_EXPR_CLEANUP (targ));
4279
          gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
4280
                               CLEANUP_EH_ONLY (targ), pre_p);
4281
        }
4282
 
4283
      /* Only expand this once.  */
4284
      TREE_OPERAND (targ, 3) = init;
4285
      TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4286
    }
4287
  else
4288
    /* We should have expanded this before.  */
4289
    gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
4290
 
4291
  *expr_p = temp;
4292
  return GS_OK;
4293
}
4294
 
4295
/* Gimplification of expression trees.  */
4296
 
4297
/* Gimplify an expression which appears at statement context; usually, this
4298
   means replacing it with a suitably gimple STATEMENT_LIST.  */
4299
 
4300
void
4301
gimplify_stmt (tree *stmt_p)
4302
{
4303
  gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none);
4304
}
4305
 
4306
/* Similarly, but force the result to be a STATEMENT_LIST.  */
4307
 
4308
void
4309
gimplify_to_stmt_list (tree *stmt_p)
4310
{
4311
  gimplify_stmt (stmt_p);
4312
  if (!*stmt_p)
4313
    *stmt_p = alloc_stmt_list ();
4314
  else if (TREE_CODE (*stmt_p) != STATEMENT_LIST)
4315
    {
4316
      tree t = *stmt_p;
4317
      *stmt_p = alloc_stmt_list ();
4318
      append_to_statement_list (t, stmt_p);
4319
    }
4320
}
4321
 
4322
 
4323
/* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
4324
   to CTX.  If entries already exist, force them to be some flavor of private.
4325
   If there is no enclosing parallel, do nothing.  */
4326
 
4327
void
4328
omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
4329
{
4330
  splay_tree_node n;
4331
 
4332
  if (decl == NULL || !DECL_P (decl))
4333
    return;
4334
 
4335
  do
4336
    {
4337
      n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4338
      if (n != NULL)
4339
        {
4340
          if (n->value & GOVD_SHARED)
4341
            n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
4342
          else
4343
            return;
4344
        }
4345
      else if (ctx->is_parallel)
4346
        omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
4347
 
4348
      ctx = ctx->outer_context;
4349
    }
4350
  while (ctx);
4351
}
4352
 
4353
/* Similarly for each of the type sizes of TYPE.  */
4354
 
4355
static void
4356
omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
4357
{
4358
  if (type == NULL || type == error_mark_node)
4359
    return;
4360
  type = TYPE_MAIN_VARIANT (type);
4361
 
4362
  if (pointer_set_insert (ctx->privatized_types, type))
4363
    return;
4364
 
4365
  switch (TREE_CODE (type))
4366
    {
4367
    case INTEGER_TYPE:
4368
    case ENUMERAL_TYPE:
4369
    case BOOLEAN_TYPE:
4370
    case REAL_TYPE:
4371
      omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
4372
      omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
4373
      break;
4374
 
4375
    case ARRAY_TYPE:
4376
      omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4377
      omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
4378
      break;
4379
 
4380
    case RECORD_TYPE:
4381
    case UNION_TYPE:
4382
    case QUAL_UNION_TYPE:
4383
      {
4384
        tree field;
4385
        for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4386
          if (TREE_CODE (field) == FIELD_DECL)
4387
            {
4388
              omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
4389
              omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
4390
            }
4391
      }
4392
      break;
4393
 
4394
    case POINTER_TYPE:
4395
    case REFERENCE_TYPE:
4396
      omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4397
      break;
4398
 
4399
    default:
4400
      break;
4401
    }
4402
 
4403
  omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
4404
  omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
4405
  lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
4406
}
4407
 
4408
/* Add an entry for DECL in the OpenMP context CTX with FLAGS.  */
4409
 
4410
static void
4411
omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
4412
{
4413
  splay_tree_node n;
4414
  unsigned int nflags;
4415
  tree t;
4416
 
4417
  if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4418
    return;
4419
 
4420
  /* Never elide decls whose type has TREE_ADDRESSABLE set.  This means
4421
     there are constructors involved somewhere.  */
4422
  if (TREE_ADDRESSABLE (TREE_TYPE (decl))
4423
      || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
4424
    flags |= GOVD_SEEN;
4425
 
4426
  n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4427
  if (n != NULL)
4428
    {
4429
      /* We shouldn't be re-adding the decl with the same data
4430
         sharing class.  */
4431
      gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
4432
      /* The only combination of data sharing classes we should see is
4433
         FIRSTPRIVATE and LASTPRIVATE.  */
4434
      nflags = n->value | flags;
4435
      gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
4436
                  == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
4437
      n->value = nflags;
4438
      return;
4439
    }
4440
 
4441
  /* When adding a variable-sized variable, we have to handle all sorts
4442
     of additional bits of data: the pointer replacement variable, and
4443
     the parameters of the type.  */
4444
  if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
4445
    {
4446
      /* Add the pointer replacement variable as PRIVATE if the variable
4447
         replacement is private, else FIRSTPRIVATE since we'll need the
4448
         address of the original variable either for SHARED, or for the
4449
         copy into or out of the context.  */
4450
      if (!(flags & GOVD_LOCAL))
4451
        {
4452
          nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
4453
          nflags |= flags & GOVD_SEEN;
4454
          t = DECL_VALUE_EXPR (decl);
4455
          gcc_assert (TREE_CODE (t) == INDIRECT_REF);
4456
          t = TREE_OPERAND (t, 0);
4457
          gcc_assert (DECL_P (t));
4458
          omp_add_variable (ctx, t, nflags);
4459
        }
4460
 
4461
      /* Add all of the variable and type parameters (which should have
4462
         been gimplified to a formal temporary) as FIRSTPRIVATE.  */
4463
      omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
4464
      omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
4465
      omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4466
 
4467
      /* The variable-sized variable itself is never SHARED, only some form
4468
         of PRIVATE.  The sharing would take place via the pointer variable
4469
         which we remapped above.  */
4470
      if (flags & GOVD_SHARED)
4471
        flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
4472
                | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
4473
 
4474
      /* We're going to make use of the TYPE_SIZE_UNIT at least in the
4475
         alloca statement we generate for the variable, so make sure it
4476
         is available.  This isn't automatically needed for the SHARED
4477
         case, since we won't be allocating local storage then.
4478
         For local variables TYPE_SIZE_UNIT might not be gimplified yet,
4479
         in this case omp_notice_variable will be called later
4480
         on when it is gimplified.  */
4481
      else if (! (flags & GOVD_LOCAL))
4482
        omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
4483
    }
4484
  else if (lang_hooks.decls.omp_privatize_by_reference (decl))
4485
    {
4486
      gcc_assert ((flags & GOVD_LOCAL) == 0);
4487
      omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4488
 
4489
      /* Similar to the direct variable sized case above, we'll need the
4490
         size of references being privatized.  */
4491
      if ((flags & GOVD_SHARED) == 0)
4492
        {
4493
          t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
4494
          if (TREE_CODE (t) != INTEGER_CST)
4495
            omp_notice_variable (ctx, t, true);
4496
        }
4497
    }
4498
 
4499
  splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
4500
}
4501
 
4502
/* Record the fact that DECL was used within the OpenMP context CTX.
4503
   IN_CODE is true when real code uses DECL, and false when we should
4504
   merely emit default(none) errors.  Return true if DECL is going to
4505
   be remapped and thus DECL shouldn't be gimplified into its
4506
   DECL_VALUE_EXPR (if any).  */
4507
 
4508
static bool
4509
omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
4510
{
4511
  splay_tree_node n;
4512
  unsigned flags = in_code ? GOVD_SEEN : 0;
4513
  bool ret = false, shared;
4514
 
4515
  if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4516
    return false;
4517
 
4518
  /* Threadprivate variables are predetermined.  */
4519
  if (is_global_var (decl))
4520
    {
4521
      if (DECL_THREAD_LOCAL_P (decl))
4522
        return false;
4523
 
4524
      if (DECL_HAS_VALUE_EXPR_P (decl))
4525
        {
4526
          tree value = get_base_address (DECL_VALUE_EXPR (decl));
4527
 
4528
          if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
4529
            return false;
4530
        }
4531
    }
4532
 
4533
  n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4534
  if (n == NULL)
4535
    {
4536
      enum omp_clause_default_kind default_kind, kind;
4537
 
4538
      if (!ctx->is_parallel)
4539
        goto do_outer;
4540
 
4541
      /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
4542
         remapped firstprivate instead of shared.  To some extent this is
4543
         addressed in omp_firstprivatize_type_sizes, but not effectively.  */
4544
      default_kind = ctx->default_kind;
4545
      kind = lang_hooks.decls.omp_predetermined_sharing (decl);
4546
      if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
4547
        default_kind = kind;
4548
 
4549
      switch (default_kind)
4550
        {
4551
        case OMP_CLAUSE_DEFAULT_NONE:
4552
          error ("%qs not specified in enclosing parallel",
4553
                 IDENTIFIER_POINTER (DECL_NAME (decl)));
4554
          error ("%Henclosing parallel", &ctx->location);
4555
          /* FALLTHRU */
4556
        case OMP_CLAUSE_DEFAULT_SHARED:
4557
          flags |= GOVD_SHARED;
4558
          break;
4559
        case OMP_CLAUSE_DEFAULT_PRIVATE:
4560
          flags |= GOVD_PRIVATE;
4561
          break;
4562
        default:
4563
          gcc_unreachable ();
4564
        }
4565
 
4566
      omp_add_variable (ctx, decl, flags);
4567
 
4568
      shared = (flags & GOVD_SHARED) != 0;
4569
      ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4570
      goto do_outer;
4571
    }
4572
 
4573
  shared = ((flags | n->value) & GOVD_SHARED) != 0;
4574
  ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4575
 
4576
  /* If nothing changed, there's nothing left to do.  */
4577
  if ((n->value & flags) == flags)
4578
    return ret;
4579
  flags |= n->value;
4580
  n->value = flags;
4581
 
4582
 do_outer:
4583
  /* If the variable is private in the current context, then we don't
4584
     need to propagate anything to an outer context.  */
4585
  if (flags & GOVD_PRIVATE)
4586
    return ret;
4587
  if (ctx->outer_context
4588
      && omp_notice_variable (ctx->outer_context, decl, in_code))
4589
    return true;
4590
  return ret;
4591
}
4592
 
4593
/* Verify that DECL is private within CTX.  If there's specific information
4594
   to the contrary in the innermost scope, generate an error.  */
4595
 
4596
static bool
4597
omp_is_private (struct gimplify_omp_ctx *ctx, tree decl)
4598
{
4599
  splay_tree_node n;
4600
 
4601
  n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4602
  if (n != NULL)
4603
    {
4604
      if (n->value & GOVD_SHARED)
4605
        {
4606
          if (ctx == gimplify_omp_ctxp)
4607
            {
4608
              error ("iteration variable %qs should be private",
4609
                     IDENTIFIER_POINTER (DECL_NAME (decl)));
4610
              n->value = GOVD_PRIVATE;
4611
              return true;
4612
            }
4613
          else
4614
            return false;
4615
        }
4616
      else if ((n->value & GOVD_EXPLICIT) != 0
4617
               && (ctx == gimplify_omp_ctxp
4618
                   || (ctx->is_combined_parallel
4619
                       && gimplify_omp_ctxp->outer_context == ctx)))
4620
        {
4621
          if ((n->value & GOVD_FIRSTPRIVATE) != 0)
4622
            error ("iteration variable %qs should not be firstprivate",
4623
                   IDENTIFIER_POINTER (DECL_NAME (decl)));
4624
          else if ((n->value & GOVD_REDUCTION) != 0)
4625
            error ("iteration variable %qs should not be reduction",
4626
                   IDENTIFIER_POINTER (DECL_NAME (decl)));
4627
        }
4628
      return true;
4629
    }
4630
 
4631
  if (ctx->is_parallel)
4632
    return false;
4633
  else if (ctx->outer_context)
4634
    return omp_is_private (ctx->outer_context, decl);
4635
  else
4636
    return !is_global_var (decl);
4637
}
4638
 
4639
/* Return true if DECL is private within a parallel region
4640
   that binds to the current construct's context or in parallel
4641
   region's REDUCTION clause.  */
4642
 
4643
static bool
4644
omp_check_private (struct gimplify_omp_ctx *ctx, tree decl)
4645
{
4646
  splay_tree_node n;
4647
 
4648
  do
4649
    {
4650
      ctx = ctx->outer_context;
4651
      if (ctx == NULL)
4652
        return !(is_global_var (decl)
4653
                 /* References might be private, but might be shared too.  */
4654
                 || lang_hooks.decls.omp_privatize_by_reference (decl));
4655
 
4656
      n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4657
      if (n != NULL)
4658
        return (n->value & GOVD_SHARED) == 0;
4659
    }
4660
  while (!ctx->is_parallel);
4661
  return false;
4662
}
4663
 
4664
/* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
4665
   and previous omp contexts.  */
4666
 
4667
static void
4668
gimplify_scan_omp_clauses (tree *list_p, tree *pre_p, bool in_parallel,
4669
                           bool in_combined_parallel)
4670
{
4671
  struct gimplify_omp_ctx *ctx, *outer_ctx;
4672
  tree c;
4673
 
4674
  ctx = new_omp_context (in_parallel, in_combined_parallel);
4675
  outer_ctx = ctx->outer_context;
4676
 
4677
  while ((c = *list_p) != NULL)
4678
    {
4679
      enum gimplify_status gs;
4680
      bool remove = false;
4681
      bool notice_outer = true;
4682
      const char *check_non_private = NULL;
4683
      unsigned int flags;
4684
      tree decl;
4685
 
4686
      switch (OMP_CLAUSE_CODE (c))
4687
        {
4688
        case OMP_CLAUSE_PRIVATE:
4689
          flags = GOVD_PRIVATE | GOVD_EXPLICIT;
4690
          notice_outer = false;
4691
          goto do_add;
4692
        case OMP_CLAUSE_SHARED:
4693
          flags = GOVD_SHARED | GOVD_EXPLICIT;
4694
          goto do_add;
4695
        case OMP_CLAUSE_FIRSTPRIVATE:
4696
          flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
4697
          check_non_private = "firstprivate";
4698
          goto do_add;
4699
        case OMP_CLAUSE_LASTPRIVATE:
4700
          flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
4701
          check_non_private = "lastprivate";
4702
          goto do_add;
4703
        case OMP_CLAUSE_REDUCTION:
4704
          flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
4705
          check_non_private = "reduction";
4706
          goto do_add;
4707
 
4708
        do_add:
4709
          decl = OMP_CLAUSE_DECL (c);
4710
          if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4711
            {
4712
              remove = true;
4713
              break;
4714
            }
4715
          omp_add_variable (ctx, decl, flags);
4716
          if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
4717
              && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
4718
            {
4719
              omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
4720
                                GOVD_LOCAL | GOVD_SEEN);
4721
              gimplify_omp_ctxp = ctx;
4722
              push_gimplify_context ();
4723
              gimplify_stmt (&OMP_CLAUSE_REDUCTION_INIT (c));
4724
              pop_gimplify_context (OMP_CLAUSE_REDUCTION_INIT (c));
4725
              push_gimplify_context ();
4726
              gimplify_stmt (&OMP_CLAUSE_REDUCTION_MERGE (c));
4727
              pop_gimplify_context (OMP_CLAUSE_REDUCTION_MERGE (c));
4728
              gimplify_omp_ctxp = outer_ctx;
4729
            }
4730
          if (notice_outer)
4731
            goto do_notice;
4732
          break;
4733
 
4734
        case OMP_CLAUSE_COPYIN:
4735
        case OMP_CLAUSE_COPYPRIVATE:
4736
          decl = OMP_CLAUSE_DECL (c);
4737
          if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4738
            {
4739
              remove = true;
4740
              break;
4741
            }
4742
        do_notice:
4743
          if (outer_ctx)
4744
            omp_notice_variable (outer_ctx, decl, true);
4745
          if (check_non_private
4746
              && !in_parallel
4747
              && omp_check_private (ctx, decl))
4748
            {
4749
              error ("%s variable %qs is private in outer context",
4750
                     check_non_private, IDENTIFIER_POINTER (DECL_NAME (decl)));
4751
              remove = true;
4752
            }
4753
          break;
4754
 
4755
        case OMP_CLAUSE_IF:
4756
          OMP_CLAUSE_OPERAND (c, 0)
4757
            = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
4758
          /* Fall through.  */
4759
 
4760
        case OMP_CLAUSE_SCHEDULE:
4761
        case OMP_CLAUSE_NUM_THREADS:
4762
          gs = gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
4763
                              is_gimple_val, fb_rvalue);
4764
          if (gs == GS_ERROR)
4765
            remove = true;
4766
          break;
4767
 
4768
        case OMP_CLAUSE_NOWAIT:
4769
        case OMP_CLAUSE_ORDERED:
4770
          break;
4771
 
4772
        case OMP_CLAUSE_DEFAULT:
4773
          ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
4774
          break;
4775
 
4776
        default:
4777
          gcc_unreachable ();
4778
        }
4779
 
4780
      if (remove)
4781
        *list_p = OMP_CLAUSE_CHAIN (c);
4782
      else
4783
        list_p = &OMP_CLAUSE_CHAIN (c);
4784
    }
4785
 
4786
  gimplify_omp_ctxp = ctx;
4787
}
4788
 
4789
/* For all variables that were not actually used within the context,
4790
   remove PRIVATE, SHARED, and FIRSTPRIVATE clauses.  */
4791
 
4792
static int
4793
gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
4794
{
4795
  tree *list_p = (tree *) data;
4796
  tree decl = (tree) n->key;
4797
  unsigned flags = n->value;
4798
  enum omp_clause_code code;
4799
  tree clause;
4800
  bool private_debug;
4801
 
4802
  if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
4803
    return 0;
4804
  if ((flags & GOVD_SEEN) == 0)
4805
    return 0;
4806
  if (flags & GOVD_DEBUG_PRIVATE)
4807
    {
4808
      gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
4809
      private_debug = true;
4810
    }
4811
  else
4812
    private_debug
4813
      = lang_hooks.decls.omp_private_debug_clause (decl,
4814
                                                   !!(flags & GOVD_SHARED));
4815
  if (private_debug)
4816
    code = OMP_CLAUSE_PRIVATE;
4817
  else if (flags & GOVD_SHARED)
4818
    {
4819
      if (is_global_var (decl))
4820
        {
4821
          struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
4822
          while (ctx != NULL)
4823
            {
4824
              splay_tree_node on
4825
                = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4826
              if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
4827
                                      | GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
4828
                break;
4829
              ctx = ctx->outer_context;
4830
            }
4831
          if (ctx == NULL)
4832
            return 0;
4833
        }
4834
      code = OMP_CLAUSE_SHARED;
4835
    }
4836
  else if (flags & GOVD_PRIVATE)
4837
    code = OMP_CLAUSE_PRIVATE;
4838
  else if (flags & GOVD_FIRSTPRIVATE)
4839
    code = OMP_CLAUSE_FIRSTPRIVATE;
4840
  else
4841
    gcc_unreachable ();
4842
 
4843
  clause = build_omp_clause (code);
4844
  OMP_CLAUSE_DECL (clause) = decl;
4845
  OMP_CLAUSE_CHAIN (clause) = *list_p;
4846
  if (private_debug)
4847
    OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
4848
  *list_p = clause;
4849
 
4850
  return 0;
4851
}
4852
 
4853
static void
4854
gimplify_adjust_omp_clauses (tree *list_p)
4855
{
4856
  struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
4857
  tree c, decl;
4858
 
4859
  while ((c = *list_p) != NULL)
4860
    {
4861
      splay_tree_node n;
4862
      bool remove = false;
4863
 
4864
      switch (OMP_CLAUSE_CODE (c))
4865
        {
4866
        case OMP_CLAUSE_PRIVATE:
4867
        case OMP_CLAUSE_SHARED:
4868
        case OMP_CLAUSE_FIRSTPRIVATE:
4869
          decl = OMP_CLAUSE_DECL (c);
4870
          n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4871
          remove = !(n->value & GOVD_SEEN);
4872
          if (! remove)
4873
            {
4874
              bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
4875
              if ((n->value & GOVD_DEBUG_PRIVATE)
4876
                  || lang_hooks.decls.omp_private_debug_clause (decl, shared))
4877
                {
4878
                  gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
4879
                              || ((n->value & GOVD_DATA_SHARE_CLASS)
4880
                                  == GOVD_PRIVATE));
4881
                  OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
4882
                  OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
4883
                }
4884
            }
4885
          break;
4886
 
4887
        case OMP_CLAUSE_LASTPRIVATE:
4888
          /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
4889
             accurately reflect the presence of a FIRSTPRIVATE clause.  */
4890
          decl = OMP_CLAUSE_DECL (c);
4891
          n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4892
          OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
4893
            = (n->value & GOVD_FIRSTPRIVATE) != 0;
4894
          break;
4895
 
4896
        case OMP_CLAUSE_REDUCTION:
4897
        case OMP_CLAUSE_COPYIN:
4898
        case OMP_CLAUSE_COPYPRIVATE:
4899
        case OMP_CLAUSE_IF:
4900
        case OMP_CLAUSE_NUM_THREADS:
4901
        case OMP_CLAUSE_SCHEDULE:
4902
        case OMP_CLAUSE_NOWAIT:
4903
        case OMP_CLAUSE_ORDERED:
4904
        case OMP_CLAUSE_DEFAULT:
4905
          break;
4906
 
4907
        default:
4908
          gcc_unreachable ();
4909
        }
4910
 
4911
      if (remove)
4912
        *list_p = OMP_CLAUSE_CHAIN (c);
4913
      else
4914
        list_p = &OMP_CLAUSE_CHAIN (c);
4915
    }
4916
 
4917
  /* Add in any implicit data sharing.  */
4918
  splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
4919
 
4920
  gimplify_omp_ctxp = ctx->outer_context;
4921
  delete_omp_context (ctx);
4922
}
4923
 
4924
/* Gimplify the contents of an OMP_PARALLEL statement.  This involves
4925
   gimplification of the body, as well as scanning the body for used
4926
   variables.  We need to do this scan now, because variable-sized
4927
   decls will be decomposed during gimplification.  */
4928
 
4929
static enum gimplify_status
4930
gimplify_omp_parallel (tree *expr_p, tree *pre_p)
4931
{
4932
  tree expr = *expr_p;
4933
 
4934
  gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p, true,
4935
                             OMP_PARALLEL_COMBINED (expr));
4936
 
4937
  push_gimplify_context ();
4938
 
4939
  gimplify_stmt (&OMP_PARALLEL_BODY (expr));
4940
 
4941
  if (TREE_CODE (OMP_PARALLEL_BODY (expr)) == BIND_EXPR)
4942
    pop_gimplify_context (OMP_PARALLEL_BODY (expr));
4943
  else
4944
    pop_gimplify_context (NULL_TREE);
4945
 
4946
  gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
4947
 
4948
  return GS_ALL_DONE;
4949
}
4950
 
4951
/* Gimplify the gross structure of an OMP_FOR statement.  */
4952
 
4953
static enum gimplify_status
4954
gimplify_omp_for (tree *expr_p, tree *pre_p)
4955
{
4956
  tree for_stmt, decl, t;
4957
  enum gimplify_status ret = 0;
4958
 
4959
  for_stmt = *expr_p;
4960
 
4961
  gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, false, false);
4962
 
4963
  t = OMP_FOR_INIT (for_stmt);
4964
  gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
4965
  decl = TREE_OPERAND (t, 0);
4966
  gcc_assert (DECL_P (decl));
4967
  gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl)));
4968
 
4969
  /* Make sure the iteration variable is private.  */
4970
  if (omp_is_private (gimplify_omp_ctxp, decl))
4971
    omp_notice_variable (gimplify_omp_ctxp, decl, true);
4972
  else
4973
    omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
4974
 
4975
  ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
4976
                        NULL, is_gimple_val, fb_rvalue);
4977
 
4978
  t = OMP_FOR_COND (for_stmt);
4979
  gcc_assert (COMPARISON_CLASS_P (t));
4980
  gcc_assert (TREE_OPERAND (t, 0) == decl);
4981
 
4982
  ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
4983
                        NULL, is_gimple_val, fb_rvalue);
4984
 
4985
  t = OMP_FOR_INCR (for_stmt);
4986
  switch (TREE_CODE (t))
4987
    {
4988
    case PREINCREMENT_EXPR:
4989
    case POSTINCREMENT_EXPR:
4990
      t = build_int_cst (TREE_TYPE (decl), 1);
4991
      goto build_modify;
4992
    case PREDECREMENT_EXPR:
4993
    case POSTDECREMENT_EXPR:
4994
      t = build_int_cst (TREE_TYPE (decl), -1);
4995
      goto build_modify;
4996
    build_modify:
4997
      t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t);
4998
      t = build2 (MODIFY_EXPR, void_type_node, decl, t);
4999
      OMP_FOR_INCR (for_stmt) = t;
5000
      break;
5001
 
5002
    case MODIFY_EXPR:
5003
      gcc_assert (TREE_OPERAND (t, 0) == decl);
5004
      t = TREE_OPERAND (t, 1);
5005
      switch (TREE_CODE (t))
5006
        {
5007
        case PLUS_EXPR:
5008
          if (TREE_OPERAND (t, 1) == decl)
5009
            {
5010
              TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
5011
              TREE_OPERAND (t, 0) = decl;
5012
              break;
5013
            }
5014
        case MINUS_EXPR:
5015
          gcc_assert (TREE_OPERAND (t, 0) == decl);
5016
          break;
5017
        default:
5018
          gcc_unreachable ();
5019
        }
5020
 
5021
      ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
5022
                            NULL, is_gimple_val, fb_rvalue);
5023
      break;
5024
 
5025
    default:
5026
      gcc_unreachable ();
5027
    }
5028
 
5029
  gimplify_to_stmt_list (&OMP_FOR_BODY (for_stmt));
5030
  gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
5031
 
5032
  return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR;
5033
}
5034
 
5035
/* Gimplify the gross structure of other OpenMP worksharing constructs.
5036
   In particular, OMP_SECTIONS and OMP_SINGLE.  */
5037
 
5038
static enum gimplify_status
5039
gimplify_omp_workshare (tree *expr_p, tree *pre_p)
5040
{
5041
  tree stmt = *expr_p;
5042
 
5043
  gimplify_scan_omp_clauses (&OMP_CLAUSES (stmt), pre_p, false, false);
5044
  gimplify_to_stmt_list (&OMP_BODY (stmt));
5045
  gimplify_adjust_omp_clauses (&OMP_CLAUSES (stmt));
5046
 
5047
  return GS_ALL_DONE;
5048
}
5049
 
5050
/* A subroutine of gimplify_omp_atomic.  The front end is supposed to have
5051
   stabilized the lhs of the atomic operation as *ADDR.  Return true if
5052
   EXPR is this stabilized form.  */
5053
 
5054
static bool
5055
goa_lhs_expr_p (tree expr, tree addr)
5056
{
5057
  /* Also include casts to other type variants.  The C front end is fond
5058
     of adding these for e.g. volatile variables.  This is like
5059
     STRIP_TYPE_NOPS but includes the main variant lookup.  */
5060
  while ((TREE_CODE (expr) == NOP_EXPR
5061
          || TREE_CODE (expr) == CONVERT_EXPR
5062
          || TREE_CODE (expr) == NON_LVALUE_EXPR)
5063
         && TREE_OPERAND (expr, 0) != error_mark_node
5064
         && (TYPE_MAIN_VARIANT (TREE_TYPE (expr))
5065
             == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (expr, 0)))))
5066
    expr = TREE_OPERAND (expr, 0);
5067
 
5068
  if (TREE_CODE (expr) == INDIRECT_REF && TREE_OPERAND (expr, 0) == addr)
5069
    return true;
5070
  if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
5071
    return true;
5072
  return false;
5073
}
5074
 
5075
/* A subroutine of gimplify_omp_atomic.  Attempt to implement the atomic
5076
   operation as a __sync_fetch_and_op builtin.  INDEX is log2 of the
5077
   size of the data type, and thus usable to find the index of the builtin
5078
   decl.  Returns GS_UNHANDLED if the expression is not of the proper form.  */
5079
 
5080
static enum gimplify_status
5081
gimplify_omp_atomic_fetch_op (tree *expr_p, tree addr, tree rhs, int index)
5082
{
5083
  enum built_in_function base;
5084
  tree decl, args, itype;
5085
  enum insn_code *optab;
5086
 
5087
  /* Check for one of the supported fetch-op operations.  */
5088
  switch (TREE_CODE (rhs))
5089
    {
5090
    case PLUS_EXPR:
5091
      base = BUILT_IN_FETCH_AND_ADD_N;
5092
      optab = sync_add_optab;
5093
      break;
5094
    case MINUS_EXPR:
5095
      base = BUILT_IN_FETCH_AND_SUB_N;
5096
      optab = sync_add_optab;
5097
      break;
5098
    case BIT_AND_EXPR:
5099
      base = BUILT_IN_FETCH_AND_AND_N;
5100
      optab = sync_and_optab;
5101
      break;
5102
    case BIT_IOR_EXPR:
5103
      base = BUILT_IN_FETCH_AND_OR_N;
5104
      optab = sync_ior_optab;
5105
      break;
5106
    case BIT_XOR_EXPR:
5107
      base = BUILT_IN_FETCH_AND_XOR_N;
5108
      optab = sync_xor_optab;
5109
      break;
5110
    default:
5111
      return GS_UNHANDLED;
5112
    }
5113
 
5114
  /* Make sure the expression is of the proper form.  */
5115
  if (goa_lhs_expr_p (TREE_OPERAND (rhs, 0), addr))
5116
    rhs = TREE_OPERAND (rhs, 1);
5117
  else if (commutative_tree_code (TREE_CODE (rhs))
5118
           && goa_lhs_expr_p (TREE_OPERAND (rhs, 1), addr))
5119
    rhs = TREE_OPERAND (rhs, 0);
5120
  else
5121
    return GS_UNHANDLED;
5122
 
5123
  decl = built_in_decls[base + index + 1];
5124
  itype = TREE_TYPE (TREE_TYPE (decl));
5125
 
5126
  if (optab[TYPE_MODE (itype)] == CODE_FOR_nothing)
5127
    return GS_UNHANDLED;
5128
 
5129
  args = tree_cons (NULL, fold_convert (itype, rhs), NULL);
5130
  args = tree_cons (NULL, addr, args);
5131
  *expr_p = build_function_call_expr (decl, args);
5132
  return GS_OK;
5133
}
5134
 
5135
/* A subroutine of gimplify_omp_atomic_pipeline.  Walk *EXPR_P and replace
5136
   appearances of *LHS_ADDR with LHS_VAR.  If an expression does not involve
5137
   the lhs, evaluate it into a temporary.  Return 1 if the lhs appeared as
5138
   a subexpression, 0 if it did not, or -1 if an error was encountered.  */
5139
 
5140
static int
5141
goa_stabilize_expr (tree *expr_p, tree *pre_p, tree lhs_addr, tree lhs_var)
5142
{
5143
  tree expr = *expr_p;
5144
  int saw_lhs;
5145
 
5146
  if (goa_lhs_expr_p (expr, lhs_addr))
5147
    {
5148
      *expr_p = lhs_var;
5149
      return 1;
5150
    }
5151
  if (is_gimple_val (expr))
5152
    return 0;
5153
 
5154
  saw_lhs = 0;
5155
  switch (TREE_CODE_CLASS (TREE_CODE (expr)))
5156
    {
5157
    case tcc_binary:
5158
      saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
5159
                                     lhs_addr, lhs_var);
5160
    case tcc_unary:
5161
      saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
5162
                                     lhs_addr, lhs_var);
5163
      break;
5164
    default:
5165
      break;
5166
    }
5167
 
5168
  if (saw_lhs == 0)
5169
    {
5170
      enum gimplify_status gs;
5171
      gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
5172
      if (gs != GS_ALL_DONE)
5173
        saw_lhs = -1;
5174
    }
5175
 
5176
  return saw_lhs;
5177
}
5178
 
5179
/* A subroutine of gimplify_omp_atomic.  Implement the atomic operation as:
5180
 
5181
        oldval = *addr;
5182
      repeat:
5183
        newval = rhs;   // with oldval replacing *addr in rhs
5184
        oldval = __sync_val_compare_and_swap (addr, oldval, newval);
5185
        if (oldval != newval)
5186
          goto repeat;
5187
 
5188
   INDEX is log2 of the size of the data type, and thus usable to find the
5189
   index of the builtin decl.  */
5190
 
5191
static enum gimplify_status
5192
gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr,
5193
                              tree rhs, int index)
5194
{
5195
  tree oldval, oldival, oldival2, newval, newival, label;
5196
  tree type, itype, cmpxchg, args, x, iaddr;
5197
 
5198
  cmpxchg = built_in_decls[BUILT_IN_VAL_COMPARE_AND_SWAP_N + index + 1];
5199
  type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
5200
  itype = TREE_TYPE (TREE_TYPE (cmpxchg));
5201
 
5202
  if (sync_compare_and_swap[TYPE_MODE (itype)] == CODE_FOR_nothing)
5203
    return GS_UNHANDLED;
5204
 
5205
  oldval = create_tmp_var (type, NULL);
5206
  newval = create_tmp_var (type, NULL);
5207
 
5208
  /* Precompute as much of RHS as possible.  In the same walk, replace
5209
     occurrences of the lhs value with our temporary.  */
5210
  if (goa_stabilize_expr (&rhs, pre_p, addr, oldval) < 0)
5211
    return GS_ERROR;
5212
 
5213
  x = build_fold_indirect_ref (addr);
5214
  x = build2 (MODIFY_EXPR, void_type_node, oldval, x);
5215
  gimplify_and_add (x, pre_p);
5216
 
5217
  /* For floating-point values, we'll need to view-convert them to integers
5218
     so that we can perform the atomic compare and swap.  Simplify the
5219
     following code by always setting up the "i"ntegral variables.  */
5220
  if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
5221
    {
5222
      oldival = oldval;
5223
      newival = newval;
5224
      iaddr = addr;
5225
    }
5226
  else
5227
    {
5228
      oldival = create_tmp_var (itype, NULL);
5229
      newival = create_tmp_var (itype, NULL);
5230
 
5231
      x = build1 (VIEW_CONVERT_EXPR, itype, oldval);
5232
      x = build2 (MODIFY_EXPR, void_type_node, oldival, x);
5233
      gimplify_and_add (x, pre_p);
5234
      iaddr = fold_convert (build_pointer_type (itype), addr);
5235
    }
5236
 
5237
  oldival2 = create_tmp_var (itype, NULL);
5238
 
5239
  label = create_artificial_label ();
5240
  x = build1 (LABEL_EXPR, void_type_node, label);
5241
  gimplify_and_add (x, pre_p);
5242
 
5243
  x = build2 (MODIFY_EXPR, void_type_node, newval, rhs);
5244
  gimplify_and_add (x, pre_p);
5245
 
5246
  if (newval != newival)
5247
    {
5248
      x = build1 (VIEW_CONVERT_EXPR, itype, newval);
5249
      x = build2 (MODIFY_EXPR, void_type_node, newival, x);
5250
      gimplify_and_add (x, pre_p);
5251
    }
5252
 
5253
  x = build2 (MODIFY_EXPR, void_type_node, oldival2,
5254
              fold_convert (itype, oldival));
5255
  gimplify_and_add (x, pre_p);
5256
 
5257
  args = tree_cons (NULL, fold_convert (itype, newival), NULL);
5258
  args = tree_cons (NULL, fold_convert (itype, oldival), args);
5259
  args = tree_cons (NULL, iaddr, args);
5260
  x = build_function_call_expr (cmpxchg, args);
5261
  if (oldval == oldival)
5262
    x = fold_convert (type, x);
5263
  x = build2 (MODIFY_EXPR, void_type_node, oldival, x);
5264
  gimplify_and_add (x, pre_p);
5265
 
5266
  /* For floating point, be prepared for the loop backedge.  */
5267
  if (oldval != oldival)
5268
    {
5269
      x = build1 (VIEW_CONVERT_EXPR, type, oldival);
5270
      x = build2 (MODIFY_EXPR, void_type_node, oldval, x);
5271
      gimplify_and_add (x, pre_p);
5272
    }
5273
 
5274
  /* Note that we always perform the comparison as an integer, even for
5275
     floating point.  This allows the atomic operation to properly
5276
     succeed even with NaNs and -0.0.  */
5277
  x = build3 (COND_EXPR, void_type_node,
5278
              build2 (NE_EXPR, boolean_type_node, oldival, oldival2),
5279
              build1 (GOTO_EXPR, void_type_node, label), NULL);
5280
  gimplify_and_add (x, pre_p);
5281
 
5282
  *expr_p = NULL;
5283
  return GS_ALL_DONE;
5284
}
5285
 
5286
/* A subroutine of gimplify_omp_atomic.  Implement the atomic operation as:
5287
 
5288
        GOMP_atomic_start ();
5289
        *addr = rhs;
5290
        GOMP_atomic_end ();
5291
 
5292
   The result is not globally atomic, but works so long as all parallel
5293
   references are within #pragma omp atomic directives.  According to
5294
   responses received from omp@openmp.org, appears to be within spec.
5295
   Which makes sense, since that's how several other compilers handle
5296
   this situation as well.  */
5297
 
5298
static enum gimplify_status
5299
gimplify_omp_atomic_mutex (tree *expr_p, tree *pre_p, tree addr, tree rhs)
5300
{
5301
  tree t;
5302
 
5303
  t = built_in_decls[BUILT_IN_GOMP_ATOMIC_START];
5304
  t = build_function_call_expr (t, NULL);
5305
  gimplify_and_add (t, pre_p);
5306
 
5307
  t = build_fold_indirect_ref (addr);
5308
  t = build2 (MODIFY_EXPR, void_type_node, t, rhs);
5309
  gimplify_and_add (t, pre_p);
5310
 
5311
  t = built_in_decls[BUILT_IN_GOMP_ATOMIC_END];
5312
  t = build_function_call_expr (t, NULL);
5313
  gimplify_and_add (t, pre_p);
5314
 
5315
  *expr_p = NULL;
5316
  return GS_ALL_DONE;
5317
}
5318
 
5319
/* Gimplify an OMP_ATOMIC statement.  */
5320
 
5321
static enum gimplify_status
5322
gimplify_omp_atomic (tree *expr_p, tree *pre_p)
5323
{
5324
  tree addr = TREE_OPERAND (*expr_p, 0);
5325
  tree rhs = TREE_OPERAND (*expr_p, 1);
5326
  tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
5327
  HOST_WIDE_INT index;
5328
 
5329
  /* Make sure the type is one of the supported sizes.  */
5330
  index = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5331
  index = exact_log2 (index);
5332
  if (index >= 0 && index <= 4)
5333
    {
5334
      enum gimplify_status gs;
5335
      unsigned int align;
5336
 
5337
      if (DECL_P (TREE_OPERAND (addr, 0)))
5338
        align = DECL_ALIGN_UNIT (TREE_OPERAND (addr, 0));
5339
      else if (TREE_CODE (TREE_OPERAND (addr, 0)) == COMPONENT_REF
5340
               && TREE_CODE (TREE_OPERAND (TREE_OPERAND (addr, 0), 1))
5341
                  == FIELD_DECL)
5342
        align = DECL_ALIGN_UNIT (TREE_OPERAND (TREE_OPERAND (addr, 0), 1));
5343
      else
5344
        align = TYPE_ALIGN_UNIT (type);
5345
 
5346
      /* __sync builtins require strict data alignment.  */
5347
      if (exact_log2 (align) >= index)
5348
        {
5349
          /* When possible, use specialized atomic update functions.  */
5350
          if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
5351
            {
5352
              gs = gimplify_omp_atomic_fetch_op (expr_p, addr, rhs, index);
5353
              if (gs != GS_UNHANDLED)
5354
                return gs;
5355
            }
5356
 
5357
          /* If we don't have specialized __sync builtins, try and implement
5358
             as a compare and swap loop.  */
5359
          gs = gimplify_omp_atomic_pipeline (expr_p, pre_p, addr, rhs, index);
5360
          if (gs != GS_UNHANDLED)
5361
            return gs;
5362
        }
5363
    }
5364
 
5365
  /* The ultimate fallback is wrapping the operation in a mutex.  */
5366
  return gimplify_omp_atomic_mutex (expr_p, pre_p, addr, rhs);
5367
}
5368
 
5369
/*  Gimplifies the expression tree pointed to by EXPR_P.  Return 0 if
5370
    gimplification failed.
5371
 
5372
    PRE_P points to the list where side effects that must happen before
5373
        EXPR should be stored.
5374
 
5375
    POST_P points to the list where side effects that must happen after
5376
        EXPR should be stored, or NULL if there is no suitable list.  In
5377
        that case, we copy the result to a temporary, emit the
5378
        post-effects, and then return the temporary.
5379
 
5380
    GIMPLE_TEST_F points to a function that takes a tree T and
5381
        returns nonzero if T is in the GIMPLE form requested by the
5382
        caller.  The GIMPLE predicates are in tree-gimple.c.
5383
 
5384
        This test is used twice.  Before gimplification, the test is
5385
        invoked to determine whether *EXPR_P is already gimple enough.  If
5386
        that fails, *EXPR_P is gimplified according to its code and
5387
        GIMPLE_TEST_F is called again.  If the test still fails, then a new
5388
        temporary variable is created and assigned the value of the
5389
        gimplified expression.
5390
 
5391
    FALLBACK tells the function what sort of a temporary we want.  If the 1
5392
        bit is set, an rvalue is OK.  If the 2 bit is set, an lvalue is OK.
5393
        If both are set, either is OK, but an lvalue is preferable.
5394
 
5395
    The return value is either GS_ERROR or GS_ALL_DONE, since this function
5396
    iterates until solution.  */
5397
 
5398
enum gimplify_status
5399
gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
5400
               bool (* gimple_test_f) (tree), fallback_t fallback)
5401
{
5402
  tree tmp;
5403
  tree internal_pre = NULL_TREE;
5404
  tree internal_post = NULL_TREE;
5405
  tree save_expr;
5406
  int is_statement = (pre_p == NULL);
5407
  location_t saved_location;
5408
  enum gimplify_status ret;
5409
 
5410
  save_expr = *expr_p;
5411
  if (save_expr == NULL_TREE)
5412
    return GS_ALL_DONE;
5413
 
5414
  /* We used to check the predicate here and return immediately if it
5415
     succeeds.  This is wrong; the design is for gimplification to be
5416
     idempotent, and for the predicates to only test for valid forms, not
5417
     whether they are fully simplified.  */
5418
 
5419
  /* Set up our internal queues if needed.  */
5420
  if (pre_p == NULL)
5421
    pre_p = &internal_pre;
5422
  if (post_p == NULL)
5423
    post_p = &internal_post;
5424
 
5425
  saved_location = input_location;
5426
  if (save_expr != error_mark_node
5427
      && EXPR_HAS_LOCATION (*expr_p))
5428
    input_location = EXPR_LOCATION (*expr_p);
5429
 
5430
  /* Loop over the specific gimplifiers until the toplevel node
5431
     remains the same.  */
5432
  do
5433
    {
5434
      /* Strip away as many useless type conversions as possible
5435
         at the toplevel.  */
5436
      STRIP_USELESS_TYPE_CONVERSION (*expr_p);
5437
 
5438
      /* Remember the expr.  */
5439
      save_expr = *expr_p;
5440
 
5441
      /* Die, die, die, my darling.  */
5442
      if (save_expr == error_mark_node
5443
          || (TREE_TYPE (save_expr)
5444
              && TREE_TYPE (save_expr) == error_mark_node))
5445
        {
5446
          ret = GS_ERROR;
5447
          break;
5448
        }
5449
 
5450
      /* Do any language-specific gimplification.  */
5451
      ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p);
5452
      if (ret == GS_OK)
5453
        {
5454
          if (*expr_p == NULL_TREE)
5455
            break;
5456
          if (*expr_p != save_expr)
5457
            continue;
5458
        }
5459
      else if (ret != GS_UNHANDLED)
5460
        break;
5461
 
5462
      ret = GS_OK;
5463
      switch (TREE_CODE (*expr_p))
5464
        {
5465
          /* First deal with the special cases.  */
5466
 
5467
        case POSTINCREMENT_EXPR:
5468
        case POSTDECREMENT_EXPR:
5469
        case PREINCREMENT_EXPR:
5470
        case PREDECREMENT_EXPR:
5471
          ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
5472
                                        fallback != fb_none);
5473
          break;
5474
 
5475
        case ARRAY_REF:
5476
        case ARRAY_RANGE_REF:
5477
        case REALPART_EXPR:
5478
        case IMAGPART_EXPR:
5479
        case COMPONENT_REF:
5480
        case VIEW_CONVERT_EXPR:
5481
          ret = gimplify_compound_lval (expr_p, pre_p, post_p,
5482
                                        fallback ? fallback : fb_rvalue);
5483
          break;
5484
 
5485
        case COND_EXPR:
5486
          ret = gimplify_cond_expr (expr_p, pre_p, fallback);
5487
          /* C99 code may assign to an array in a structure value of a
5488
             conditional expression, and this has undefined behavior
5489
             only on execution, so create a temporary if an lvalue is
5490
             required.  */
5491
          if (fallback == fb_lvalue)
5492
            {
5493
              *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5494
              lang_hooks.mark_addressable (*expr_p);
5495
            }
5496
          break;
5497
 
5498
        case CALL_EXPR:
5499
          ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
5500
          /* C99 code may assign to an array in a structure returned
5501
             from a function, and this has undefined behavior only on
5502
             execution, so create a temporary if an lvalue is
5503
             required.  */
5504
          if (fallback == fb_lvalue)
5505
            {
5506
              *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5507
              lang_hooks.mark_addressable (*expr_p);
5508
            }
5509
          break;
5510
 
5511
        case TREE_LIST:
5512
          gcc_unreachable ();
5513
 
5514
        case COMPOUND_EXPR:
5515
          ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
5516
          break;
5517
 
5518
        case MODIFY_EXPR:
5519
        case INIT_EXPR:
5520
          ret = gimplify_modify_expr (expr_p, pre_p, post_p,
5521
                                      fallback != fb_none);
5522
 
5523
          /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer
5524
             useful.  */
5525
          if (*expr_p && TREE_CODE (*expr_p) == INIT_EXPR)
5526
            TREE_SET_CODE (*expr_p, MODIFY_EXPR);
5527
          break;
5528
 
5529
        case TRUTH_ANDIF_EXPR:
5530
        case TRUTH_ORIF_EXPR:
5531
          ret = gimplify_boolean_expr (expr_p);
5532
          break;
5533
 
5534
        case TRUTH_NOT_EXPR:
5535
          TREE_OPERAND (*expr_p, 0)
5536
            = gimple_boolify (TREE_OPERAND (*expr_p, 0));
5537
          ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5538
                               is_gimple_val, fb_rvalue);
5539
          recalculate_side_effects (*expr_p);
5540
          break;
5541
 
5542
        case ADDR_EXPR:
5543
          ret = gimplify_addr_expr (expr_p, pre_p, post_p);
5544
          break;
5545
 
5546
        case VA_ARG_EXPR:
5547
          ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
5548
          break;
5549
 
5550
        case CONVERT_EXPR:
5551
        case NOP_EXPR:
5552
          if (IS_EMPTY_STMT (*expr_p))
5553
            {
5554
              ret = GS_ALL_DONE;
5555
              break;
5556
            }
5557
 
5558
          if (VOID_TYPE_P (TREE_TYPE (*expr_p))
5559
              || fallback == fb_none)
5560
            {
5561
              /* Just strip a conversion to void (or in void context) and
5562
                 try again.  */
5563
              *expr_p = TREE_OPERAND (*expr_p, 0);
5564
              break;
5565
            }
5566
 
5567
          ret = gimplify_conversion (expr_p);
5568
          if (ret == GS_ERROR)
5569
            break;
5570
          if (*expr_p != save_expr)
5571
            break;
5572
          /* FALLTHRU */
5573
 
5574
        case FIX_TRUNC_EXPR:
5575
        case FIX_CEIL_EXPR:
5576
        case FIX_FLOOR_EXPR:
5577
        case FIX_ROUND_EXPR:
5578
          /* unary_expr: ... | '(' cast ')' val | ...  */
5579
          ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5580
                               is_gimple_val, fb_rvalue);
5581
          recalculate_side_effects (*expr_p);
5582
          break;
5583
 
5584
        case INDIRECT_REF:
5585
          *expr_p = fold_indirect_ref (*expr_p);
5586
          if (*expr_p != save_expr)
5587
            break;
5588
          /* else fall through.  */
5589
        case ALIGN_INDIRECT_REF:
5590
        case MISALIGNED_INDIRECT_REF:
5591
          ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5592
                               is_gimple_reg, fb_rvalue);
5593
          recalculate_side_effects (*expr_p);
5594
          break;
5595
 
5596
          /* Constants need not be gimplified.  */
5597
        case INTEGER_CST:
5598
        case REAL_CST:
5599
        case STRING_CST:
5600
        case COMPLEX_CST:
5601
        case VECTOR_CST:
5602
          ret = GS_ALL_DONE;
5603
          break;
5604
 
5605
        case CONST_DECL:
5606
          /* If we require an lvalue, such as for ADDR_EXPR, retain the
5607
             CONST_DECL node.  Otherwise the decl is replaceable by its
5608
             value.  */
5609
          /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.  */
5610
          if (fallback & fb_lvalue)
5611
            ret = GS_ALL_DONE;
5612
          else
5613
            *expr_p = DECL_INITIAL (*expr_p);
5614
          break;
5615
 
5616
        case DECL_EXPR:
5617
          ret = gimplify_decl_expr (expr_p);
5618
          break;
5619
 
5620
        case EXC_PTR_EXPR:
5621
          /* FIXME make this a decl.  */
5622
          ret = GS_ALL_DONE;
5623
          break;
5624
 
5625
        case BIND_EXPR:
5626
          ret = gimplify_bind_expr (expr_p, pre_p);
5627
          break;
5628
 
5629
        case LOOP_EXPR:
5630
          ret = gimplify_loop_expr (expr_p, pre_p);
5631
          break;
5632
 
5633
        case SWITCH_EXPR:
5634
          ret = gimplify_switch_expr (expr_p, pre_p);
5635
          break;
5636
 
5637
        case EXIT_EXPR:
5638
          ret = gimplify_exit_expr (expr_p);
5639
          break;
5640
 
5641
        case GOTO_EXPR:
5642
          /* If the target is not LABEL, then it is a computed jump
5643
             and the target needs to be gimplified.  */
5644
          if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
5645
            ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
5646
                                 NULL, is_gimple_val, fb_rvalue);
5647
          break;
5648
 
5649
        case LABEL_EXPR:
5650
          ret = GS_ALL_DONE;
5651
          gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
5652
                      == current_function_decl);
5653
          break;
5654
 
5655
        case CASE_LABEL_EXPR:
5656
          ret = gimplify_case_label_expr (expr_p);
5657
          break;
5658
 
5659
        case RETURN_EXPR:
5660
          ret = gimplify_return_expr (*expr_p, pre_p);
5661
          break;
5662
 
5663
        case CONSTRUCTOR:
5664
          /* Don't reduce this in place; let gimplify_init_constructor work its
5665
             magic.  Buf if we're just elaborating this for side effects, just
5666
             gimplify any element that has side-effects.  */
5667
          if (fallback == fb_none)
5668
            {
5669
              unsigned HOST_WIDE_INT ix;
5670
              constructor_elt *ce;
5671
              tree temp = NULL_TREE;
5672
              for (ix = 0;
5673
                   VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
5674
                                ix, ce);
5675
                   ix++)
5676
                if (TREE_SIDE_EFFECTS (ce->value))
5677
                  append_to_statement_list (ce->value, &temp);
5678
 
5679
              *expr_p = temp;
5680
              ret = GS_OK;
5681
            }
5682
          /* C99 code may assign to an array in a constructed
5683
             structure or union, and this has undefined behavior only
5684
             on execution, so create a temporary if an lvalue is
5685
             required.  */
5686
          else if (fallback == fb_lvalue)
5687
            {
5688
              *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5689
              lang_hooks.mark_addressable (*expr_p);
5690
            }
5691
          else
5692
            ret = GS_ALL_DONE;
5693
          break;
5694
 
5695
          /* The following are special cases that are not handled by the
5696
             original GIMPLE grammar.  */
5697
 
5698
          /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
5699
             eliminated.  */
5700
        case SAVE_EXPR:
5701
          ret = gimplify_save_expr (expr_p, pre_p, post_p);
5702
          break;
5703
 
5704
        case BIT_FIELD_REF:
5705
          {
5706
            enum gimplify_status r0, r1, r2;
5707
 
5708
            r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5709
                                is_gimple_lvalue, fb_either);
5710
            r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5711
                                is_gimple_val, fb_rvalue);
5712
            r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p,
5713
                                is_gimple_val, fb_rvalue);
5714
            recalculate_side_effects (*expr_p);
5715
 
5716
            ret = MIN (r0, MIN (r1, r2));
5717
          }
5718
          break;
5719
 
5720
        case NON_LVALUE_EXPR:
5721
          /* This should have been stripped above.  */
5722
          gcc_unreachable ();
5723
 
5724
        case ASM_EXPR:
5725
          ret = gimplify_asm_expr (expr_p, pre_p, post_p);
5726
          break;
5727
 
5728
        case TRY_FINALLY_EXPR:
5729
        case TRY_CATCH_EXPR:
5730
          gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0));
5731
          gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1));
5732
          ret = GS_ALL_DONE;
5733
          break;
5734
 
5735
        case CLEANUP_POINT_EXPR:
5736
          ret = gimplify_cleanup_point_expr (expr_p, pre_p);
5737
          break;
5738
 
5739
        case TARGET_EXPR:
5740
          ret = gimplify_target_expr (expr_p, pre_p, post_p);
5741
          break;
5742
 
5743
        case CATCH_EXPR:
5744
          gimplify_to_stmt_list (&CATCH_BODY (*expr_p));
5745
          ret = GS_ALL_DONE;
5746
          break;
5747
 
5748
        case EH_FILTER_EXPR:
5749
          gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p));
5750
          ret = GS_ALL_DONE;
5751
          break;
5752
 
5753
        case OBJ_TYPE_REF:
5754
          {
5755
            enum gimplify_status r0, r1;
5756
            r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p,
5757
                                is_gimple_val, fb_rvalue);
5758
            r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
5759
                                is_gimple_val, fb_rvalue);
5760
            ret = MIN (r0, r1);
5761
          }
5762
          break;
5763
 
5764
        case LABEL_DECL:
5765
          /* We get here when taking the address of a label.  We mark
5766
             the label as "forced"; meaning it can never be removed and
5767
             it is a potential target for any computed goto.  */
5768
          FORCED_LABEL (*expr_p) = 1;
5769
          ret = GS_ALL_DONE;
5770
          break;
5771
 
5772
        case STATEMENT_LIST:
5773
          ret = gimplify_statement_list (expr_p, pre_p);
5774
          break;
5775
 
5776
        case WITH_SIZE_EXPR:
5777
          {
5778
            gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5779
                           post_p == &internal_post ? NULL : post_p,
5780
                           gimple_test_f, fallback);
5781
            gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5782
                           is_gimple_val, fb_rvalue);
5783
          }
5784
          break;
5785
 
5786
        case VAR_DECL:
5787
        case PARM_DECL:
5788
          ret = gimplify_var_or_parm_decl (expr_p);
5789
          break;
5790
 
5791
        case RESULT_DECL:
5792
          /* When within an OpenMP context, notice uses of variables.  */
5793
          if (gimplify_omp_ctxp)
5794
            omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
5795
          ret = GS_ALL_DONE;
5796
          break;
5797
 
5798
        case SSA_NAME:
5799
          /* Allow callbacks into the gimplifier during optimization.  */
5800
          ret = GS_ALL_DONE;
5801
          break;
5802
 
5803
        case OMP_PARALLEL:
5804
          ret = gimplify_omp_parallel (expr_p, pre_p);
5805
          break;
5806
 
5807
        case OMP_FOR:
5808
          ret = gimplify_omp_for (expr_p, pre_p);
5809
          break;
5810
 
5811
        case OMP_SECTIONS:
5812
        case OMP_SINGLE:
5813
          ret = gimplify_omp_workshare (expr_p, pre_p);
5814
          break;
5815
 
5816
        case OMP_SECTION:
5817
        case OMP_MASTER:
5818
        case OMP_ORDERED:
5819
        case OMP_CRITICAL:
5820
          gimplify_to_stmt_list (&OMP_BODY (*expr_p));
5821
          break;
5822
 
5823
        case OMP_ATOMIC:
5824
          ret = gimplify_omp_atomic (expr_p, pre_p);
5825
          break;
5826
 
5827
        case OMP_RETURN:
5828
        case OMP_CONTINUE:
5829
          ret = GS_ALL_DONE;
5830
          break;
5831
 
5832
        default:
5833
          switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
5834
            {
5835
            case tcc_comparison:
5836
              /* Handle comparison of objects of non scalar mode aggregates
5837
                 with a call to memcmp.  It would be nice to only have to do
5838
                 this for variable-sized objects, but then we'd have to allow
5839
                 the same nest of reference nodes we allow for MODIFY_EXPR and
5840
                 that's too complex.
5841
 
5842
                 Compare scalar mode aggregates as scalar mode values.  Using
5843
                 memcmp for them would be very inefficient at best, and is
5844
                 plain wrong if bitfields are involved.  */
5845
 
5846
              {
5847
                tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
5848
 
5849
                if (!AGGREGATE_TYPE_P (type))
5850
                  goto expr_2;
5851
                else if (TYPE_MODE (type) != BLKmode)
5852
                  ret = gimplify_scalar_mode_aggregate_compare (expr_p);
5853
                else
5854
                  ret = gimplify_variable_sized_compare (expr_p);
5855
 
5856
                break;
5857
                }
5858
 
5859
            /* If *EXPR_P does not need to be special-cased, handle it
5860
               according to its class.  */
5861
            case tcc_unary:
5862
              ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5863
                                   post_p, is_gimple_val, fb_rvalue);
5864
              break;
5865
 
5866
            case tcc_binary:
5867
            expr_2:
5868
              {
5869
                enum gimplify_status r0, r1;
5870
 
5871
                r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5872
                                    post_p, is_gimple_val, fb_rvalue);
5873
                r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
5874
                                    post_p, is_gimple_val, fb_rvalue);
5875
 
5876
                ret = MIN (r0, r1);
5877
                break;
5878
              }
5879
 
5880
            case tcc_declaration:
5881
            case tcc_constant:
5882
              ret = GS_ALL_DONE;
5883
              goto dont_recalculate;
5884
 
5885
            default:
5886
              gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
5887
                          || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
5888
                          || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
5889
              goto expr_2;
5890
            }
5891
 
5892
          recalculate_side_effects (*expr_p);
5893
        dont_recalculate:
5894
          break;
5895
        }
5896
 
5897
      /* If we replaced *expr_p, gimplify again.  */
5898
      if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
5899
        ret = GS_ALL_DONE;
5900
    }
5901
  while (ret == GS_OK);
5902
 
5903
  /* If we encountered an error_mark somewhere nested inside, either
5904
     stub out the statement or propagate the error back out.  */
5905
  if (ret == GS_ERROR)
5906
    {
5907
      if (is_statement)
5908
        *expr_p = NULL;
5909
      goto out;
5910
    }
5911
 
5912
  /* This was only valid as a return value from the langhook, which
5913
     we handled.  Make sure it doesn't escape from any other context.  */
5914
  gcc_assert (ret != GS_UNHANDLED);
5915
 
5916
  if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
5917
    {
5918
      /* We aren't looking for a value, and we don't have a valid
5919
         statement.  If it doesn't have side-effects, throw it away.  */
5920
      if (!TREE_SIDE_EFFECTS (*expr_p))
5921
        *expr_p = NULL;
5922
      else if (!TREE_THIS_VOLATILE (*expr_p))
5923
        {
5924
          /* This is probably a _REF that contains something nested that
5925
             has side effects.  Recurse through the operands to find it.  */
5926
          enum tree_code code = TREE_CODE (*expr_p);
5927
 
5928
          switch (code)
5929
            {
5930
            case COMPONENT_REF:
5931
            case REALPART_EXPR:
5932
            case IMAGPART_EXPR:
5933
            case VIEW_CONVERT_EXPR:
5934
              gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5935
                             gimple_test_f, fallback);
5936
              break;
5937
 
5938
            case ARRAY_REF:
5939
            case ARRAY_RANGE_REF:
5940
              gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5941
                             gimple_test_f, fallback);
5942
              gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5943
                             gimple_test_f, fallback);
5944
              break;
5945
 
5946
            default:
5947
               /* Anything else with side-effects must be converted to
5948
                  a valid statement before we get here.  */
5949
              gcc_unreachable ();
5950
            }
5951
 
5952
          *expr_p = NULL;
5953
        }
5954
      else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
5955
               && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
5956
        {
5957
          /* Historically, the compiler has treated a bare reference
5958
             to a non-BLKmode volatile lvalue as forcing a load.  */
5959
          tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
5960
          /* Normally, we do not want to create a temporary for a
5961
             TREE_ADDRESSABLE type because such a type should not be
5962
             copied by bitwise-assignment.  However, we make an
5963
             exception here, as all we are doing here is ensuring that
5964
             we read the bytes that make up the type.  We use
5965
             create_tmp_var_raw because create_tmp_var will abort when
5966
             given a TREE_ADDRESSABLE type.  */
5967
          tree tmp = create_tmp_var_raw (type, "vol");
5968
          gimple_add_tmp_var (tmp);
5969
          *expr_p = build2 (MODIFY_EXPR, type, tmp, *expr_p);
5970
        }
5971
      else
5972
        /* We can't do anything useful with a volatile reference to
5973
           an incomplete type, so just throw it away.  Likewise for
5974
           a BLKmode type, since any implicit inner load should
5975
           already have been turned into an explicit one by the
5976
           gimplification process.  */
5977
        *expr_p = NULL;
5978
    }
5979
 
5980
  /* If we are gimplifying at the statement level, we're done.  Tack
5981
     everything together and replace the original statement with the
5982
     gimplified form.  */
5983
  if (fallback == fb_none || is_statement)
5984
    {
5985
      if (internal_pre || internal_post)
5986
        {
5987
          append_to_statement_list (*expr_p, &internal_pre);
5988
          append_to_statement_list (internal_post, &internal_pre);
5989
          annotate_all_with_locus (&internal_pre, input_location);
5990
          *expr_p = internal_pre;
5991
        }
5992
      else if (!*expr_p)
5993
        ;
5994
      else if (TREE_CODE (*expr_p) == STATEMENT_LIST)
5995
        annotate_all_with_locus (expr_p, input_location);
5996
      else
5997
        annotate_one_with_locus (*expr_p, input_location);
5998
      goto out;
5999
    }
6000
 
6001
  /* Otherwise we're gimplifying a subexpression, so the resulting value is
6002
     interesting.  */
6003
 
6004
  /* If it's sufficiently simple already, we're done.  Unless we are
6005
     handling some post-effects internally; if that's the case, we need to
6006
     copy into a temp before adding the post-effects to the tree.  */
6007
  if (!internal_post && (*gimple_test_f) (*expr_p))
6008
    goto out;
6009
 
6010
  /* Otherwise, we need to create a new temporary for the gimplified
6011
     expression.  */
6012
 
6013
  /* We can't return an lvalue if we have an internal postqueue.  The
6014
     object the lvalue refers to would (probably) be modified by the
6015
     postqueue; we need to copy the value out first, which means an
6016
     rvalue.  */
6017
  if ((fallback & fb_lvalue) && !internal_post
6018
      && is_gimple_addressable (*expr_p))
6019
    {
6020
      /* An lvalue will do.  Take the address of the expression, store it
6021
         in a temporary, and replace the expression with an INDIRECT_REF of
6022
         that temporary.  */
6023
      tmp = build_fold_addr_expr (*expr_p);
6024
      gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
6025
      *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
6026
    }
6027
  else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_rhs (*expr_p))
6028
    {
6029
      gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
6030
 
6031
      /* An rvalue will do.  Assign the gimplified expression into a new
6032
         temporary TMP and replace the original expression with TMP.  */
6033
 
6034
      if (internal_post || (fallback & fb_lvalue))
6035
        /* The postqueue might change the value of the expression between
6036
           the initialization and use of the temporary, so we can't use a
6037
           formal temp.  FIXME do we care?  */
6038
        *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6039
      else
6040
        *expr_p = get_formal_tmp_var (*expr_p, pre_p);
6041
 
6042
      if (TREE_CODE (*expr_p) != SSA_NAME)
6043
        DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1;
6044
    }
6045
  else
6046
    {
6047
#ifdef ENABLE_CHECKING
6048
      if (!(fallback & fb_mayfail))
6049
        {
6050
          fprintf (stderr, "gimplification failed:\n");
6051
          print_generic_expr (stderr, *expr_p, 0);
6052
          debug_tree (*expr_p);
6053
          internal_error ("gimplification failed");
6054
        }
6055
#endif
6056
      gcc_assert (fallback & fb_mayfail);
6057
      /* If this is an asm statement, and the user asked for the
6058
         impossible, don't die.  Fail and let gimplify_asm_expr
6059
         issue an error.  */
6060
      ret = GS_ERROR;
6061
      goto out;
6062
    }
6063
 
6064
  /* Make sure the temporary matches our predicate.  */
6065
  gcc_assert ((*gimple_test_f) (*expr_p));
6066
 
6067
  if (internal_post)
6068
    {
6069
      annotate_all_with_locus (&internal_post, input_location);
6070
      append_to_statement_list (internal_post, pre_p);
6071
    }
6072
 
6073
 out:
6074
  input_location = saved_location;
6075
  return ret;
6076
}
6077
 
6078
/* Look through TYPE for variable-sized objects and gimplify each such
6079
   size that we find.  Add to LIST_P any statements generated.  */
6080
 
6081
void
6082
gimplify_type_sizes (tree type, tree *list_p)
6083
{
6084
  tree field, t;
6085
 
6086
  if (type == NULL || type == error_mark_node)
6087
    return;
6088
 
6089
  /* We first do the main variant, then copy into any other variants.  */
6090
  type = TYPE_MAIN_VARIANT (type);
6091
 
6092
  /* Avoid infinite recursion.  */
6093
  if (TYPE_SIZES_GIMPLIFIED (type))
6094
    return;
6095
 
6096
  TYPE_SIZES_GIMPLIFIED (type) = 1;
6097
 
6098
  switch (TREE_CODE (type))
6099
    {
6100
    case INTEGER_TYPE:
6101
    case ENUMERAL_TYPE:
6102
    case BOOLEAN_TYPE:
6103
    case REAL_TYPE:
6104
      gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
6105
      gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
6106
 
6107
      for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6108
        {
6109
          TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
6110
          TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
6111
        }
6112
      break;
6113
 
6114
    case ARRAY_TYPE:
6115
      /* These types may not have declarations, so handle them here.  */
6116
      gimplify_type_sizes (TREE_TYPE (type), list_p);
6117
      gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
6118
      break;
6119
 
6120
    case RECORD_TYPE:
6121
    case UNION_TYPE:
6122
    case QUAL_UNION_TYPE:
6123
      for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6124
        if (TREE_CODE (field) == FIELD_DECL)
6125
          {
6126
            gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
6127
            gimplify_type_sizes (TREE_TYPE (field), list_p);
6128
          }
6129
      break;
6130
 
6131
    case POINTER_TYPE:
6132
    case REFERENCE_TYPE:
6133
        /* We used to recurse on the pointed-to type here, which turned out to
6134
           be incorrect because its definition might refer to variables not
6135
           yet initialized at this point if a forward declaration is involved.
6136
 
6137
           It was actually useful for anonymous pointed-to types to ensure
6138
           that the sizes evaluation dominates every possible later use of the
6139
           values.  Restricting to such types here would be safe since there
6140
           is no possible forward declaration around, but would introduce an
6141
           undesirable middle-end semantic to anonymity.  We then defer to
6142
           front-ends the responsibility of ensuring that the sizes are
6143
           evaluated both early and late enough, e.g. by attaching artificial
6144
           type declarations to the tree.  */
6145
      break;
6146
 
6147
    default:
6148
      break;
6149
    }
6150
 
6151
  gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
6152
  gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
6153
 
6154
  for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6155
    {
6156
      TYPE_SIZE (t) = TYPE_SIZE (type);
6157
      TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
6158
      TYPE_SIZES_GIMPLIFIED (t) = 1;
6159
    }
6160
}
6161
 
6162
/* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
6163
   a size or position, has had all of its SAVE_EXPRs evaluated.
6164
   We add any required statements to STMT_P.  */
6165
 
6166
void
6167
gimplify_one_sizepos (tree *expr_p, tree *stmt_p)
6168
{
6169
  tree type, expr = *expr_p;
6170
 
6171
  /* We don't do anything if the value isn't there, is constant, or contains
6172
     A PLACEHOLDER_EXPR.  We also don't want to do anything if it's already
6173
     a VAR_DECL.  If it's a VAR_DECL from another function, the gimplifier
6174
     will want to replace it with a new variable, but that will cause problems
6175
     if this type is from outside the function.  It's OK to have that here.  */
6176
  if (expr == NULL_TREE || TREE_CONSTANT (expr)
6177
      || TREE_CODE (expr) == VAR_DECL
6178
      || CONTAINS_PLACEHOLDER_P (expr))
6179
    return;
6180
 
6181
  type = TREE_TYPE (expr);
6182
  *expr_p = unshare_expr (expr);
6183
 
6184
  gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
6185
  expr = *expr_p;
6186
 
6187
  /* Verify that we've an exact type match with the original expression.
6188
     In particular, we do not wish to drop a "sizetype" in favour of a
6189
     type of similar dimensions.  We don't want to pollute the generic
6190
     type-stripping code with this knowledge because it doesn't matter
6191
     for the bulk of GENERIC/GIMPLE.  It only matters that TYPE_SIZE_UNIT
6192
     and friends retain their "sizetype-ness".  */
6193
  if (TREE_TYPE (expr) != type
6194
      && TREE_CODE (type) == INTEGER_TYPE
6195
      && TYPE_IS_SIZETYPE (type))
6196
    {
6197
      tree tmp;
6198
 
6199
      *expr_p = create_tmp_var (type, NULL);
6200
      tmp = build1 (NOP_EXPR, type, expr);
6201
      tmp = build2 (MODIFY_EXPR, type, *expr_p, tmp);
6202
      if (EXPR_HAS_LOCATION (expr))
6203
        SET_EXPR_LOCUS (tmp, EXPR_LOCUS (expr));
6204
      else
6205
        SET_EXPR_LOCATION (tmp, input_location);
6206
 
6207
      gimplify_and_add (tmp, stmt_p);
6208
    }
6209
}
6210
 
6211
#ifdef ENABLE_CHECKING
6212
/* Compare types A and B for a "close enough" match.  */
6213
 
6214
static bool
6215
cpt_same_type (tree a, tree b)
6216
{
6217
  if (lang_hooks.types_compatible_p (a, b))
6218
    return true;
6219
 
6220
  /* ??? The C++ FE decomposes METHOD_TYPES to FUNCTION_TYPES and doesn't
6221
     link them together.  This routine is intended to catch type errors
6222
     that will affect the optimizers, and the optimizers don't add new
6223
     dereferences of function pointers, so ignore it.  */
6224
  if ((TREE_CODE (a) == FUNCTION_TYPE || TREE_CODE (a) == METHOD_TYPE)
6225
      && (TREE_CODE (b) == FUNCTION_TYPE || TREE_CODE (b) == METHOD_TYPE))
6226
    return true;
6227
 
6228
  /* ??? The C FE pushes type qualifiers after the fact into the type of
6229
     the element from the type of the array.  See build_unary_op's handling
6230
     of ADDR_EXPR.  This seems wrong -- if we were going to do this, we
6231
     should have done it when creating the variable in the first place.
6232
     Alternately, why aren't the two array types made variants?  */
6233
  if (TREE_CODE (a) == ARRAY_TYPE && TREE_CODE (b) == ARRAY_TYPE)
6234
    return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
6235
 
6236
  /* And because of those, we have to recurse down through pointers.  */
6237
  if (POINTER_TYPE_P (a) && POINTER_TYPE_P (b))
6238
    return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
6239
 
6240
  return false;
6241
}
6242
 
6243
/* Check for some cases of the front end missing cast expressions.
6244
   The type of a dereference should correspond to the pointer type;
6245
   similarly the type of an address should match its object.  */
6246
 
6247
static tree
6248
check_pointer_types_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
6249
                       void *data ATTRIBUTE_UNUSED)
6250
{
6251
  tree t = *tp;
6252
  tree ptype, otype, dtype;
6253
 
6254
  switch (TREE_CODE (t))
6255
    {
6256
    case INDIRECT_REF:
6257
    case ARRAY_REF:
6258
      otype = TREE_TYPE (t);
6259
      ptype = TREE_TYPE (TREE_OPERAND (t, 0));
6260
      dtype = TREE_TYPE (ptype);
6261
      gcc_assert (cpt_same_type (otype, dtype));
6262
      break;
6263
 
6264
    case ADDR_EXPR:
6265
      ptype = TREE_TYPE (t);
6266
      otype = TREE_TYPE (TREE_OPERAND (t, 0));
6267
      dtype = TREE_TYPE (ptype);
6268
      if (!cpt_same_type (otype, dtype))
6269
        {
6270
          /* &array is allowed to produce a pointer to the element, rather than
6271
             a pointer to the array type.  We must allow this in order to
6272
             properly represent assigning the address of an array in C into
6273
             pointer to the element type.  */
6274
          gcc_assert (TREE_CODE (otype) == ARRAY_TYPE
6275
                      && POINTER_TYPE_P (ptype)
6276
                      && cpt_same_type (TREE_TYPE (otype), dtype));
6277
          break;
6278
        }
6279
      break;
6280
 
6281
    default:
6282
      return NULL_TREE;
6283
    }
6284
 
6285
 
6286
  return NULL_TREE;
6287
}
6288
#endif
6289
 
6290
/* Gimplify the body of statements pointed to by BODY_P.  FNDECL is the
6291
   function decl containing BODY.  */
6292
 
6293
void
6294
gimplify_body (tree *body_p, tree fndecl, bool do_parms)
6295
{
6296
  location_t saved_location = input_location;
6297
  tree body, parm_stmts;
6298
 
6299
  timevar_push (TV_TREE_GIMPLIFY);
6300
 
6301
  gcc_assert (gimplify_ctxp == NULL);
6302
  push_gimplify_context ();
6303
 
6304
  /* Unshare most shared trees in the body and in that of any nested functions.
6305
     It would seem we don't have to do this for nested functions because
6306
     they are supposed to be output and then the outer function gimplified
6307
     first, but the g++ front end doesn't always do it that way.  */
6308
  unshare_body (body_p, fndecl);
6309
  unvisit_body (body_p, fndecl);
6310
 
6311
  /* Make sure input_location isn't set to something wierd.  */
6312
  input_location = DECL_SOURCE_LOCATION (fndecl);
6313
 
6314
  /* Resolve callee-copies.  This has to be done before processing
6315
     the body so that DECL_VALUE_EXPR gets processed correctly.  */
6316
  parm_stmts = do_parms ? gimplify_parameters () : NULL;
6317
 
6318
  /* Gimplify the function's body.  */
6319
  gimplify_stmt (body_p);
6320
  body = *body_p;
6321
 
6322
  if (!body)
6323
    body = alloc_stmt_list ();
6324
  else if (TREE_CODE (body) == STATEMENT_LIST)
6325
    {
6326
      tree t = expr_only (*body_p);
6327
      if (t)
6328
        body = t;
6329
    }
6330
 
6331
  /* If there isn't an outer BIND_EXPR, add one.  */
6332
  if (TREE_CODE (body) != BIND_EXPR)
6333
    {
6334
      tree b = build3 (BIND_EXPR, void_type_node, NULL_TREE,
6335
                       NULL_TREE, NULL_TREE);
6336
      TREE_SIDE_EFFECTS (b) = 1;
6337
      append_to_statement_list_force (body, &BIND_EXPR_BODY (b));
6338
      body = b;
6339
    }
6340
 
6341
  /* If we had callee-copies statements, insert them at the beginning
6342
     of the function.  */
6343
  if (parm_stmts)
6344
    {
6345
      append_to_statement_list_force (BIND_EXPR_BODY (body), &parm_stmts);
6346
      BIND_EXPR_BODY (body) = parm_stmts;
6347
    }
6348
 
6349
  /* Unshare again, in case gimplification was sloppy.  */
6350
  unshare_all_trees (body);
6351
 
6352
  *body_p = body;
6353
 
6354
  pop_gimplify_context (body);
6355
  gcc_assert (gimplify_ctxp == NULL);
6356
 
6357
#ifdef ENABLE_CHECKING
6358
  walk_tree (body_p, check_pointer_types_r, NULL, NULL);
6359
#endif
6360
 
6361
  timevar_pop (TV_TREE_GIMPLIFY);
6362
  input_location = saved_location;
6363
}
6364
 
6365
/* Entry point to the gimplification pass.  FNDECL is the FUNCTION_DECL
6366
   node for the function we want to gimplify.  */
6367
 
6368
void
6369
gimplify_function_tree (tree fndecl)
6370
{
6371
  tree oldfn, parm, ret;
6372
 
6373
  oldfn = current_function_decl;
6374
  current_function_decl = fndecl;
6375
  cfun = DECL_STRUCT_FUNCTION (fndecl);
6376
  if (cfun == NULL)
6377
    allocate_struct_function (fndecl);
6378
 
6379
  for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm))
6380
    {
6381
      /* Preliminarily mark non-addressed complex variables as eligible
6382
         for promotion to gimple registers.  We'll transform their uses
6383
         as we find them.  */
6384
      if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
6385
          && !TREE_THIS_VOLATILE (parm)
6386
          && !needs_to_live_in_memory (parm))
6387
        DECL_COMPLEX_GIMPLE_REG_P (parm) = 1;
6388
    }
6389
 
6390
  ret = DECL_RESULT (fndecl);
6391
  if (TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
6392
      && !needs_to_live_in_memory (ret))
6393
    DECL_COMPLEX_GIMPLE_REG_P (ret) = 1;
6394
 
6395
  gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true);
6396
 
6397
  /* If we're instrumenting function entry/exit, then prepend the call to
6398
     the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
6399
     catch the exit hook.  */
6400
  /* ??? Add some way to ignore exceptions for this TFE.  */
6401
  if (flag_instrument_function_entry_exit
6402
      && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl))
6403
    {
6404
      tree tf, x, bind;
6405
 
6406
      tf = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
6407
      TREE_SIDE_EFFECTS (tf) = 1;
6408
      x = DECL_SAVED_TREE (fndecl);
6409
      append_to_statement_list (x, &TREE_OPERAND (tf, 0));
6410
      x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
6411
      x = build_function_call_expr (x, NULL);
6412
      append_to_statement_list (x, &TREE_OPERAND (tf, 1));
6413
 
6414
      bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
6415
      TREE_SIDE_EFFECTS (bind) = 1;
6416
      x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
6417
      x = build_function_call_expr (x, NULL);
6418
      append_to_statement_list (x, &BIND_EXPR_BODY (bind));
6419
      append_to_statement_list (tf, &BIND_EXPR_BODY (bind));
6420
 
6421
      DECL_SAVED_TREE (fndecl) = bind;
6422
    }
6423
 
6424
  current_function_decl = oldfn;
6425
  cfun = oldfn ? DECL_STRUCT_FUNCTION (oldfn) : NULL;
6426
}
6427
 
6428
 
6429
/* Expands EXPR to list of gimple statements STMTS.  If SIMPLE is true,
6430
   force the result to be either ssa_name or an invariant, otherwise
6431
   just force it to be a rhs expression.  If VAR is not NULL, make the
6432
   base variable of the final destination be VAR if suitable.  */
6433
 
6434
tree
6435
force_gimple_operand (tree expr, tree *stmts, bool simple, tree var)
6436
{
6437
  tree t;
6438
  enum gimplify_status ret;
6439
  gimple_predicate gimple_test_f;
6440
 
6441
  *stmts = NULL_TREE;
6442
 
6443
  if (is_gimple_val (expr))
6444
    return expr;
6445
 
6446
  gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs;
6447
 
6448
  push_gimplify_context ();
6449
  gimplify_ctxp->into_ssa = in_ssa_p;
6450
 
6451
  if (var)
6452
    expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
6453
 
6454
  ret = gimplify_expr (&expr, stmts, NULL,
6455
                       gimple_test_f, fb_rvalue);
6456
  gcc_assert (ret != GS_ERROR);
6457
 
6458
  if (referenced_vars)
6459
    {
6460
      for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
6461
        add_referenced_var (t);
6462
    }
6463
 
6464
  pop_gimplify_context (NULL);
6465
 
6466
  return expr;
6467
}
6468
 
6469
/* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR.  If
6470
   some statements are produced, emits them before BSI.  */
6471
 
6472
tree
6473
force_gimple_operand_bsi (block_stmt_iterator *bsi, tree expr,
6474
                          bool simple_p, tree var)
6475
{
6476
  tree stmts;
6477
 
6478
  expr = force_gimple_operand (expr, &stmts, simple_p, var);
6479
  if (stmts)
6480
    bsi_insert_before (bsi, stmts, BSI_SAME_STMT);
6481
 
6482
  return expr;
6483
}
6484
 
6485
#include "gt-gimplify.h"

powered by: WebSVN 2.1.0

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