OSDN Git Service

* gimplify.c (gimplify_cond_expr): Use THEN_ and ELSE_ local variables.
[pf3gnuchains/gcc-fork.git] / gcc / gimplify.c
1 /* 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, 2008, 2009, 2010
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 "gimple.h"
32 #include "tree-iterator.h"
33 #include "tree-inline.h"
34 #include "diagnostic.h"
35 #include "langhooks.h"
36 #include "langhooks-def.h"
37 #include "tree-flow.h"
38 #include "cgraph.h"
39 #include "timevar.h"
40 #include "except.h"
41 #include "hashtab.h"
42 #include "flags.h"
43 #include "real.h"
44 #include "function.h"
45 #include "output.h"
46 #include "expr.h"
47 #include "ggc.h"
48 #include "toplev.h"
49 #include "target.h"
50 #include "optabs.h"
51 #include "pointer-set.h"
52 #include "splay-tree.h"
53 #include "vec.h"
54 #include "gimple.h"
55 #include "tree-pass.h"
56
57
58 enum gimplify_omp_var_data
59 {
60   GOVD_SEEN = 1,
61   GOVD_EXPLICIT = 2,
62   GOVD_SHARED = 4,
63   GOVD_PRIVATE = 8,
64   GOVD_FIRSTPRIVATE = 16,
65   GOVD_LASTPRIVATE = 32,
66   GOVD_REDUCTION = 64,
67   GOVD_LOCAL = 128,
68   GOVD_DEBUG_PRIVATE = 256,
69   GOVD_PRIVATE_OUTER_REF = 512,
70   GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
71                            | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
72 };
73
74
75 enum omp_region_type
76 {
77   ORT_WORKSHARE = 0,
78   ORT_TASK = 1,
79   ORT_PARALLEL = 2,
80   ORT_COMBINED_PARALLEL = 3
81 };
82
83 struct gimplify_omp_ctx
84 {
85   struct gimplify_omp_ctx *outer_context;
86   splay_tree variables;
87   struct pointer_set_t *privatized_types;
88   location_t location;
89   enum omp_clause_default_kind default_kind;
90   enum omp_region_type region_type;
91 };
92
93 static struct gimplify_ctx *gimplify_ctxp;
94 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
95
96
97 /* Formal (expression) temporary table handling: Multiple occurrences of
98    the same scalar expression are evaluated into the same temporary.  */
99
100 typedef struct gimple_temp_hash_elt
101 {
102   tree val;   /* Key */
103   tree temp;  /* Value */
104 } elt_t;
105
106 /* Forward declarations.  */
107 static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
108
109 /* Mark X addressable.  Unlike the langhook we expect X to be in gimple
110    form and we don't do any syntax checking.  */
111 void
112 mark_addressable (tree x)
113 {
114   while (handled_component_p (x))
115     x = TREE_OPERAND (x, 0);
116   if (TREE_CODE (x) != VAR_DECL
117       && TREE_CODE (x) != PARM_DECL
118       && TREE_CODE (x) != RESULT_DECL)
119     return ;
120   TREE_ADDRESSABLE (x) = 1;
121 }
122
123 /* Return a hash value for a formal temporary table entry.  */
124
125 static hashval_t
126 gimple_tree_hash (const void *p)
127 {
128   tree t = ((const elt_t *) p)->val;
129   return iterative_hash_expr (t, 0);
130 }
131
132 /* Compare two formal temporary table entries.  */
133
134 static int
135 gimple_tree_eq (const void *p1, const void *p2)
136 {
137   tree t1 = ((const elt_t *) p1)->val;
138   tree t2 = ((const elt_t *) p2)->val;
139   enum tree_code code = TREE_CODE (t1);
140
141   if (TREE_CODE (t2) != code
142       || TREE_TYPE (t1) != TREE_TYPE (t2))
143     return 0;
144
145   if (!operand_equal_p (t1, t2, 0))
146     return 0;
147
148   /* Only allow them to compare equal if they also hash equal; otherwise
149      results are nondeterminate, and we fail bootstrap comparison.  */
150   gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
151
152   return 1;
153 }
154
155 /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
156    *SEQ_P is NULL, a new sequence is allocated.  This function is
157    similar to gimple_seq_add_stmt, but does not scan the operands.
158    During gimplification, we need to manipulate statement sequences
159    before the def/use vectors have been constructed.  */
160
161 static void
162 gimplify_seq_add_stmt (gimple_seq *seq_p, gimple gs)
163 {
164   gimple_stmt_iterator si;
165
166   if (gs == NULL)
167     return;
168
169   if (*seq_p == NULL)
170     *seq_p = gimple_seq_alloc ();
171
172   si = gsi_last (*seq_p);
173
174   gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
175 }
176
177 /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
178    NULL, a new sequence is allocated.   This function is
179    similar to gimple_seq_add_seq, but does not scan the operands.
180    During gimplification, we need to manipulate statement sequences
181    before the def/use vectors have been constructed.  */
182
183 static void
184 gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
185 {
186   gimple_stmt_iterator si;
187
188   if (src == NULL)
189     return;
190
191   if (*dst_p == NULL)
192     *dst_p = gimple_seq_alloc ();
193
194   si = gsi_last (*dst_p);
195   gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
196 }
197
198 /* Set up a context for the gimplifier.  */
199
200 void
201 push_gimplify_context (struct gimplify_ctx *c)
202 {
203   memset (c, '\0', sizeof (*c));
204   c->prev_context = gimplify_ctxp;
205   gimplify_ctxp = c;
206 }
207
208 /* Tear down a context for the gimplifier.  If BODY is non-null, then
209    put the temporaries into the outer BIND_EXPR.  Otherwise, put them
210    in the local_decls.
211
212    BODY is not a sequence, but the first tuple in a sequence.  */
213
214 void
215 pop_gimplify_context (gimple body)
216 {
217   struct gimplify_ctx *c = gimplify_ctxp;
218
219   gcc_assert (c && (c->bind_expr_stack == NULL
220                     || VEC_empty (gimple, c->bind_expr_stack)));
221   VEC_free (gimple, heap, c->bind_expr_stack);
222   gimplify_ctxp = c->prev_context;
223
224   if (body)
225     declare_vars (c->temps, body, false);
226   else
227     record_vars (c->temps);
228
229   if (c->temp_htab)
230     htab_delete (c->temp_htab);
231 }
232
233 static void
234 gimple_push_bind_expr (gimple gimple_bind)
235 {
236   if (gimplify_ctxp->bind_expr_stack == NULL)
237     gimplify_ctxp->bind_expr_stack = VEC_alloc (gimple, heap, 8);
238   VEC_safe_push (gimple, heap, gimplify_ctxp->bind_expr_stack, gimple_bind);
239 }
240
241 static void
242 gimple_pop_bind_expr (void)
243 {
244   VEC_pop (gimple, gimplify_ctxp->bind_expr_stack);
245 }
246
247 gimple
248 gimple_current_bind_expr (void)
249 {
250   return VEC_last (gimple, gimplify_ctxp->bind_expr_stack);
251 }
252
253 /* Return the stack GIMPLE_BINDs created during gimplification.  */
254
255 VEC(gimple, heap) *
256 gimple_bind_expr_stack (void)
257 {
258   return gimplify_ctxp->bind_expr_stack;
259 }
260
261 /* Returns true iff there is a COND_EXPR between us and the innermost
262    CLEANUP_POINT_EXPR.  This info is used by gimple_push_cleanup.  */
263
264 static bool
265 gimple_conditional_context (void)
266 {
267   return gimplify_ctxp->conditions > 0;
268 }
269
270 /* Note that we've entered a COND_EXPR.  */
271
272 static void
273 gimple_push_condition (void)
274 {
275 #ifdef ENABLE_GIMPLE_CHECKING
276   if (gimplify_ctxp->conditions == 0)
277     gcc_assert (gimple_seq_empty_p (gimplify_ctxp->conditional_cleanups));
278 #endif
279   ++(gimplify_ctxp->conditions);
280 }
281
282 /* Note that we've left a COND_EXPR.  If we're back at unconditional scope
283    now, add any conditional cleanups we've seen to the prequeue.  */
284
285 static void
286 gimple_pop_condition (gimple_seq *pre_p)
287 {
288   int conds = --(gimplify_ctxp->conditions);
289
290   gcc_assert (conds >= 0);
291   if (conds == 0)
292     {
293       gimplify_seq_add_seq (pre_p, gimplify_ctxp->conditional_cleanups);
294       gimplify_ctxp->conditional_cleanups = NULL;
295     }
296 }
297
298 /* A stable comparison routine for use with splay trees and DECLs.  */
299
300 static int
301 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
302 {
303   tree a = (tree) xa;
304   tree b = (tree) xb;
305
306   return DECL_UID (a) - DECL_UID (b);
307 }
308
309 /* Create a new omp construct that deals with variable remapping.  */
310
311 static struct gimplify_omp_ctx *
312 new_omp_context (enum omp_region_type region_type)
313 {
314   struct gimplify_omp_ctx *c;
315
316   c = XCNEW (struct gimplify_omp_ctx);
317   c->outer_context = gimplify_omp_ctxp;
318   c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
319   c->privatized_types = pointer_set_create ();
320   c->location = input_location;
321   c->region_type = region_type;
322   if (region_type != ORT_TASK)
323     c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
324   else
325     c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
326
327   return c;
328 }
329
330 /* Destroy an omp construct that deals with variable remapping.  */
331
332 static void
333 delete_omp_context (struct gimplify_omp_ctx *c)
334 {
335   splay_tree_delete (c->variables);
336   pointer_set_destroy (c->privatized_types);
337   XDELETE (c);
338 }
339
340 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
341 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
342
343 /* A subroutine of append_to_statement_list{,_force}.  T is not NULL.  */
344
345 static void
346 append_to_statement_list_1 (tree t, tree *list_p)
347 {
348   tree list = *list_p;
349   tree_stmt_iterator i;
350
351   if (!list)
352     {
353       if (t && TREE_CODE (t) == STATEMENT_LIST)
354         {
355           *list_p = t;
356           return;
357         }
358       *list_p = list = alloc_stmt_list ();
359     }
360
361   i = tsi_last (list);
362   tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
363 }
364
365 /* Add T to the end of the list container pointed to by LIST_P.
366    If T is an expression with no effects, it is ignored.  */
367
368 void
369 append_to_statement_list (tree t, tree *list_p)
370 {
371   if (t && TREE_SIDE_EFFECTS (t))
372     append_to_statement_list_1 (t, list_p);
373 }
374
375 /* Similar, but the statement is always added, regardless of side effects.  */
376
377 void
378 append_to_statement_list_force (tree t, tree *list_p)
379 {
380   if (t != NULL_TREE)
381     append_to_statement_list_1 (t, list_p);
382 }
383
384 /* Both gimplify the statement T and append it to *SEQ_P.  This function
385    behaves exactly as gimplify_stmt, but you don't have to pass T as a
386    reference.  */
387
388 void
389 gimplify_and_add (tree t, gimple_seq *seq_p)
390 {
391   gimplify_stmt (&t, seq_p);
392 }
393
394 /* Gimplify statement T into sequence *SEQ_P, and return the first
395    tuple in the sequence of generated tuples for this statement.
396    Return NULL if gimplifying T produced no tuples.  */
397
398 static gimple
399 gimplify_and_return_first (tree t, gimple_seq *seq_p)
400 {
401   gimple_stmt_iterator last = gsi_last (*seq_p);
402
403   gimplify_and_add (t, seq_p);
404
405   if (!gsi_end_p (last))
406     {
407       gsi_next (&last);
408       return gsi_stmt (last);
409     }
410   else
411     return gimple_seq_first_stmt (*seq_p);
412 }
413
414 /* Strip off a legitimate source ending from the input string NAME of
415    length LEN.  Rather than having to know the names used by all of
416    our front ends, we strip off an ending of a period followed by
417    up to five characters.  (Java uses ".class".)  */
418
419 static inline void
420 remove_suffix (char *name, int len)
421 {
422   int i;
423
424   for (i = 2;  i < 8 && len > i;  i++)
425     {
426       if (name[len - i] == '.')
427         {
428           name[len - i] = '\0';
429           break;
430         }
431     }
432 }
433
434 /* Create a new temporary name with PREFIX.  Returns an identifier.  */
435
436 static GTY(()) unsigned int tmp_var_id_num;
437
438 tree
439 create_tmp_var_name (const char *prefix)
440 {
441   char *tmp_name;
442
443   if (prefix)
444     {
445       char *preftmp = ASTRDUP (prefix);
446
447       remove_suffix (preftmp, strlen (preftmp));
448       prefix = preftmp;
449     }
450
451   ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
452   return get_identifier (tmp_name);
453 }
454
455
456 /* Create a new temporary variable declaration of type TYPE.
457    Does NOT push it into the current binding.  */
458
459 tree
460 create_tmp_var_raw (tree type, const char *prefix)
461 {
462   tree tmp_var;
463   tree new_type;
464
465   /* Make the type of the variable writable.  */
466   new_type = build_type_variant (type, 0, 0);
467   TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
468
469   tmp_var = build_decl (input_location,
470                         VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
471                         type);
472
473   /* The variable was declared by the compiler.  */
474   DECL_ARTIFICIAL (tmp_var) = 1;
475   /* And we don't want debug info for it.  */
476   DECL_IGNORED_P (tmp_var) = 1;
477
478   /* Make the variable writable.  */
479   TREE_READONLY (tmp_var) = 0;
480
481   DECL_EXTERNAL (tmp_var) = 0;
482   TREE_STATIC (tmp_var) = 0;
483   TREE_USED (tmp_var) = 1;
484
485   return tmp_var;
486 }
487
488 /* Create a new temporary variable declaration of type TYPE.  DOES push the
489    variable into the current binding.  Further, assume that this is called
490    only from gimplification or optimization, at which point the creation of
491    certain types are bugs.  */
492
493 tree
494 create_tmp_var (tree type, const char *prefix)
495 {
496   tree tmp_var;
497
498   /* We don't allow types that are addressable (meaning we can't make copies),
499      or incomplete.  We also used to reject every variable size objects here,
500      but now support those for which a constant upper bound can be obtained.
501      The processing for variable sizes is performed in gimple_add_tmp_var,
502      point at which it really matters and possibly reached via paths not going
503      through this function, e.g. after direct calls to create_tmp_var_raw.  */
504   gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
505
506   tmp_var = create_tmp_var_raw (type, prefix);
507   gimple_add_tmp_var (tmp_var);
508   return tmp_var;
509 }
510
511 /* Create a new temporary variable declaration of type TYPE by calling
512    create_tmp_var and if TYPE is a vector or a complex number, mark the new
513    temporary as gimple register.  */
514
515 tree
516 create_tmp_reg (tree type, const char *prefix)
517 {
518   tree tmp;
519
520   tmp = create_tmp_var (type, prefix);
521   if (TREE_CODE (type) == COMPLEX_TYPE
522       || TREE_CODE (type) == VECTOR_TYPE)
523     DECL_GIMPLE_REG_P (tmp) = 1;
524
525   return tmp;
526 }
527
528 /* Create a temporary with a name derived from VAL.  Subroutine of
529    lookup_tmp_var; nobody else should call this function.  */
530
531 static inline tree
532 create_tmp_from_val (tree val)
533 {
534   return create_tmp_var (TREE_TYPE (val), get_name (val));
535 }
536
537 /* Create a temporary to hold the value of VAL.  If IS_FORMAL, try to reuse
538    an existing expression temporary.  */
539
540 static tree
541 lookup_tmp_var (tree val, bool is_formal)
542 {
543   tree ret;
544
545   /* If not optimizing, never really reuse a temporary.  local-alloc
546      won't allocate any variable that is used in more than one basic
547      block, which means it will go into memory, causing much extra
548      work in reload and final and poorer code generation, outweighing
549      the extra memory allocation here.  */
550   if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
551     ret = create_tmp_from_val (val);
552   else
553     {
554       elt_t elt, *elt_p;
555       void **slot;
556
557       elt.val = val;
558       if (gimplify_ctxp->temp_htab == NULL)
559         gimplify_ctxp->temp_htab
560           = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
561       slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
562       if (*slot == NULL)
563         {
564           elt_p = XNEW (elt_t);
565           elt_p->val = val;
566           elt_p->temp = ret = create_tmp_from_val (val);
567           *slot = (void *) elt_p;
568         }
569       else
570         {
571           elt_p = (elt_t *) *slot;
572           ret = elt_p->temp;
573         }
574     }
575
576   return ret;
577 }
578
579
580 /* Return true if T is a CALL_EXPR or an expression that can be
581    assignmed to a temporary.  Note that this predicate should only be
582    used during gimplification.  See the rationale for this in
583    gimplify_modify_expr.  */
584
585 static bool
586 is_gimple_reg_rhs_or_call (tree t)
587 {
588   return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
589           || TREE_CODE (t) == CALL_EXPR);
590 }
591
592 /* Return true if T is a valid memory RHS or a CALL_EXPR.  Note that
593    this predicate should only be used during gimplification.  See the
594    rationale for this in gimplify_modify_expr.  */
595
596 static bool
597 is_gimple_mem_rhs_or_call (tree t)
598 {
599   /* If we're dealing with a renamable type, either source or dest must be
600      a renamed variable.  */
601   if (is_gimple_reg_type (TREE_TYPE (t)))
602     return is_gimple_val (t);
603   else
604     return (is_gimple_val (t) || is_gimple_lvalue (t)
605             || TREE_CODE (t) == CALL_EXPR);
606 }
607
608 /* Helper for get_formal_tmp_var and get_initialized_tmp_var.  */
609
610 static tree
611 internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
612                       bool is_formal)
613 {
614   tree t, mod;
615
616   /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
617      can create an INIT_EXPR and convert it into a GIMPLE_CALL below.  */
618   gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
619                  fb_rvalue);
620
621   t = lookup_tmp_var (val, is_formal);
622
623   if (is_formal
624       && (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
625           || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE))
626     DECL_GIMPLE_REG_P (t) = 1;
627
628   mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
629
630   if (EXPR_HAS_LOCATION (val))
631     SET_EXPR_LOCATION (mod, EXPR_LOCATION (val));
632   else
633     SET_EXPR_LOCATION (mod, input_location);
634
635   /* gimplify_modify_expr might want to reduce this further.  */
636   gimplify_and_add (mod, pre_p);
637   ggc_free (mod);
638
639   /* If we're gimplifying into ssa, gimplify_modify_expr will have
640      given our temporary an SSA name.  Find and return it.  */
641   if (gimplify_ctxp->into_ssa)
642     {
643       gimple last = gimple_seq_last_stmt (*pre_p);
644       t = gimple_get_lhs (last);
645     }
646
647   return t;
648 }
649
650 /* Returns a formal temporary variable initialized with VAL.  PRE_P is as
651    in gimplify_expr.  Only use this function if:
652
653    1) The value of the unfactored expression represented by VAL will not
654       change between the initialization and use of the temporary, and
655    2) The temporary will not be otherwise modified.
656
657    For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
658    and #2 means it is inappropriate for && temps.
659
660    For other cases, use get_initialized_tmp_var instead.  */
661
662 tree
663 get_formal_tmp_var (tree val, gimple_seq *pre_p)
664 {
665   return internal_get_tmp_var (val, pre_p, NULL, true);
666 }
667
668 /* Returns a temporary variable initialized with VAL.  PRE_P and POST_P
669    are as in gimplify_expr.  */
670
671 tree
672 get_initialized_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p)
673 {
674   return internal_get_tmp_var (val, pre_p, post_p, false);
675 }
676
677 /* Declares all the variables in VARS in SCOPE.  If DEBUG_INFO is
678    true, generate debug info for them; otherwise don't.  */
679
680 void
681 declare_vars (tree vars, gimple scope, bool debug_info)
682 {
683   tree last = vars;
684   if (last)
685     {
686       tree temps, block;
687
688       gcc_assert (gimple_code (scope) == GIMPLE_BIND);
689
690       temps = nreverse (last);
691
692       block = gimple_bind_block (scope);
693       gcc_assert (!block || TREE_CODE (block) == BLOCK);
694       if (!block || !debug_info)
695         {
696           TREE_CHAIN (last) = gimple_bind_vars (scope);
697           gimple_bind_set_vars (scope, temps);
698         }
699       else
700         {
701           /* We need to attach the nodes both to the BIND_EXPR and to its
702              associated BLOCK for debugging purposes.  The key point here
703              is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
704              is a subchain of the BIND_EXPR_VARS of the BIND_EXPR.  */
705           if (BLOCK_VARS (block))
706             BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
707           else
708             {
709               gimple_bind_set_vars (scope,
710                                     chainon (gimple_bind_vars (scope), temps));
711               BLOCK_VARS (block) = temps;
712             }
713         }
714     }
715 }
716
717 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
718    for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly.  Abort if
719    no such upper bound can be obtained.  */
720
721 static void
722 force_constant_size (tree var)
723 {
724   /* The only attempt we make is by querying the maximum size of objects
725      of the variable's type.  */
726
727   HOST_WIDE_INT max_size;
728
729   gcc_assert (TREE_CODE (var) == VAR_DECL);
730
731   max_size = max_int_size_in_bytes (TREE_TYPE (var));
732
733   gcc_assert (max_size >= 0);
734
735   DECL_SIZE_UNIT (var)
736     = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
737   DECL_SIZE (var)
738     = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
739 }
740
741 void
742 gimple_add_tmp_var (tree tmp)
743 {
744   gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
745
746   /* Later processing assumes that the object size is constant, which might
747      not be true at this point.  Force the use of a constant upper bound in
748      this case.  */
749   if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
750     force_constant_size (tmp);
751
752   DECL_CONTEXT (tmp) = current_function_decl;
753   DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
754
755   if (gimplify_ctxp)
756     {
757       TREE_CHAIN (tmp) = gimplify_ctxp->temps;
758       gimplify_ctxp->temps = tmp;
759
760       /* Mark temporaries local within the nearest enclosing parallel.  */
761       if (gimplify_omp_ctxp)
762         {
763           struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
764           while (ctx && ctx->region_type == ORT_WORKSHARE)
765             ctx = ctx->outer_context;
766           if (ctx)
767             omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
768         }
769     }
770   else if (cfun)
771     record_vars (tmp);
772   else
773     {
774       gimple_seq body_seq;
775
776       /* This case is for nested functions.  We need to expose the locals
777          they create.  */
778       body_seq = gimple_body (current_function_decl);
779       declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
780     }
781 }
782
783 /* Determines whether to assign a location to the statement GS.  */
784
785 static bool
786 should_carry_location_p (gimple gs)
787 {
788   /* Don't emit a line note for a label.  We particularly don't want to
789      emit one for the break label, since it doesn't actually correspond
790      to the beginning of the loop/switch.  */
791   if (gimple_code (gs) == GIMPLE_LABEL)
792     return false;
793
794   return true;
795 }
796
797
798 /* Return true if a location should not be emitted for this statement
799    by annotate_one_with_location.  */
800
801 static inline bool
802 gimple_do_not_emit_location_p (gimple g)
803 {
804   return gimple_plf (g, GF_PLF_1);
805 }
806
807 /* Mark statement G so a location will not be emitted by
808    annotate_one_with_location.  */
809
810 static inline void
811 gimple_set_do_not_emit_location (gimple g)
812 {
813   /* The PLF flags are initialized to 0 when a new tuple is created,
814      so no need to initialize it anywhere.  */
815   gimple_set_plf (g, GF_PLF_1, true);
816 }
817
818 /* Set the location for gimple statement GS to LOCATION.  */
819
820 static void
821 annotate_one_with_location (gimple gs, location_t location)
822 {
823   if (!gimple_has_location (gs)
824       && !gimple_do_not_emit_location_p (gs)
825       && should_carry_location_p (gs))
826     gimple_set_location (gs, location);
827 }
828
829
830 /* Set LOCATION for all the statements after iterator GSI in sequence
831    SEQ.  If GSI is pointing to the end of the sequence, start with the
832    first statement in SEQ.  */
833
834 static void
835 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
836                                   location_t location)
837 {
838   if (gsi_end_p (gsi))
839     gsi = gsi_start (seq);
840   else
841     gsi_next (&gsi);
842
843   for (; !gsi_end_p (gsi); gsi_next (&gsi))
844     annotate_one_with_location (gsi_stmt (gsi), location);
845 }
846
847
848 /* Set the location for all the statements in a sequence STMT_P to LOCATION.  */
849
850 void
851 annotate_all_with_location (gimple_seq stmt_p, location_t location)
852 {
853   gimple_stmt_iterator i;
854
855   if (gimple_seq_empty_p (stmt_p))
856     return;
857
858   for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
859     {
860       gimple gs = gsi_stmt (i);
861       annotate_one_with_location (gs, location);
862     }
863 }
864
865
866 /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
867    These nodes model computations that should only be done once.  If we
868    were to unshare something like SAVE_EXPR(i++), the gimplification
869    process would create wrong code.  */
870
871 static tree
872 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
873 {
874   enum tree_code code = TREE_CODE (*tp);
875   /* Don't unshare types, decls, constants and SAVE_EXPR nodes.  */
876   if (TREE_CODE_CLASS (code) == tcc_type
877       || TREE_CODE_CLASS (code) == tcc_declaration
878       || TREE_CODE_CLASS (code) == tcc_constant
879       || code == SAVE_EXPR || code == TARGET_EXPR
880       /* We can't do anything sensible with a BLOCK used as an expression,
881          but we also can't just die when we see it because of non-expression
882          uses.  So just avert our eyes and cross our fingers.  Silly Java.  */
883       || code == BLOCK)
884     *walk_subtrees = 0;
885   else
886     {
887       gcc_assert (code != BIND_EXPR);
888       copy_tree_r (tp, walk_subtrees, data);
889     }
890
891   return NULL_TREE;
892 }
893
894 /* Callback for walk_tree to unshare most of the shared trees rooted at
895    *TP.  If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
896    then *TP is deep copied by calling copy_tree_r.
897
898    This unshares the same trees as copy_tree_r with the exception of
899    SAVE_EXPR nodes.  These nodes model computations that should only be
900    done once.  If we were to unshare something like SAVE_EXPR(i++), the
901    gimplification process would create wrong code.  */
902
903 static tree
904 copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
905                   void *data ATTRIBUTE_UNUSED)
906 {
907   tree t = *tp;
908   enum tree_code code = TREE_CODE (t);
909
910   /* Skip types, decls, and constants.  But we do want to look at their
911      types and the bounds of types.  Mark them as visited so we properly
912      unmark their subtrees on the unmark pass.  If we've already seen them,
913      don't look down further.  */
914   if (TREE_CODE_CLASS (code) == tcc_type
915       || TREE_CODE_CLASS (code) == tcc_declaration
916       || TREE_CODE_CLASS (code) == tcc_constant)
917     {
918       if (TREE_VISITED (t))
919         *walk_subtrees = 0;
920       else
921         TREE_VISITED (t) = 1;
922     }
923
924   /* If this node has been visited already, unshare it and don't look
925      any deeper.  */
926   else if (TREE_VISITED (t))
927     {
928       walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
929       *walk_subtrees = 0;
930     }
931
932   /* Otherwise, mark the tree as visited and keep looking.  */
933   else
934     TREE_VISITED (t) = 1;
935
936   return NULL_TREE;
937 }
938
939 static tree
940 unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
941                   void *data ATTRIBUTE_UNUSED)
942 {
943   if (TREE_VISITED (*tp))
944     TREE_VISITED (*tp) = 0;
945   else
946     *walk_subtrees = 0;
947
948   return NULL_TREE;
949 }
950
951 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
952    bodies of any nested functions if we are unsharing the entire body of
953    FNDECL.  */
954
955 static void
956 unshare_body (tree *body_p, tree fndecl)
957 {
958   struct cgraph_node *cgn = cgraph_node (fndecl);
959
960   walk_tree (body_p, copy_if_shared_r, NULL, NULL);
961   if (body_p == &DECL_SAVED_TREE (fndecl))
962     for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
963       unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
964 }
965
966 /* Likewise, but mark all trees as not visited.  */
967
968 static void
969 unvisit_body (tree *body_p, tree fndecl)
970 {
971   struct cgraph_node *cgn = cgraph_node (fndecl);
972
973   walk_tree (body_p, unmark_visited_r, NULL, NULL);
974   if (body_p == &DECL_SAVED_TREE (fndecl))
975     for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
976       unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
977 }
978
979 /* Unconditionally make an unshared copy of EXPR.  This is used when using
980    stored expressions which span multiple functions, such as BINFO_VTABLE,
981    as the normal unsharing process can't tell that they're shared.  */
982
983 tree
984 unshare_expr (tree expr)
985 {
986   walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
987   return expr;
988 }
989 \f
990 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
991    contain statements and have a value.  Assign its value to a temporary
992    and give it void_type_node.  Returns the temporary, or NULL_TREE if
993    WRAPPER was already void.  */
994
995 tree
996 voidify_wrapper_expr (tree wrapper, tree temp)
997 {
998   tree type = TREE_TYPE (wrapper);
999   if (type && !VOID_TYPE_P (type))
1000     {
1001       tree *p;
1002
1003       /* Set p to point to the body of the wrapper.  Loop until we find
1004          something that isn't a wrapper.  */
1005       for (p = &wrapper; p && *p; )
1006         {
1007           switch (TREE_CODE (*p))
1008             {
1009             case BIND_EXPR:
1010               TREE_SIDE_EFFECTS (*p) = 1;
1011               TREE_TYPE (*p) = void_type_node;
1012               /* For a BIND_EXPR, the body is operand 1.  */
1013               p = &BIND_EXPR_BODY (*p);
1014               break;
1015
1016             case CLEANUP_POINT_EXPR:
1017             case TRY_FINALLY_EXPR:
1018             case TRY_CATCH_EXPR:
1019               TREE_SIDE_EFFECTS (*p) = 1;
1020               TREE_TYPE (*p) = void_type_node;
1021               p = &TREE_OPERAND (*p, 0);
1022               break;
1023
1024             case STATEMENT_LIST:
1025               {
1026                 tree_stmt_iterator i = tsi_last (*p);
1027                 TREE_SIDE_EFFECTS (*p) = 1;
1028                 TREE_TYPE (*p) = void_type_node;
1029                 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1030               }
1031               break;
1032
1033             case COMPOUND_EXPR:
1034               /* Advance to the last statement.  Set all container types to void.  */
1035               for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1036                 {
1037                   TREE_SIDE_EFFECTS (*p) = 1;
1038                   TREE_TYPE (*p) = void_type_node;
1039                 }
1040               break;
1041
1042             default:
1043               goto out;
1044             }
1045         }
1046
1047     out:
1048       if (p == NULL || IS_EMPTY_STMT (*p))
1049         temp = NULL_TREE;
1050       else if (temp)
1051         {
1052           /* The wrapper is on the RHS of an assignment that we're pushing
1053              down.  */
1054           gcc_assert (TREE_CODE (temp) == INIT_EXPR
1055                       || TREE_CODE (temp) == MODIFY_EXPR);
1056           TREE_OPERAND (temp, 1) = *p;
1057           *p = temp;
1058         }
1059       else
1060         {
1061           temp = create_tmp_var (type, "retval");
1062           *p = build2 (INIT_EXPR, type, temp, *p);
1063         }
1064
1065       return temp;
1066     }
1067
1068   return NULL_TREE;
1069 }
1070
1071 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1072    a temporary through which they communicate.  */
1073
1074 static void
1075 build_stack_save_restore (gimple *save, gimple *restore)
1076 {
1077   tree tmp_var;
1078
1079   *save = gimple_build_call (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 0);
1080   tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1081   gimple_call_set_lhs (*save, tmp_var);
1082
1083   *restore = gimple_build_call (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
1084                             1, tmp_var);
1085 }
1086
1087 /* Gimplify a BIND_EXPR.  Just voidify and recurse.  */
1088
1089 static enum gimplify_status
1090 gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
1091 {
1092   tree bind_expr = *expr_p;
1093   bool old_save_stack = gimplify_ctxp->save_stack;
1094   tree t;
1095   gimple gimple_bind;
1096   gimple_seq body;
1097
1098   tree temp = voidify_wrapper_expr (bind_expr, NULL);
1099
1100   /* Mark variables seen in this bind expr.  */
1101   for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
1102     {
1103       if (TREE_CODE (t) == VAR_DECL)
1104         {
1105           struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1106
1107           /* Mark variable as local.  */
1108           if (ctx && !is_global_var (t)
1109               && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1110                   || splay_tree_lookup (ctx->variables,
1111                                         (splay_tree_key) t) == NULL))
1112             omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1113
1114           DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1115
1116           if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
1117             cfun->has_local_explicit_reg_vars = true;
1118         }
1119
1120       /* Preliminarily mark non-addressed complex variables as eligible
1121          for promotion to gimple registers.  We'll transform their uses
1122          as we find them.
1123          We exclude complex types if not optimizing because they can be
1124          subject to partial stores in GNU C by means of the __real__ and
1125          __imag__ operators and we cannot promote them to total stores
1126          (see gimplify_modify_expr_complex_part).  */
1127       if (optimize
1128           && (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1129               || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1130           && !TREE_THIS_VOLATILE (t)
1131           && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1132           && !needs_to_live_in_memory (t))
1133         DECL_GIMPLE_REG_P (t) = 1;
1134     }
1135
1136   gimple_bind = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
1137                                    BIND_EXPR_BLOCK (bind_expr));
1138   gimple_push_bind_expr (gimple_bind);
1139
1140   gimplify_ctxp->save_stack = false;
1141
1142   /* Gimplify the body into the GIMPLE_BIND tuple's body.  */
1143   body = NULL;
1144   gimplify_stmt (&BIND_EXPR_BODY (bind_expr), &body);
1145   gimple_bind_set_body (gimple_bind, body);
1146
1147   if (gimplify_ctxp->save_stack)
1148     {
1149       gimple stack_save, stack_restore, gs;
1150       gimple_seq cleanup, new_body;
1151
1152       /* Save stack on entry and restore it on exit.  Add a try_finally
1153          block to achieve this.  Note that mudflap depends on the
1154          format of the emitted code: see mx_register_decls().  */
1155       build_stack_save_restore (&stack_save, &stack_restore);
1156
1157       cleanup = new_body = NULL;
1158       gimplify_seq_add_stmt (&cleanup, stack_restore);
1159       gs = gimple_build_try (gimple_bind_body (gimple_bind), cleanup,
1160                              GIMPLE_TRY_FINALLY);
1161
1162       gimplify_seq_add_stmt (&new_body, stack_save);
1163       gimplify_seq_add_stmt (&new_body, gs);
1164       gimple_bind_set_body (gimple_bind, new_body);
1165     }
1166
1167   gimplify_ctxp->save_stack = old_save_stack;
1168   gimple_pop_bind_expr ();
1169
1170   gimplify_seq_add_stmt (pre_p, gimple_bind);
1171
1172   if (temp)
1173     {
1174       *expr_p = temp;
1175       return GS_OK;
1176     }
1177
1178   *expr_p = NULL_TREE;
1179   return GS_ALL_DONE;
1180 }
1181
1182 /* Gimplify a RETURN_EXPR.  If the expression to be returned is not a
1183    GIMPLE value, it is assigned to a new temporary and the statement is
1184    re-written to return the temporary.
1185
1186    PRE_P points to the sequence where side effects that must happen before
1187    STMT should be stored.  */
1188
1189 static enum gimplify_status
1190 gimplify_return_expr (tree stmt, gimple_seq *pre_p)
1191 {
1192   gimple ret;
1193   tree ret_expr = TREE_OPERAND (stmt, 0);
1194   tree result_decl, result;
1195
1196   if (ret_expr == error_mark_node)
1197     return GS_ERROR;
1198
1199   if (!ret_expr
1200       || TREE_CODE (ret_expr) == RESULT_DECL
1201       || ret_expr == error_mark_node)
1202     {
1203       gimple ret = gimple_build_return (ret_expr);
1204       gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1205       gimplify_seq_add_stmt (pre_p, ret);
1206       return GS_ALL_DONE;
1207     }
1208
1209   if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1210     result_decl = NULL_TREE;
1211   else
1212     {
1213       result_decl = TREE_OPERAND (ret_expr, 0);
1214
1215       /* See through a return by reference.  */
1216       if (TREE_CODE (result_decl) == INDIRECT_REF)
1217         result_decl = TREE_OPERAND (result_decl, 0);
1218
1219       gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1220                    || TREE_CODE (ret_expr) == INIT_EXPR)
1221                   && TREE_CODE (result_decl) == RESULT_DECL);
1222     }
1223
1224   /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1225      Recall that aggregate_value_p is FALSE for any aggregate type that is
1226      returned in registers.  If we're returning values in registers, then
1227      we don't want to extend the lifetime of the RESULT_DECL, particularly
1228      across another call.  In addition, for those aggregates for which
1229      hard_function_value generates a PARALLEL, we'll die during normal
1230      expansion of structure assignments; there's special code in expand_return
1231      to handle this case that does not exist in expand_expr.  */
1232   if (!result_decl
1233       || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1234     result = result_decl;
1235   else if (gimplify_ctxp->return_temp)
1236     result = gimplify_ctxp->return_temp;
1237   else
1238     {
1239       result = create_tmp_reg (TREE_TYPE (result_decl), NULL);
1240
1241       /* ??? With complex control flow (usually involving abnormal edges),
1242          we can wind up warning about an uninitialized value for this.  Due
1243          to how this variable is constructed and initialized, this is never
1244          true.  Give up and never warn.  */
1245       TREE_NO_WARNING (result) = 1;
1246
1247       gimplify_ctxp->return_temp = result;
1248     }
1249
1250   /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1251      Then gimplify the whole thing.  */
1252   if (result != result_decl)
1253     TREE_OPERAND (ret_expr, 0) = result;
1254
1255   gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1256
1257   ret = gimple_build_return (result);
1258   gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1259   gimplify_seq_add_stmt (pre_p, ret);
1260
1261   return GS_ALL_DONE;
1262 }
1263
1264 static void
1265 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1266 {
1267   /* This is a variable-sized decl.  Simplify its size and mark it
1268      for deferred expansion.  Note that mudflap depends on the format
1269      of the emitted code: see mx_register_decls().  */
1270   tree t, addr, ptr_type;
1271
1272   gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1273   gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1274
1275   /* All occurrences of this decl in final gimplified code will be
1276      replaced by indirection.  Setting DECL_VALUE_EXPR does two
1277      things: First, it lets the rest of the gimplifier know what
1278      replacement to use.  Second, it lets the debug info know
1279      where to find the value.  */
1280   ptr_type = build_pointer_type (TREE_TYPE (decl));
1281   addr = create_tmp_var (ptr_type, get_name (decl));
1282   DECL_IGNORED_P (addr) = 0;
1283   t = build_fold_indirect_ref (addr);
1284   SET_DECL_VALUE_EXPR (decl, t);
1285   DECL_HAS_VALUE_EXPR_P (decl) = 1;
1286
1287   t = built_in_decls[BUILT_IN_ALLOCA];
1288   t = build_call_expr (t, 1, DECL_SIZE_UNIT (decl));
1289   t = fold_convert (ptr_type, t);
1290   t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1291
1292   gimplify_and_add (t, seq_p);
1293
1294   /* Indicate that we need to restore the stack level when the
1295      enclosing BIND_EXPR is exited.  */
1296   gimplify_ctxp->save_stack = true;
1297 }
1298
1299
1300 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1301    and initialization explicit.  */
1302
1303 static enum gimplify_status
1304 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1305 {
1306   tree stmt = *stmt_p;
1307   tree decl = DECL_EXPR_DECL (stmt);
1308
1309   *stmt_p = NULL_TREE;
1310
1311   if (TREE_TYPE (decl) == error_mark_node)
1312     return GS_ERROR;
1313
1314   if ((TREE_CODE (decl) == TYPE_DECL
1315        || TREE_CODE (decl) == VAR_DECL)
1316       && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1317     gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1318
1319   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1320     {
1321       tree init = DECL_INITIAL (decl);
1322
1323       if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1324           || (!TREE_STATIC (decl)
1325               && flag_stack_check == GENERIC_STACK_CHECK
1326               && compare_tree_int (DECL_SIZE_UNIT (decl),
1327                                    STACK_CHECK_MAX_VAR_SIZE) > 0))
1328         gimplify_vla_decl (decl, seq_p);
1329
1330       if (init && init != error_mark_node)
1331         {
1332           if (!TREE_STATIC (decl))
1333             {
1334               DECL_INITIAL (decl) = NULL_TREE;
1335               init = build2 (INIT_EXPR, void_type_node, decl, init);
1336               gimplify_and_add (init, seq_p);
1337               ggc_free (init);
1338             }
1339           else
1340             /* We must still examine initializers for static variables
1341                as they may contain a label address.  */
1342             walk_tree (&init, force_labels_r, NULL, NULL);
1343         }
1344
1345       /* Some front ends do not explicitly declare all anonymous
1346          artificial variables.  We compensate here by declaring the
1347          variables, though it would be better if the front ends would
1348          explicitly declare them.  */
1349       if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1350           && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1351         gimple_add_tmp_var (decl);
1352     }
1353
1354   return GS_ALL_DONE;
1355 }
1356
1357 /* Gimplify a LOOP_EXPR.  Normally this just involves gimplifying the body
1358    and replacing the LOOP_EXPR with goto, but if the loop contains an
1359    EXIT_EXPR, we need to append a label for it to jump to.  */
1360
1361 static enum gimplify_status
1362 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1363 {
1364   tree saved_label = gimplify_ctxp->exit_label;
1365   tree start_label = create_artificial_label (UNKNOWN_LOCATION);
1366
1367   gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1368
1369   gimplify_ctxp->exit_label = NULL_TREE;
1370
1371   gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1372
1373   gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1374
1375   if (gimplify_ctxp->exit_label)
1376     gimplify_seq_add_stmt (pre_p, gimple_build_label (gimplify_ctxp->exit_label));
1377
1378   gimplify_ctxp->exit_label = saved_label;
1379
1380   *expr_p = NULL;
1381   return GS_ALL_DONE;
1382 }
1383
1384 /* Gimplifies a statement list onto a sequence.  These may be created either
1385    by an enlightened front-end, or by shortcut_cond_expr.  */
1386
1387 static enum gimplify_status
1388 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1389 {
1390   tree temp = voidify_wrapper_expr (*expr_p, NULL);
1391
1392   tree_stmt_iterator i = tsi_start (*expr_p);
1393
1394   while (!tsi_end_p (i))
1395     {
1396       gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1397       tsi_delink (&i);
1398     }
1399
1400   if (temp)
1401     {
1402       *expr_p = temp;
1403       return GS_OK;
1404     }
1405
1406   return GS_ALL_DONE;
1407 }
1408
1409 /* Compare two case labels.  Because the front end should already have
1410    made sure that case ranges do not overlap, it is enough to only compare
1411    the CASE_LOW values of each case label.  */
1412
1413 static int
1414 compare_case_labels (const void *p1, const void *p2)
1415 {
1416   const_tree const case1 = *(const_tree const*)p1;
1417   const_tree const case2 = *(const_tree const*)p2;
1418
1419   /* The 'default' case label always goes first.  */
1420   if (!CASE_LOW (case1))
1421     return -1;
1422   else if (!CASE_LOW (case2))
1423     return 1;
1424   else
1425     return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1426 }
1427
1428
1429 /* Sort the case labels in LABEL_VEC in place in ascending order.  */
1430
1431 void
1432 sort_case_labels (VEC(tree,heap)* label_vec)
1433 {
1434   size_t len = VEC_length (tree, label_vec);
1435   qsort (VEC_address (tree, label_vec), len, sizeof (tree),
1436          compare_case_labels);
1437 }
1438
1439
1440 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1441    branch to.  */
1442
1443 static enum gimplify_status
1444 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
1445 {
1446   tree switch_expr = *expr_p;
1447   gimple_seq switch_body_seq = NULL;
1448   enum gimplify_status ret;
1449
1450   ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
1451                        fb_rvalue);
1452   if (ret == GS_ERROR || ret == GS_UNHANDLED)
1453     return ret;
1454
1455   if (SWITCH_BODY (switch_expr))
1456     {
1457       VEC (tree,heap) *labels;
1458       VEC (tree,heap) *saved_labels;
1459       tree default_case = NULL_TREE;
1460       size_t i, len;
1461       gimple gimple_switch;
1462
1463       /* If someone can be bothered to fill in the labels, they can
1464          be bothered to null out the body too.  */
1465       gcc_assert (!SWITCH_LABELS (switch_expr));
1466
1467       /* save old labels, get new ones from body, then restore the old
1468          labels.  Save all the things from the switch body to append after.  */
1469       saved_labels = gimplify_ctxp->case_labels;
1470       gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1471
1472       gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
1473       labels = gimplify_ctxp->case_labels;
1474       gimplify_ctxp->case_labels = saved_labels;
1475
1476       i = 0;
1477       while (i < VEC_length (tree, labels))
1478         {
1479           tree elt = VEC_index (tree, labels, i);
1480           tree low = CASE_LOW (elt);
1481           bool remove_element = FALSE;
1482
1483           if (low)
1484             {
1485               /* Discard empty ranges.  */
1486               tree high = CASE_HIGH (elt);
1487               if (high && tree_int_cst_lt (high, low))
1488                 remove_element = TRUE;
1489             }
1490           else
1491             {
1492               /* The default case must be the last label in the list.  */
1493               gcc_assert (!default_case);
1494               default_case = elt;
1495               remove_element = TRUE;
1496             }
1497
1498           if (remove_element)
1499             VEC_ordered_remove (tree, labels, i);
1500           else
1501             i++;
1502         }
1503       len = i;
1504
1505       if (!VEC_empty (tree, labels))
1506         sort_case_labels (labels);
1507
1508       if (!default_case)
1509         {
1510           tree type = TREE_TYPE (switch_expr);
1511
1512           /* If the switch has no default label, add one, so that we jump
1513              around the switch body.  If the labels already cover the whole
1514              range of type, add the default label pointing to one of the
1515              existing labels.  */
1516           if (type == void_type_node)
1517             type = TREE_TYPE (SWITCH_COND (switch_expr));
1518           if (len
1519               && INTEGRAL_TYPE_P (type)
1520               && TYPE_MIN_VALUE (type)
1521               && TYPE_MAX_VALUE (type)
1522               && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
1523                                      TYPE_MIN_VALUE (type)))
1524             {
1525               tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
1526               if (!high)
1527                 high = CASE_LOW (VEC_index (tree, labels, len - 1));
1528               if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
1529                 {
1530                   for (i = 1; i < len; i++)
1531                     {
1532                       high = CASE_LOW (VEC_index (tree, labels, i));
1533                       low = CASE_HIGH (VEC_index (tree, labels, i - 1));
1534                       if (!low)
1535                         low = CASE_LOW (VEC_index (tree, labels, i - 1));
1536                       if ((TREE_INT_CST_LOW (low) + 1
1537                            != TREE_INT_CST_LOW (high))
1538                           || (TREE_INT_CST_HIGH (low)
1539                               + (TREE_INT_CST_LOW (high) == 0)
1540                               != TREE_INT_CST_HIGH (high)))
1541                         break;
1542                     }
1543                   if (i == len)
1544                     default_case = build3 (CASE_LABEL_EXPR, void_type_node,
1545                                            NULL_TREE, NULL_TREE,
1546                                            CASE_LABEL (VEC_index (tree,
1547                                                                   labels, 0)));
1548                 }
1549             }
1550
1551           if (!default_case)
1552             {
1553               gimple new_default;
1554
1555               default_case
1556                 = build3 (CASE_LABEL_EXPR, void_type_node,
1557                           NULL_TREE, NULL_TREE,
1558                           create_artificial_label (UNKNOWN_LOCATION));
1559               new_default = gimple_build_label (CASE_LABEL (default_case));
1560               gimplify_seq_add_stmt (&switch_body_seq, new_default);
1561             }
1562         }
1563
1564       gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
1565                                                default_case, labels);
1566       gimplify_seq_add_stmt (pre_p, gimple_switch);
1567       gimplify_seq_add_seq (pre_p, switch_body_seq);
1568       VEC_free(tree, heap, labels);
1569     }
1570   else
1571     gcc_assert (SWITCH_LABELS (switch_expr));
1572
1573   return GS_ALL_DONE;
1574 }
1575
1576
1577 static enum gimplify_status
1578 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
1579 {
1580   struct gimplify_ctx *ctxp;
1581   gimple gimple_label;
1582
1583   /* Invalid OpenMP programs can play Duff's Device type games with
1584      #pragma omp parallel.  At least in the C front end, we don't
1585      detect such invalid branches until after gimplification.  */
1586   for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1587     if (ctxp->case_labels)
1588       break;
1589
1590   gimple_label = gimple_build_label (CASE_LABEL (*expr_p));
1591   VEC_safe_push (tree, heap, ctxp->case_labels, *expr_p);
1592   gimplify_seq_add_stmt (pre_p, gimple_label);
1593
1594   return GS_ALL_DONE;
1595 }
1596
1597 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1598    if necessary.  */
1599
1600 tree
1601 build_and_jump (tree *label_p)
1602 {
1603   if (label_p == NULL)
1604     /* If there's nowhere to jump, just fall through.  */
1605     return NULL_TREE;
1606
1607   if (*label_p == NULL_TREE)
1608     {
1609       tree label = create_artificial_label (UNKNOWN_LOCATION);
1610       *label_p = label;
1611     }
1612
1613   return build1 (GOTO_EXPR, void_type_node, *label_p);
1614 }
1615
1616 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1617    This also involves building a label to jump to and communicating it to
1618    gimplify_loop_expr through gimplify_ctxp->exit_label.  */
1619
1620 static enum gimplify_status
1621 gimplify_exit_expr (tree *expr_p)
1622 {
1623   tree cond = TREE_OPERAND (*expr_p, 0);
1624   tree expr;
1625
1626   expr = build_and_jump (&gimplify_ctxp->exit_label);
1627   expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1628   *expr_p = expr;
1629
1630   return GS_OK;
1631 }
1632
1633 /* A helper function to be called via walk_tree.  Mark all labels under *TP
1634    as being forced.  To be called for DECL_INITIAL of static variables.  */
1635
1636 tree
1637 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1638 {
1639   if (TYPE_P (*tp))
1640     *walk_subtrees = 0;
1641   if (TREE_CODE (*tp) == LABEL_DECL)
1642     FORCED_LABEL (*tp) = 1;
1643
1644   return NULL_TREE;
1645 }
1646
1647 /* *EXPR_P is a COMPONENT_REF being used as an rvalue.  If its type is
1648    different from its canonical type, wrap the whole thing inside a
1649    NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1650    type.
1651
1652    The canonical type of a COMPONENT_REF is the type of the field being
1653    referenced--unless the field is a bit-field which can be read directly
1654    in a smaller mode, in which case the canonical type is the
1655    sign-appropriate type corresponding to that mode.  */
1656
1657 static void
1658 canonicalize_component_ref (tree *expr_p)
1659 {
1660   tree expr = *expr_p;
1661   tree type;
1662
1663   gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1664
1665   if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1666     type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1667   else
1668     type = TREE_TYPE (TREE_OPERAND (expr, 1));
1669
1670   /* One could argue that all the stuff below is not necessary for
1671      the non-bitfield case and declare it a FE error if type
1672      adjustment would be needed.  */
1673   if (TREE_TYPE (expr) != type)
1674     {
1675 #ifdef ENABLE_TYPES_CHECKING
1676       tree old_type = TREE_TYPE (expr);
1677 #endif
1678       int type_quals;
1679
1680       /* We need to preserve qualifiers and propagate them from
1681          operand 0.  */
1682       type_quals = TYPE_QUALS (type)
1683         | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1684       if (TYPE_QUALS (type) != type_quals)
1685         type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1686
1687       /* Set the type of the COMPONENT_REF to the underlying type.  */
1688       TREE_TYPE (expr) = type;
1689
1690 #ifdef ENABLE_TYPES_CHECKING
1691       /* It is now a FE error, if the conversion from the canonical
1692          type to the original expression type is not useless.  */
1693       gcc_assert (useless_type_conversion_p (old_type, type));
1694 #endif
1695     }
1696 }
1697
1698 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1699    to foo, embed that change in the ADDR_EXPR by converting
1700       T array[U];
1701       (T *)&array
1702    ==>
1703       &array[L]
1704    where L is the lower bound.  For simplicity, only do this for constant
1705    lower bound.
1706    The constraint is that the type of &array[L] is trivially convertible
1707    to T *.  */
1708
1709 static void
1710 canonicalize_addr_expr (tree *expr_p)
1711 {
1712   tree expr = *expr_p;
1713   tree addr_expr = TREE_OPERAND (expr, 0);
1714   tree datype, ddatype, pddatype;
1715
1716   /* We simplify only conversions from an ADDR_EXPR to a pointer type.  */
1717   if (!POINTER_TYPE_P (TREE_TYPE (expr))
1718       || TREE_CODE (addr_expr) != ADDR_EXPR)
1719     return;
1720
1721   /* The addr_expr type should be a pointer to an array.  */
1722   datype = TREE_TYPE (TREE_TYPE (addr_expr));
1723   if (TREE_CODE (datype) != ARRAY_TYPE)
1724     return;
1725
1726   /* The pointer to element type shall be trivially convertible to
1727      the expression pointer type.  */
1728   ddatype = TREE_TYPE (datype);
1729   pddatype = build_pointer_type (ddatype);
1730   if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
1731                                   pddatype))
1732     return;
1733
1734   /* The lower bound and element sizes must be constant.  */
1735   if (!TYPE_SIZE_UNIT (ddatype)
1736       || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1737       || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1738       || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1739     return;
1740
1741   /* All checks succeeded.  Build a new node to merge the cast.  */
1742   *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1743                     TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1744                     NULL_TREE, NULL_TREE);
1745   *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1746
1747   /* We can have stripped a required restrict qualifier above.  */
1748   if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
1749     *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
1750 }
1751
1752 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR.  Remove it and/or other conversions
1753    underneath as appropriate.  */
1754
1755 static enum gimplify_status
1756 gimplify_conversion (tree *expr_p)
1757 {
1758   tree tem;
1759   location_t loc = EXPR_LOCATION (*expr_p);
1760   gcc_assert (CONVERT_EXPR_P (*expr_p));
1761
1762   /* Then strip away all but the outermost conversion.  */
1763   STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1764
1765   /* And remove the outermost conversion if it's useless.  */
1766   if (tree_ssa_useless_type_conversion (*expr_p))
1767     *expr_p = TREE_OPERAND (*expr_p, 0);
1768
1769   /* Attempt to avoid NOP_EXPR by producing reference to a subtype.
1770      For example this fold (subclass *)&A into &A->subclass avoiding
1771      a need for statement.  */
1772   if (CONVERT_EXPR_P (*expr_p)
1773       && POINTER_TYPE_P (TREE_TYPE (*expr_p))
1774       && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0)))
1775       && (tem = maybe_fold_offset_to_address
1776           (EXPR_LOCATION (*expr_p), TREE_OPERAND (*expr_p, 0),
1777            integer_zero_node, TREE_TYPE (*expr_p))) != NULL_TREE)
1778     *expr_p = tem;
1779
1780   /* If we still have a conversion at the toplevel,
1781      then canonicalize some constructs.  */
1782   if (CONVERT_EXPR_P (*expr_p))
1783     {
1784       tree sub = TREE_OPERAND (*expr_p, 0);
1785
1786       /* If a NOP conversion is changing the type of a COMPONENT_REF
1787          expression, then canonicalize its type now in order to expose more
1788          redundant conversions.  */
1789       if (TREE_CODE (sub) == COMPONENT_REF)
1790         canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1791
1792       /* If a NOP conversion is changing a pointer to array of foo
1793          to a pointer to foo, embed that change in the ADDR_EXPR.  */
1794       else if (TREE_CODE (sub) == ADDR_EXPR)
1795         canonicalize_addr_expr (expr_p);
1796     }
1797
1798   /* If we have a conversion to a non-register type force the
1799      use of a VIEW_CONVERT_EXPR instead.  */
1800   if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
1801     *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
1802                                TREE_OPERAND (*expr_p, 0));
1803
1804   return GS_OK;
1805 }
1806
1807 /* Nonlocal VLAs seen in the current function.  */
1808 static struct pointer_set_t *nonlocal_vlas;
1809
1810 /* Gimplify a VAR_DECL or PARM_DECL.  Returns GS_OK if we expanded a
1811    DECL_VALUE_EXPR, and it's worth re-examining things.  */
1812
1813 static enum gimplify_status
1814 gimplify_var_or_parm_decl (tree *expr_p)
1815 {
1816   tree decl = *expr_p;
1817
1818   /* ??? If this is a local variable, and it has not been seen in any
1819      outer BIND_EXPR, then it's probably the result of a duplicate
1820      declaration, for which we've already issued an error.  It would
1821      be really nice if the front end wouldn't leak these at all.
1822      Currently the only known culprit is C++ destructors, as seen
1823      in g++.old-deja/g++.jason/binding.C.  */
1824   if (TREE_CODE (decl) == VAR_DECL
1825       && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1826       && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1827       && decl_function_context (decl) == current_function_decl)
1828     {
1829       gcc_assert (errorcount || sorrycount);
1830       return GS_ERROR;
1831     }
1832
1833   /* When within an OpenMP context, notice uses of variables.  */
1834   if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1835     return GS_ALL_DONE;
1836
1837   /* If the decl is an alias for another expression, substitute it now.  */
1838   if (DECL_HAS_VALUE_EXPR_P (decl))
1839     {
1840       tree value_expr = DECL_VALUE_EXPR (decl);
1841
1842       /* For referenced nonlocal VLAs add a decl for debugging purposes
1843          to the current function.  */
1844       if (TREE_CODE (decl) == VAR_DECL
1845           && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1846           && nonlocal_vlas != NULL
1847           && TREE_CODE (value_expr) == INDIRECT_REF
1848           && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
1849           && decl_function_context (decl) != current_function_decl)
1850         {
1851           struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1852           while (ctx && ctx->region_type == ORT_WORKSHARE)
1853             ctx = ctx->outer_context;
1854           if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
1855             {
1856               tree copy = copy_node (decl), block;
1857
1858               lang_hooks.dup_lang_specific_decl (copy);
1859               SET_DECL_RTL (copy, NULL_RTX);
1860               TREE_USED (copy) = 1;
1861               block = DECL_INITIAL (current_function_decl);
1862               TREE_CHAIN (copy) = BLOCK_VARS (block);
1863               BLOCK_VARS (block) = copy;
1864               SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
1865               DECL_HAS_VALUE_EXPR_P (copy) = 1;
1866             }
1867         }
1868
1869       *expr_p = unshare_expr (value_expr);
1870       return GS_OK;
1871     }
1872
1873   return GS_ALL_DONE;
1874 }
1875
1876
1877 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1878    node *EXPR_P.
1879
1880       compound_lval
1881               : min_lval '[' val ']'
1882               | min_lval '.' ID
1883               | compound_lval '[' val ']'
1884               | compound_lval '.' ID
1885
1886    This is not part of the original SIMPLE definition, which separates
1887    array and member references, but it seems reasonable to handle them
1888    together.  Also, this way we don't run into problems with union
1889    aliasing; gcc requires that for accesses through a union to alias, the
1890    union reference must be explicit, which was not always the case when we
1891    were splitting up array and member refs.
1892
1893    PRE_P points to the sequence where side effects that must happen before
1894      *EXPR_P should be stored.
1895
1896    POST_P points to the sequence where side effects that must happen after
1897      *EXPR_P should be stored.  */
1898
1899 static enum gimplify_status
1900 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
1901                         fallback_t fallback)
1902 {
1903   tree *p;
1904   VEC(tree,heap) *stack;
1905   enum gimplify_status ret = GS_OK, tret;
1906   int i;
1907   location_t loc = EXPR_LOCATION (*expr_p);
1908
1909   /* Create a stack of the subexpressions so later we can walk them in
1910      order from inner to outer.  */
1911   stack = VEC_alloc (tree, heap, 10);
1912
1913   /* We can handle anything that get_inner_reference can deal with.  */
1914   for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
1915     {
1916     restart:
1917       /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs.  */
1918       if (TREE_CODE (*p) == INDIRECT_REF)
1919         *p = fold_indirect_ref_loc (loc, *p);
1920
1921       if (handled_component_p (*p))
1922         ;
1923       /* Expand DECL_VALUE_EXPR now.  In some cases that may expose
1924          additional COMPONENT_REFs.  */
1925       else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
1926                && gimplify_var_or_parm_decl (p) == GS_OK)
1927         goto restart;
1928       else
1929         break;
1930
1931       VEC_safe_push (tree, heap, stack, *p);
1932     }
1933
1934   gcc_assert (VEC_length (tree, stack));
1935
1936   /* Now STACK is a stack of pointers to all the refs we've walked through
1937      and P points to the innermost expression.
1938
1939      Java requires that we elaborated nodes in source order.  That
1940      means we must gimplify the inner expression followed by each of
1941      the indices, in order.  But we can't gimplify the inner
1942      expression until we deal with any variable bounds, sizes, or
1943      positions in order to deal with PLACEHOLDER_EXPRs.
1944
1945      So we do this in three steps.  First we deal with the annotations
1946      for any variables in the components, then we gimplify the base,
1947      then we gimplify any indices, from left to right.  */
1948   for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
1949     {
1950       tree t = VEC_index (tree, stack, i);
1951
1952       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1953         {
1954           /* Gimplify the low bound and element type size and put them into
1955              the ARRAY_REF.  If these values are set, they have already been
1956              gimplified.  */
1957           if (TREE_OPERAND (t, 2) == NULL_TREE)
1958             {
1959               tree low = unshare_expr (array_ref_low_bound (t));
1960               if (!is_gimple_min_invariant (low))
1961                 {
1962                   TREE_OPERAND (t, 2) = low;
1963                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
1964                                         post_p, is_gimple_reg,
1965                                         fb_rvalue);
1966                   ret = MIN (ret, tret);
1967                 }
1968             }
1969
1970           if (!TREE_OPERAND (t, 3))
1971             {
1972               tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1973               tree elmt_size = unshare_expr (array_ref_element_size (t));
1974               tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
1975
1976               /* Divide the element size by the alignment of the element
1977                  type (above).  */
1978               elmt_size = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
1979
1980               if (!is_gimple_min_invariant (elmt_size))
1981                 {
1982                   TREE_OPERAND (t, 3) = elmt_size;
1983                   tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
1984                                         post_p, is_gimple_reg,
1985                                         fb_rvalue);
1986                   ret = MIN (ret, tret);
1987                 }
1988             }
1989         }
1990       else if (TREE_CODE (t) == COMPONENT_REF)
1991         {
1992           /* Set the field offset into T and gimplify it.  */
1993           if (!TREE_OPERAND (t, 2))
1994             {
1995               tree offset = unshare_expr (component_ref_field_offset (t));
1996               tree field = TREE_OPERAND (t, 1);
1997               tree factor
1998                 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
1999
2000               /* Divide the offset by its alignment.  */
2001               offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2002
2003               if (!is_gimple_min_invariant (offset))
2004                 {
2005                   TREE_OPERAND (t, 2) = offset;
2006                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2007                                         post_p, is_gimple_reg,
2008                                         fb_rvalue);
2009                   ret = MIN (ret, tret);
2010                 }
2011             }
2012         }
2013     }
2014
2015   /* Step 2 is to gimplify the base expression.  Make sure lvalue is set
2016      so as to match the min_lval predicate.  Failure to do so may result
2017      in the creation of large aggregate temporaries.  */
2018   tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2019                         fallback | fb_lvalue);
2020   ret = MIN (ret, tret);
2021
2022   /* And finally, the indices and operands to BIT_FIELD_REF.  During this
2023      loop we also remove any useless conversions.  */
2024   for (; VEC_length (tree, stack) > 0; )
2025     {
2026       tree t = VEC_pop (tree, stack);
2027
2028       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2029         {
2030           /* Gimplify the dimension.  */
2031           if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2032             {
2033               tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2034                                     is_gimple_val, fb_rvalue);
2035               ret = MIN (ret, tret);
2036             }
2037         }
2038       else if (TREE_CODE (t) == BIT_FIELD_REF)
2039         {
2040           tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2041                                 is_gimple_val, fb_rvalue);
2042           ret = MIN (ret, tret);
2043           tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2044                                 is_gimple_val, fb_rvalue);
2045           ret = MIN (ret, tret);
2046         }
2047
2048       STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2049
2050       /* The innermost expression P may have originally had
2051          TREE_SIDE_EFFECTS set which would have caused all the outer
2052          expressions in *EXPR_P leading to P to also have had
2053          TREE_SIDE_EFFECTS set.  */
2054       recalculate_side_effects (t);
2055     }
2056
2057   /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
2058   if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2059     {
2060       canonicalize_component_ref (expr_p);
2061       ret = MIN (ret, GS_OK);
2062     }
2063
2064   VEC_free (tree, heap, stack);
2065
2066   return ret;
2067 }
2068
2069 /*  Gimplify the self modifying expression pointed to by EXPR_P
2070     (++, --, +=, -=).
2071
2072     PRE_P points to the list where side effects that must happen before
2073         *EXPR_P should be stored.
2074
2075     POST_P points to the list where side effects that must happen after
2076         *EXPR_P should be stored.
2077
2078     WANT_VALUE is nonzero iff we want to use the value of this expression
2079         in another expression.  */
2080
2081 static enum gimplify_status
2082 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2083                         bool want_value)
2084 {
2085   enum tree_code code;
2086   tree lhs, lvalue, rhs, t1;
2087   gimple_seq post = NULL, *orig_post_p = post_p;
2088   bool postfix;
2089   enum tree_code arith_code;
2090   enum gimplify_status ret;
2091   location_t loc = EXPR_LOCATION (*expr_p);
2092
2093   code = TREE_CODE (*expr_p);
2094
2095   gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2096               || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2097
2098   /* Prefix or postfix?  */
2099   if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2100     /* Faster to treat as prefix if result is not used.  */
2101     postfix = want_value;
2102   else
2103     postfix = false;
2104
2105   /* For postfix, make sure the inner expression's post side effects
2106      are executed after side effects from this expression.  */
2107   if (postfix)
2108     post_p = &post;
2109
2110   /* Add or subtract?  */
2111   if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2112     arith_code = PLUS_EXPR;
2113   else
2114     arith_code = MINUS_EXPR;
2115
2116   /* Gimplify the LHS into a GIMPLE lvalue.  */
2117   lvalue = TREE_OPERAND (*expr_p, 0);
2118   ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2119   if (ret == GS_ERROR)
2120     return ret;
2121
2122   /* Extract the operands to the arithmetic operation.  */
2123   lhs = lvalue;
2124   rhs = TREE_OPERAND (*expr_p, 1);
2125
2126   /* For postfix operator, we evaluate the LHS to an rvalue and then use
2127      that as the result value and in the postqueue operation.  We also
2128      make sure to make lvalue a minimal lval, see
2129      gcc.c-torture/execute/20040313-1.c for an example where this matters.  */
2130   if (postfix)
2131     {
2132       if (!is_gimple_min_lval (lvalue))
2133         {
2134           mark_addressable (lvalue);
2135           lvalue = build_fold_addr_expr_loc (input_location, lvalue);
2136           gimplify_expr (&lvalue, pre_p, post_p, is_gimple_val, fb_rvalue);
2137           lvalue = build_fold_indirect_ref_loc (input_location, lvalue);
2138         }
2139       ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2140       if (ret == GS_ERROR)
2141         return ret;
2142     }
2143
2144   /* For POINTERs increment, use POINTER_PLUS_EXPR.  */
2145   if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2146     {
2147       rhs = fold_convert_loc (loc, sizetype, rhs);
2148       if (arith_code == MINUS_EXPR)
2149         rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2150       arith_code = POINTER_PLUS_EXPR;
2151     }
2152
2153   t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
2154
2155   if (postfix)
2156     {
2157       gimplify_assign (lvalue, t1, orig_post_p);
2158       gimplify_seq_add_seq (orig_post_p, post);
2159       *expr_p = lhs;
2160       return GS_ALL_DONE;
2161     }
2162   else
2163     {
2164       *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2165       return GS_OK;
2166     }
2167 }
2168
2169
2170 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR.  */
2171
2172 static void
2173 maybe_with_size_expr (tree *expr_p)
2174 {
2175   tree expr = *expr_p;
2176   tree type = TREE_TYPE (expr);
2177   tree size;
2178
2179   /* If we've already wrapped this or the type is error_mark_node, we can't do
2180      anything.  */
2181   if (TREE_CODE (expr) == WITH_SIZE_EXPR
2182       || type == error_mark_node)
2183     return;
2184
2185   /* If the size isn't known or is a constant, we have nothing to do.  */
2186   size = TYPE_SIZE_UNIT (type);
2187   if (!size || TREE_CODE (size) == INTEGER_CST)
2188     return;
2189
2190   /* Otherwise, make a WITH_SIZE_EXPR.  */
2191   size = unshare_expr (size);
2192   size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2193   *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2194 }
2195
2196
2197 /* Helper for gimplify_call_expr.  Gimplify a single argument *ARG_P
2198    Store any side-effects in PRE_P.  CALL_LOCATION is the location of
2199    the CALL_EXPR.  */
2200
2201 static enum gimplify_status
2202 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location)
2203 {
2204   bool (*test) (tree);
2205   fallback_t fb;
2206
2207   /* In general, we allow lvalues for function arguments to avoid
2208      extra overhead of copying large aggregates out of even larger
2209      aggregates into temporaries only to copy the temporaries to
2210      the argument list.  Make optimizers happy by pulling out to
2211      temporaries those types that fit in registers.  */
2212   if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2213     test = is_gimple_val, fb = fb_rvalue;
2214   else
2215     test = is_gimple_lvalue, fb = fb_either;
2216
2217   /* If this is a variable sized type, we must remember the size.  */
2218   maybe_with_size_expr (arg_p);
2219
2220   /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c.  */
2221   /* Make sure arguments have the same location as the function call
2222      itself.  */
2223   protected_set_expr_location (*arg_p, call_location);
2224
2225   /* There is a sequence point before a function call.  Side effects in
2226      the argument list must occur before the actual call. So, when
2227      gimplifying arguments, force gimplify_expr to use an internal
2228      post queue which is then appended to the end of PRE_P.  */
2229   return gimplify_expr (arg_p, pre_p, NULL, test, fb);
2230 }
2231
2232
2233 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2234    WANT_VALUE is true if the result of the call is desired.  */
2235
2236 static enum gimplify_status
2237 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2238 {
2239   tree fndecl, parms, p;
2240   enum gimplify_status ret;
2241   int i, nargs;
2242   gimple call;
2243   bool builtin_va_start_p = FALSE;
2244   location_t loc = EXPR_LOCATION (*expr_p);
2245
2246   gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2247
2248   /* For reliable diagnostics during inlining, it is necessary that
2249      every call_expr be annotated with file and line.  */
2250   if (! EXPR_HAS_LOCATION (*expr_p))
2251     SET_EXPR_LOCATION (*expr_p, input_location);
2252
2253   /* This may be a call to a builtin function.
2254
2255      Builtin function calls may be transformed into different
2256      (and more efficient) builtin function calls under certain
2257      circumstances.  Unfortunately, gimplification can muck things
2258      up enough that the builtin expanders are not aware that certain
2259      transformations are still valid.
2260
2261      So we attempt transformation/gimplification of the call before
2262      we gimplify the CALL_EXPR.  At this time we do not manage to
2263      transform all calls in the same manner as the expanders do, but
2264      we do transform most of them.  */
2265   fndecl = get_callee_fndecl (*expr_p);
2266   if (fndecl && DECL_BUILT_IN (fndecl))
2267     {
2268       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2269
2270       if (new_tree && new_tree != *expr_p)
2271         {
2272           /* There was a transformation of this call which computes the
2273              same value, but in a more efficient way.  Return and try
2274              again.  */
2275           *expr_p = new_tree;
2276           return GS_OK;
2277         }
2278
2279       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2280           && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
2281         {
2282           builtin_va_start_p = TRUE;
2283           if (call_expr_nargs (*expr_p) < 2)
2284             {
2285               error ("too few arguments to function %<va_start%>");
2286               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2287               return GS_OK;
2288             }
2289
2290           if (fold_builtin_next_arg (*expr_p, true))
2291             {
2292               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2293               return GS_OK;
2294             }
2295         }
2296     }
2297
2298   /* There is a sequence point before the call, so any side effects in
2299      the calling expression must occur before the actual call.  Force
2300      gimplify_expr to use an internal post queue.  */
2301   ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2302                        is_gimple_call_addr, fb_rvalue);
2303
2304   nargs = call_expr_nargs (*expr_p);
2305
2306   /* Get argument types for verification.  */
2307   fndecl = get_callee_fndecl (*expr_p);
2308   parms = NULL_TREE;
2309   if (fndecl)
2310     parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2311   else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2312     parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2313
2314   if (fndecl && DECL_ARGUMENTS (fndecl))
2315     p = DECL_ARGUMENTS (fndecl);
2316   else if (parms)
2317     p = parms;
2318   else
2319     p = NULL_TREE;
2320   for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2321     ;
2322
2323   /* If the last argument is __builtin_va_arg_pack () and it is not
2324      passed as a named argument, decrease the number of CALL_EXPR
2325      arguments and set instead the CALL_EXPR_VA_ARG_PACK flag.  */
2326   if (!p
2327       && i < nargs
2328       && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2329     {
2330       tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2331       tree last_arg_fndecl = get_callee_fndecl (last_arg);
2332
2333       if (last_arg_fndecl
2334           && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2335           && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2336           && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2337         {
2338           tree call = *expr_p;
2339
2340           --nargs;
2341           *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
2342                                           CALL_EXPR_FN (call),
2343                                           nargs, CALL_EXPR_ARGP (call));
2344
2345           /* Copy all CALL_EXPR flags, location and block, except
2346              CALL_EXPR_VA_ARG_PACK flag.  */
2347           CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2348           CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2349           CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2350             = CALL_EXPR_RETURN_SLOT_OPT (call);
2351           CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2352           CALL_CANNOT_INLINE_P (*expr_p) = CALL_CANNOT_INLINE_P (call);
2353           SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
2354           TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2355
2356           /* Set CALL_EXPR_VA_ARG_PACK.  */
2357           CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2358         }
2359     }
2360
2361   /* Finally, gimplify the function arguments.  */
2362   if (nargs > 0)
2363     {
2364       for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2365            PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2366            PUSH_ARGS_REVERSED ? i-- : i++)
2367         {
2368           enum gimplify_status t;
2369
2370           /* Avoid gimplifying the second argument to va_start, which needs to
2371              be the plain PARM_DECL.  */
2372           if ((i != 1) || !builtin_va_start_p)
2373             {
2374               t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2375                                 EXPR_LOCATION (*expr_p));
2376
2377               if (t == GS_ERROR)
2378                 ret = GS_ERROR;
2379             }
2380         }
2381     }
2382
2383   /* Verify the function result.  */
2384   if (want_value && fndecl
2385       && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl))))
2386     {
2387       error_at (loc, "using result of function returning %<void%>");
2388       ret = GS_ERROR;
2389     }
2390
2391   /* Try this again in case gimplification exposed something.  */
2392   if (ret != GS_ERROR)
2393     {
2394       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2395
2396       if (new_tree && new_tree != *expr_p)
2397         {
2398           /* There was a transformation of this call which computes the
2399              same value, but in a more efficient way.  Return and try
2400              again.  */
2401           *expr_p = new_tree;
2402           return GS_OK;
2403         }
2404     }
2405   else
2406     {
2407       *expr_p = error_mark_node;
2408       return GS_ERROR;
2409     }
2410
2411   /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2412      decl.  This allows us to eliminate redundant or useless
2413      calls to "const" functions.  */
2414   if (TREE_CODE (*expr_p) == CALL_EXPR)
2415     {
2416       int flags = call_expr_flags (*expr_p);
2417       if (flags & (ECF_CONST | ECF_PURE)
2418           /* An infinite loop is considered a side effect.  */
2419           && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2420         TREE_SIDE_EFFECTS (*expr_p) = 0;
2421     }
2422
2423   /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2424      and clear *EXPR_P.  Otherwise, leave *EXPR_P in its gimplified
2425      form and delegate the creation of a GIMPLE_CALL to
2426      gimplify_modify_expr.  This is always possible because when
2427      WANT_VALUE is true, the caller wants the result of this call into
2428      a temporary, which means that we will emit an INIT_EXPR in
2429      internal_get_tmp_var which will then be handled by
2430      gimplify_modify_expr.  */
2431   if (!want_value)
2432     {
2433       /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2434          have to do is replicate it as a GIMPLE_CALL tuple.  */
2435       call = gimple_build_call_from_tree (*expr_p);
2436       gimplify_seq_add_stmt (pre_p, call);
2437       *expr_p = NULL_TREE;
2438     }
2439
2440   return ret;
2441 }
2442
2443 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2444    rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2445
2446    TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2447    condition is true or false, respectively.  If null, we should generate
2448    our own to skip over the evaluation of this specific expression.
2449
2450    LOCUS is the source location of the COND_EXPR.
2451
2452    This function is the tree equivalent of do_jump.
2453
2454    shortcut_cond_r should only be called by shortcut_cond_expr.  */
2455
2456 static tree
2457 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
2458                  location_t locus)
2459 {
2460   tree local_label = NULL_TREE;
2461   tree t, expr = NULL;
2462
2463   /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2464      retain the shortcut semantics.  Just insert the gotos here;
2465      shortcut_cond_expr will append the real blocks later.  */
2466   if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2467     {
2468       location_t new_locus;
2469
2470       /* Turn if (a && b) into
2471
2472          if (a); else goto no;
2473          if (b) goto yes; else goto no;
2474          (no:) */
2475
2476       if (false_label_p == NULL)
2477         false_label_p = &local_label;
2478
2479       /* Keep the original source location on the first 'if'.  */
2480       t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
2481       append_to_statement_list (t, &expr);
2482
2483       /* Set the source location of the && on the second 'if'.  */
2484       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2485       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2486                            new_locus);
2487       append_to_statement_list (t, &expr);
2488     }
2489   else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2490     {
2491       location_t new_locus;
2492
2493       /* Turn if (a || b) into
2494
2495          if (a) goto yes;
2496          if (b) goto yes; else goto no;
2497          (yes:) */
2498
2499       if (true_label_p == NULL)
2500         true_label_p = &local_label;
2501
2502       /* Keep the original source location on the first 'if'.  */
2503       t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
2504       append_to_statement_list (t, &expr);
2505
2506       /* Set the source location of the || on the second 'if'.  */
2507       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2508       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2509                            new_locus);
2510       append_to_statement_list (t, &expr);
2511     }
2512   else if (TREE_CODE (pred) == COND_EXPR)
2513     {
2514       location_t new_locus;
2515
2516       /* As long as we're messing with gotos, turn if (a ? b : c) into
2517          if (a)
2518            if (b) goto yes; else goto no;
2519          else
2520            if (c) goto yes; else goto no;  */
2521
2522       /* Keep the original source location on the first 'if'.  Set the source
2523          location of the ? on the second 'if'.  */
2524       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2525       expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2526                      shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2527                                       false_label_p, locus),
2528                      shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2529                                       false_label_p, new_locus));
2530     }
2531   else
2532     {
2533       expr = build3 (COND_EXPR, void_type_node, pred,
2534                      build_and_jump (true_label_p),
2535                      build_and_jump (false_label_p));
2536       SET_EXPR_LOCATION (expr, locus);
2537     }
2538
2539   if (local_label)
2540     {
2541       t = build1 (LABEL_EXPR, void_type_node, local_label);
2542       append_to_statement_list (t, &expr);
2543     }
2544
2545   return expr;
2546 }
2547
2548 /* Given a conditional expression EXPR with short-circuit boolean
2549    predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2550    predicate appart into the equivalent sequence of conditionals.  */
2551
2552 static tree
2553 shortcut_cond_expr (tree expr)
2554 {
2555   tree pred = TREE_OPERAND (expr, 0);
2556   tree then_ = TREE_OPERAND (expr, 1);
2557   tree else_ = TREE_OPERAND (expr, 2);
2558   tree true_label, false_label, end_label, t;
2559   tree *true_label_p;
2560   tree *false_label_p;
2561   bool emit_end, emit_false, jump_over_else;
2562   bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2563   bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2564
2565   /* First do simple transformations.  */
2566   if (!else_se)
2567     {
2568       /* If there is no 'else', turn
2569            if (a && b) then c
2570          into
2571            if (a) if (b) then c.  */
2572       while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2573         {
2574           /* Keep the original source location on the first 'if'.  */
2575           location_t locus = EXPR_HAS_LOCATION (expr)
2576                              ? EXPR_LOCATION (expr) : input_location;
2577           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2578           /* Set the source location of the && on the second 'if'.  */
2579           if (EXPR_HAS_LOCATION (pred))
2580             SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2581           then_ = shortcut_cond_expr (expr);
2582           then_se = then_ && TREE_SIDE_EFFECTS (then_);
2583           pred = TREE_OPERAND (pred, 0);
2584           expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2585           SET_EXPR_LOCATION (expr, locus);
2586         }
2587     }
2588
2589   if (!then_se)
2590     {
2591       /* If there is no 'then', turn
2592            if (a || b); else d
2593          into
2594            if (a); else if (b); else d.  */
2595       while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2596         {
2597           /* Keep the original source location on the first 'if'.  */
2598           location_t locus = EXPR_HAS_LOCATION (expr)
2599                              ? EXPR_LOCATION (expr) : input_location;
2600           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2601           /* Set the source location of the || on the second 'if'.  */
2602           if (EXPR_HAS_LOCATION (pred))
2603             SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2604           else_ = shortcut_cond_expr (expr);
2605           else_se = else_ && TREE_SIDE_EFFECTS (else_);
2606           pred = TREE_OPERAND (pred, 0);
2607           expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2608           SET_EXPR_LOCATION (expr, locus);
2609         }
2610     }
2611
2612   /* If we're done, great.  */
2613   if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2614       && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2615     return expr;
2616
2617   /* Otherwise we need to mess with gotos.  Change
2618        if (a) c; else d;
2619      to
2620        if (a); else goto no;
2621        c; goto end;
2622        no: d; end:
2623      and recursively gimplify the condition.  */
2624
2625   true_label = false_label = end_label = NULL_TREE;
2626
2627   /* If our arms just jump somewhere, hijack those labels so we don't
2628      generate jumps to jumps.  */
2629
2630   if (then_
2631       && TREE_CODE (then_) == GOTO_EXPR
2632       && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2633     {
2634       true_label = GOTO_DESTINATION (then_);
2635       then_ = NULL;
2636       then_se = false;
2637     }
2638
2639   if (else_
2640       && TREE_CODE (else_) == GOTO_EXPR
2641       && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2642     {
2643       false_label = GOTO_DESTINATION (else_);
2644       else_ = NULL;
2645       else_se = false;
2646     }
2647
2648   /* If we aren't hijacking a label for the 'then' branch, it falls through.  */
2649   if (true_label)
2650     true_label_p = &true_label;
2651   else
2652     true_label_p = NULL;
2653
2654   /* The 'else' branch also needs a label if it contains interesting code.  */
2655   if (false_label || else_se)
2656     false_label_p = &false_label;
2657   else
2658     false_label_p = NULL;
2659
2660   /* If there was nothing else in our arms, just forward the label(s).  */
2661   if (!then_se && !else_se)
2662     return shortcut_cond_r (pred, true_label_p, false_label_p,
2663                             EXPR_HAS_LOCATION (expr)
2664                             ? EXPR_LOCATION (expr) : input_location);
2665
2666   /* If our last subexpression already has a terminal label, reuse it.  */
2667   if (else_se)
2668     t = expr_last (else_);
2669   else if (then_se)
2670     t = expr_last (then_);
2671   else
2672     t = NULL;
2673   if (t && TREE_CODE (t) == LABEL_EXPR)
2674     end_label = LABEL_EXPR_LABEL (t);
2675
2676   /* If we don't care about jumping to the 'else' branch, jump to the end
2677      if the condition is false.  */
2678   if (!false_label_p)
2679     false_label_p = &end_label;
2680
2681   /* We only want to emit these labels if we aren't hijacking them.  */
2682   emit_end = (end_label == NULL_TREE);
2683   emit_false = (false_label == NULL_TREE);
2684
2685   /* We only emit the jump over the else clause if we have to--if the
2686      then clause may fall through.  Otherwise we can wind up with a
2687      useless jump and a useless label at the end of gimplified code,
2688      which will cause us to think that this conditional as a whole
2689      falls through even if it doesn't.  If we then inline a function
2690      which ends with such a condition, that can cause us to issue an
2691      inappropriate warning about control reaching the end of a
2692      non-void function.  */
2693   jump_over_else = block_may_fallthru (then_);
2694
2695   pred = shortcut_cond_r (pred, true_label_p, false_label_p,
2696                           EXPR_HAS_LOCATION (expr)
2697                           ? EXPR_LOCATION (expr) : input_location);
2698
2699   expr = NULL;
2700   append_to_statement_list (pred, &expr);
2701
2702   append_to_statement_list (then_, &expr);
2703   if (else_se)
2704     {
2705       if (jump_over_else)
2706         {
2707           tree last = expr_last (expr);
2708           t = build_and_jump (&end_label);
2709           if (EXPR_HAS_LOCATION (last))
2710             SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
2711           append_to_statement_list (t, &expr);
2712         }
2713       if (emit_false)
2714         {
2715           t = build1 (LABEL_EXPR, void_type_node, false_label);
2716           append_to_statement_list (t, &expr);
2717         }
2718       append_to_statement_list (else_, &expr);
2719     }
2720   if (emit_end && end_label)
2721     {
2722       t = build1 (LABEL_EXPR, void_type_node, end_label);
2723       append_to_statement_list (t, &expr);
2724     }
2725
2726   return expr;
2727 }
2728
2729 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE.  */
2730
2731 tree
2732 gimple_boolify (tree expr)
2733 {
2734   tree type = TREE_TYPE (expr);
2735   location_t loc = EXPR_LOCATION (expr);
2736
2737   if (TREE_CODE (expr) == NE_EXPR
2738       && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
2739       && integer_zerop (TREE_OPERAND (expr, 1)))
2740     {
2741       tree call = TREE_OPERAND (expr, 0);
2742       tree fn = get_callee_fndecl (call);
2743
2744       /* For __builtin_expect ((long) (x), y) recurse into x as well
2745          if x is truth_value_p.  */
2746       if (fn
2747           && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2748           && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
2749           && call_expr_nargs (call) == 2)
2750         {
2751           tree arg = CALL_EXPR_ARG (call, 0);
2752           if (arg)
2753             {
2754               if (TREE_CODE (arg) == NOP_EXPR
2755                   && TREE_TYPE (arg) == TREE_TYPE (call))
2756                 arg = TREE_OPERAND (arg, 0);
2757               if (truth_value_p (TREE_CODE (arg)))
2758                 {
2759                   arg = gimple_boolify (arg);
2760                   CALL_EXPR_ARG (call, 0)
2761                     = fold_convert_loc (loc, TREE_TYPE (call), arg);
2762                 }
2763             }
2764         }
2765     }
2766
2767   if (TREE_CODE (type) == BOOLEAN_TYPE)
2768     return expr;
2769
2770   switch (TREE_CODE (expr))
2771     {
2772     case TRUTH_AND_EXPR:
2773     case TRUTH_OR_EXPR:
2774     case TRUTH_XOR_EXPR:
2775     case TRUTH_ANDIF_EXPR:
2776     case TRUTH_ORIF_EXPR:
2777       /* Also boolify the arguments of truth exprs.  */
2778       TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2779       /* FALLTHRU */
2780
2781     case TRUTH_NOT_EXPR:
2782       TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2783       /* FALLTHRU */
2784
2785     case EQ_EXPR: case NE_EXPR:
2786     case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2787       /* These expressions always produce boolean results.  */
2788       TREE_TYPE (expr) = boolean_type_node;
2789       return expr;
2790
2791     default:
2792       /* Other expressions that get here must have boolean values, but
2793          might need to be converted to the appropriate mode.  */
2794       return fold_convert_loc (loc, boolean_type_node, expr);
2795     }
2796 }
2797
2798 /* Given a conditional expression *EXPR_P without side effects, gimplify
2799    its operands.  New statements are inserted to PRE_P.  */
2800
2801 static enum gimplify_status
2802 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
2803 {
2804   tree expr = *expr_p, cond;
2805   enum gimplify_status ret, tret;
2806   enum tree_code code;
2807
2808   cond = gimple_boolify (COND_EXPR_COND (expr));
2809
2810   /* We need to handle && and || specially, as their gimplification
2811      creates pure cond_expr, thus leading to an infinite cycle otherwise.  */
2812   code = TREE_CODE (cond);
2813   if (code == TRUTH_ANDIF_EXPR)
2814     TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2815   else if (code == TRUTH_ORIF_EXPR)
2816     TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2817   ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
2818   COND_EXPR_COND (*expr_p) = cond;
2819
2820   tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2821                                    is_gimple_val, fb_rvalue);
2822   ret = MIN (ret, tret);
2823   tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2824                                    is_gimple_val, fb_rvalue);
2825
2826   return MIN (ret, tret);
2827 }
2828
2829 /* Returns true if evaluating EXPR could trap.
2830    EXPR is GENERIC, while tree_could_trap_p can be called
2831    only on GIMPLE.  */
2832
2833 static bool
2834 generic_expr_could_trap_p (tree expr)
2835 {
2836   unsigned i, n;
2837
2838   if (!expr || is_gimple_val (expr))
2839     return false;
2840
2841   if (!EXPR_P (expr) || tree_could_trap_p (expr))
2842     return true;
2843
2844   n = TREE_OPERAND_LENGTH (expr);
2845   for (i = 0; i < n; i++)
2846     if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
2847       return true;
2848
2849   return false;
2850 }
2851
2852 /*  Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2853     into
2854
2855     if (p)                      if (p)
2856       t1 = a;                     a;
2857     else                or      else
2858       t1 = b;                     b;
2859     t1;
2860
2861     The second form is used when *EXPR_P is of type void.
2862
2863     PRE_P points to the list where side effects that must happen before
2864       *EXPR_P should be stored.  */
2865
2866 static enum gimplify_status
2867 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
2868 {
2869   tree expr = *expr_p;
2870   tree type = TREE_TYPE (expr);
2871   location_t loc = EXPR_LOCATION (expr);
2872   tree tmp, arm1, arm2;
2873   enum gimplify_status ret;
2874   tree label_true, label_false, label_cont;
2875   bool have_then_clause_p, have_else_clause_p;
2876   gimple gimple_cond;
2877   enum tree_code pred_code;
2878   gimple_seq seq = NULL;
2879
2880   /* If this COND_EXPR has a value, copy the values into a temporary within
2881      the arms.  */
2882   if (!VOID_TYPE_P (type))
2883     {
2884       tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
2885       tree result;
2886
2887       /* If either an rvalue is ok or we do not require an lvalue, create the
2888          temporary.  But we cannot do that if the type is addressable.  */
2889       if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
2890           && !TREE_ADDRESSABLE (type))
2891         {
2892           if (gimplify_ctxp->allow_rhs_cond_expr
2893               /* If either branch has side effects or could trap, it can't be
2894                  evaluated unconditionally.  */
2895               && !TREE_SIDE_EFFECTS (then_)
2896               && !generic_expr_could_trap_p (then_)
2897               && !TREE_SIDE_EFFECTS (else_)
2898               && !generic_expr_could_trap_p (else_))
2899             return gimplify_pure_cond_expr (expr_p, pre_p);
2900
2901           tmp = create_tmp_var (type, "iftmp");
2902           result = tmp;
2903         }
2904
2905       /* Otherwise, only create and copy references to the values.  */
2906       else
2907         {
2908           type = build_pointer_type (type);
2909
2910           if (!VOID_TYPE_P (TREE_TYPE (then_)))
2911             then_ = build_fold_addr_expr_loc (loc, then_);
2912
2913           if (!VOID_TYPE_P (TREE_TYPE (else_)))
2914             else_ = build_fold_addr_expr_loc (loc, else_);
2915  
2916           expr
2917             = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
2918
2919           tmp = create_tmp_var (type, "iftmp");
2920           result = build_fold_indirect_ref_loc (loc, tmp);
2921         }
2922
2923       /* Build the new then clause, `tmp = then_;'.  But don't build the
2924          assignment if the value is void; in C++ it can be if it's a throw.  */
2925       if (!VOID_TYPE_P (TREE_TYPE (then_)))
2926         TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
2927
2928       /* Similarly, build the new else clause, `tmp = else_;'.  */
2929       if (!VOID_TYPE_P (TREE_TYPE (else_)))
2930         TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
2931
2932       TREE_TYPE (expr) = void_type_node;
2933       recalculate_side_effects (expr);
2934
2935       /* Move the COND_EXPR to the prequeue.  */
2936       gimplify_stmt (&expr, pre_p);
2937
2938       *expr_p = result;
2939       return GS_ALL_DONE;
2940     }
2941
2942   /* Make sure the condition has BOOLEAN_TYPE.  */
2943   TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2944
2945   /* Break apart && and || conditions.  */
2946   if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2947       || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2948     {
2949       expr = shortcut_cond_expr (expr);
2950
2951       if (expr != *expr_p)
2952         {
2953           *expr_p = expr;
2954
2955           /* We can't rely on gimplify_expr to re-gimplify the expanded
2956              form properly, as cleanups might cause the target labels to be
2957              wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
2958              set up a conditional context.  */
2959           gimple_push_condition ();
2960           gimplify_stmt (expr_p, &seq);
2961           gimple_pop_condition (pre_p);
2962           gimple_seq_add_seq (pre_p, seq);
2963
2964           return GS_ALL_DONE;
2965         }
2966     }
2967
2968   /* Now do the normal gimplification.  */
2969
2970   /* Gimplify condition.  */
2971   ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
2972                        fb_rvalue);
2973   if (ret == GS_ERROR)
2974     return GS_ERROR;
2975   gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
2976
2977   gimple_push_condition ();
2978
2979   have_then_clause_p = have_else_clause_p = false;
2980   if (TREE_OPERAND (expr, 1) != NULL
2981       && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
2982       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
2983       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
2984           == current_function_decl)
2985       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
2986          have different locations, otherwise we end up with incorrect
2987          location information on the branches.  */
2988       && (optimize
2989           || !EXPR_HAS_LOCATION (expr)
2990           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
2991           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
2992     {
2993       label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
2994       have_then_clause_p = true;
2995     }
2996   else
2997     label_true = create_artificial_label (UNKNOWN_LOCATION);
2998   if (TREE_OPERAND (expr, 2) != NULL
2999       && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
3000       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3001       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3002           == current_function_decl)
3003       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3004          have different locations, otherwise we end up with incorrect
3005          location information on the branches.  */
3006       && (optimize
3007           || !EXPR_HAS_LOCATION (expr)
3008           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3009           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3010     {
3011       label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3012       have_else_clause_p = true;
3013     }
3014   else
3015     label_false = create_artificial_label (UNKNOWN_LOCATION);
3016
3017   gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3018                                  &arm2);
3019
3020   gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
3021                                    label_false);
3022
3023   gimplify_seq_add_stmt (&seq, gimple_cond);
3024   label_cont = NULL_TREE;
3025   if (!have_then_clause_p)
3026     {
3027       /* For if (...) {} else { code; } put label_true after
3028          the else block.  */
3029       if (TREE_OPERAND (expr, 1) == NULL_TREE
3030           && !have_else_clause_p
3031           && TREE_OPERAND (expr, 2) != NULL_TREE)
3032         label_cont = label_true;
3033       else
3034         {
3035           gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3036           have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3037           /* For if (...) { code; } else {} or
3038              if (...) { code; } else goto label; or
3039              if (...) { code; return; } else { ... }
3040              label_cont isn't needed.  */
3041           if (!have_else_clause_p
3042               && TREE_OPERAND (expr, 2) != NULL_TREE
3043               && gimple_seq_may_fallthru (seq))
3044             {
3045               gimple g;
3046               label_cont = create_artificial_label (UNKNOWN_LOCATION);
3047
3048               g = gimple_build_goto (label_cont);
3049
3050               /* GIMPLE_COND's are very low level; they have embedded
3051                  gotos.  This particular embedded goto should not be marked
3052                  with the location of the original COND_EXPR, as it would
3053                  correspond to the COND_EXPR's condition, not the ELSE or the
3054                  THEN arms.  To avoid marking it with the wrong location, flag
3055                  it as "no location".  */
3056               gimple_set_do_not_emit_location (g);
3057
3058               gimplify_seq_add_stmt (&seq, g);
3059             }
3060         }
3061     }
3062   if (!have_else_clause_p)
3063     {
3064       gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3065       have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3066     }
3067   if (label_cont)
3068     gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3069
3070   gimple_pop_condition (pre_p);
3071   gimple_seq_add_seq (pre_p, seq);
3072
3073   if (ret == GS_ERROR)
3074     ; /* Do nothing.  */
3075   else if (have_then_clause_p || have_else_clause_p)
3076     ret = GS_ALL_DONE;
3077   else
3078     {
3079       /* Both arms are empty; replace the COND_EXPR with its predicate.  */
3080       expr = TREE_OPERAND (expr, 0);
3081       gimplify_stmt (&expr, pre_p);
3082     }
3083
3084   *expr_p = NULL;
3085   return ret;
3086 }
3087
3088 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3089    to be marked addressable.
3090
3091    We cannot rely on such an expression being directly markable if a temporary
3092    has been created by the gimplification.  In this case, we create another
3093    temporary and initialize it with a copy, which will become a store after we
3094    mark it addressable.  This can happen if the front-end passed us something
3095    that it could not mark addressable yet, like a Fortran pass-by-reference
3096    parameter (int) floatvar.  */
3097
3098 static void
3099 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
3100 {
3101   while (handled_component_p (*expr_p))
3102     expr_p = &TREE_OPERAND (*expr_p, 0);
3103   if (is_gimple_reg (*expr_p))
3104     *expr_p = get_initialized_tmp_var (*expr_p, seq_p, NULL);
3105 }
3106
3107 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3108    a call to __builtin_memcpy.  */
3109
3110 static enum gimplify_status
3111 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3112                                 gimple_seq *seq_p)
3113 {
3114   tree t, to, to_ptr, from, from_ptr;
3115   gimple gs;
3116   location_t loc = EXPR_LOCATION (*expr_p);
3117
3118   to = TREE_OPERAND (*expr_p, 0);
3119   from = TREE_OPERAND (*expr_p, 1);
3120
3121   /* Mark the RHS addressable.  Beware that it may not be possible to do so
3122      directly if a temporary has been created by the gimplification.  */
3123   prepare_gimple_addressable (&from, seq_p);
3124
3125   mark_addressable (from);
3126   from_ptr = build_fold_addr_expr_loc (loc, from);
3127   gimplify_arg (&from_ptr, seq_p, loc);
3128
3129   mark_addressable (to);
3130   to_ptr = build_fold_addr_expr_loc (loc, to);
3131   gimplify_arg (&to_ptr, seq_p, loc);
3132
3133   t = implicit_built_in_decls[BUILT_IN_MEMCPY];
3134
3135   gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3136
3137   if (want_value)
3138     {
3139       /* tmp = memcpy() */
3140       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3141       gimple_call_set_lhs (gs, t);
3142       gimplify_seq_add_stmt (seq_p, gs);
3143
3144       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3145       return GS_ALL_DONE;
3146     }
3147
3148   gimplify_seq_add_stmt (seq_p, gs);
3149   *expr_p = NULL;
3150   return GS_ALL_DONE;
3151 }
3152
3153 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3154    a call to __builtin_memset.  In this case we know that the RHS is
3155    a CONSTRUCTOR with an empty element list.  */
3156
3157 static enum gimplify_status
3158 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3159                                 gimple_seq *seq_p)
3160 {
3161   tree t, from, to, to_ptr;
3162   gimple gs;
3163   location_t loc = EXPR_LOCATION (*expr_p);
3164
3165   /* Assert our assumptions, to abort instead of producing wrong code
3166      silently if they are not met.  Beware that the RHS CONSTRUCTOR might
3167      not be immediately exposed.  */
3168   from = TREE_OPERAND (*expr_p, 1);
3169   if (TREE_CODE (from) == WITH_SIZE_EXPR)
3170     from = TREE_OPERAND (from, 0);
3171
3172   gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3173               && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
3174
3175   /* Now proceed.  */
3176   to = TREE_OPERAND (*expr_p, 0);
3177
3178   to_ptr = build_fold_addr_expr_loc (loc, to);
3179   gimplify_arg (&to_ptr, seq_p, loc);
3180   t = implicit_built_in_decls[BUILT_IN_MEMSET];
3181
3182   gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3183
3184   if (want_value)
3185     {
3186       /* tmp = memset() */
3187       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3188       gimple_call_set_lhs (gs, t);
3189       gimplify_seq_add_stmt (seq_p, gs);
3190
3191       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3192       return GS_ALL_DONE;
3193     }
3194
3195   gimplify_seq_add_stmt (seq_p, gs);
3196   *expr_p = NULL;
3197   return GS_ALL_DONE;
3198 }
3199
3200 /* A subroutine of gimplify_init_ctor_preeval.  Called via walk_tree,
3201    determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3202    assignment.  Returns non-null if we detect a potential overlap.  */
3203
3204 struct gimplify_init_ctor_preeval_data
3205 {
3206   /* The base decl of the lhs object.  May be NULL, in which case we
3207      have to assume the lhs is indirect.  */
3208   tree lhs_base_decl;
3209
3210   /* The alias set of the lhs object.  */
3211   alias_set_type lhs_alias_set;
3212 };
3213
3214 static tree
3215 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3216 {
3217   struct gimplify_init_ctor_preeval_data *data
3218     = (struct gimplify_init_ctor_preeval_data *) xdata;
3219   tree t = *tp;
3220
3221   /* If we find the base object, obviously we have overlap.  */
3222   if (data->lhs_base_decl == t)
3223     return t;
3224
3225   /* If the constructor component is indirect, determine if we have a
3226      potential overlap with the lhs.  The only bits of information we
3227      have to go on at this point are addressability and alias sets.  */
3228   if (TREE_CODE (t) == INDIRECT_REF
3229       && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3230       && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3231     return t;
3232
3233   /* If the constructor component is a call, determine if it can hide a
3234      potential overlap with the lhs through an INDIRECT_REF like above.  */
3235   if (TREE_CODE (t) == CALL_EXPR)
3236     {
3237       tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3238
3239       for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3240         if (POINTER_TYPE_P (TREE_VALUE (type))
3241             && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3242             && alias_sets_conflict_p (data->lhs_alias_set,
3243                                       get_alias_set
3244                                         (TREE_TYPE (TREE_VALUE (type)))))
3245           return t;
3246     }
3247
3248   if (IS_TYPE_OR_DECL_P (t))
3249     *walk_subtrees = 0;
3250   return NULL;
3251 }
3252
3253 /* A subroutine of gimplify_init_constructor.  Pre-evaluate EXPR,
3254    force values that overlap with the lhs (as described by *DATA)
3255    into temporaries.  */
3256
3257 static void
3258 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3259                             struct gimplify_init_ctor_preeval_data *data)
3260 {
3261   enum gimplify_status one;
3262
3263   /* If the value is constant, then there's nothing to pre-evaluate.  */
3264   if (TREE_CONSTANT (*expr_p))
3265     {
3266       /* Ensure it does not have side effects, it might contain a reference to
3267          the object we're initializing.  */
3268       gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3269       return;
3270     }
3271
3272   /* If the type has non-trivial constructors, we can't pre-evaluate.  */
3273   if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3274     return;
3275
3276   /* Recurse for nested constructors.  */
3277   if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3278     {
3279       unsigned HOST_WIDE_INT ix;
3280       constructor_elt *ce;
3281       VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
3282
3283       for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
3284         gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3285
3286       return;
3287     }
3288
3289   /* If this is a variable sized type, we must remember the size.  */
3290   maybe_with_size_expr (expr_p);
3291
3292   /* Gimplify the constructor element to something appropriate for the rhs
3293      of a MODIFY_EXPR.  Given that we know the LHS is an aggregate, we know
3294      the gimplifier will consider this a store to memory.  Doing this
3295      gimplification now means that we won't have to deal with complicated
3296      language-specific trees, nor trees like SAVE_EXPR that can induce
3297      exponential search behavior.  */
3298   one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3299   if (one == GS_ERROR)
3300     {
3301       *expr_p = NULL;
3302       return;
3303     }
3304
3305   /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3306      with the lhs, since "a = { .x=a }" doesn't make sense.  This will
3307      always be true for all scalars, since is_gimple_mem_rhs insists on a
3308      temporary variable for them.  */
3309   if (DECL_P (*expr_p))
3310     return;
3311
3312   /* If this is of variable size, we have no choice but to assume it doesn't
3313      overlap since we can't make a temporary for it.  */
3314   if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3315     return;
3316
3317   /* Otherwise, we must search for overlap ...  */
3318   if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3319     return;
3320
3321   /* ... and if found, force the value into a temporary.  */
3322   *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3323 }
3324
3325 /* A subroutine of gimplify_init_ctor_eval.  Create a loop for
3326    a RANGE_EXPR in a CONSTRUCTOR for an array.
3327
3328       var = lower;
3329     loop_entry:
3330       object[var] = value;
3331       if (var == upper)
3332         goto loop_exit;
3333       var = var + 1;
3334       goto loop_entry;
3335     loop_exit:
3336
3337    We increment var _after_ the loop exit check because we might otherwise
3338    fail if upper == TYPE_MAX_VALUE (type for upper).
3339
3340    Note that we never have to deal with SAVE_EXPRs here, because this has
3341    already been taken care of for us, in gimplify_init_ctor_preeval().  */
3342
3343 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
3344                                      gimple_seq *, bool);
3345
3346 static void
3347 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3348                                tree value, tree array_elt_type,
3349                                gimple_seq *pre_p, bool cleared)
3350 {
3351   tree loop_entry_label, loop_exit_label, fall_thru_label;
3352   tree var, var_type, cref, tmp;
3353
3354   loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
3355   loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
3356   fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
3357
3358   /* Create and initialize the index variable.  */
3359   var_type = TREE_TYPE (upper);
3360   var = create_tmp_var (var_type, NULL);
3361   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3362
3363   /* Add the loop entry label.  */
3364   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3365
3366   /* Build the reference.  */
3367   cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3368                  var, NULL_TREE, NULL_TREE);
3369
3370   /* If we are a constructor, just call gimplify_init_ctor_eval to do
3371      the store.  Otherwise just assign value to the reference.  */
3372
3373   if (TREE_CODE (value) == CONSTRUCTOR)
3374     /* NB we might have to call ourself recursively through
3375        gimplify_init_ctor_eval if the value is a constructor.  */
3376     gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3377                              pre_p, cleared);
3378   else
3379     gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3380
3381   /* We exit the loop when the index var is equal to the upper bound.  */
3382   gimplify_seq_add_stmt (pre_p,
3383                          gimple_build_cond (EQ_EXPR, var, upper,
3384                                             loop_exit_label, fall_thru_label));
3385
3386   gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3387
3388   /* Otherwise, increment the index var...  */
3389   tmp = build2 (PLUS_EXPR, var_type, var,
3390                 fold_convert (var_type, integer_one_node));
3391   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3392
3393   /* ...and jump back to the loop entry.  */
3394   gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3395
3396   /* Add the loop exit label.  */
3397   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3398 }
3399
3400 /* Return true if FDECL is accessing a field that is zero sized.  */
3401
3402 static bool
3403 zero_sized_field_decl (const_tree fdecl)
3404 {
3405   if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3406       && integer_zerop (DECL_SIZE (fdecl)))
3407     return true;
3408   return false;
3409 }
3410
3411 /* Return true if TYPE is zero sized.  */
3412
3413 static bool
3414 zero_sized_type (const_tree type)
3415 {
3416   if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3417       && integer_zerop (TYPE_SIZE (type)))
3418     return true;
3419   return false;
3420 }
3421
3422 /* A subroutine of gimplify_init_constructor.  Generate individual
3423    MODIFY_EXPRs for a CONSTRUCTOR.  OBJECT is the LHS against which the
3424    assignments should happen.  ELTS is the CONSTRUCTOR_ELTS of the
3425    CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
3426    zeroed first.  */
3427
3428 static void
3429 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3430                          gimple_seq *pre_p, bool cleared)
3431 {
3432   tree array_elt_type = NULL;
3433   unsigned HOST_WIDE_INT ix;
3434   tree purpose, value;
3435
3436   if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3437     array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3438
3439   FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3440     {
3441       tree cref;
3442
3443       /* NULL values are created above for gimplification errors.  */
3444       if (value == NULL)
3445         continue;
3446
3447       if (cleared && initializer_zerop (value))
3448         continue;
3449
3450       /* ??? Here's to hoping the front end fills in all of the indices,
3451          so we don't have to figure out what's missing ourselves.  */
3452       gcc_assert (purpose);
3453
3454       /* Skip zero-sized fields, unless value has side-effects.  This can
3455          happen with calls to functions returning a zero-sized type, which
3456          we shouldn't discard.  As a number of downstream passes don't
3457          expect sets of zero-sized fields, we rely on the gimplification of
3458          the MODIFY_EXPR we make below to drop the assignment statement.  */
3459       if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3460         continue;
3461
3462       /* If we have a RANGE_EXPR, we have to build a loop to assign the
3463          whole range.  */
3464       if (TREE_CODE (purpose) == RANGE_EXPR)
3465         {
3466           tree lower = TREE_OPERAND (purpose, 0);
3467           tree upper = TREE_OPERAND (purpose, 1);
3468
3469           /* If the lower bound is equal to upper, just treat it as if
3470              upper was the index.  */
3471           if (simple_cst_equal (lower, upper))
3472             purpose = upper;
3473           else
3474             {
3475               gimplify_init_ctor_eval_range (object, lower, upper, value,
3476                                              array_elt_type, pre_p, cleared);
3477               continue;
3478             }
3479         }
3480
3481       if (array_elt_type)
3482         {
3483           /* Do not use bitsizetype for ARRAY_REF indices.  */
3484           if (TYPE_DOMAIN (TREE_TYPE (object)))
3485             purpose = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3486                                     purpose);
3487           cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3488                          purpose, NULL_TREE, NULL_TREE);
3489         }
3490       else
3491         {
3492           gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3493           cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3494                          unshare_expr (object), purpose, NULL_TREE);
3495         }
3496
3497       if (TREE_CODE (value) == CONSTRUCTOR
3498           && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3499         gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3500                                  pre_p, cleared);
3501       else
3502         {
3503           tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3504           gimplify_and_add (init, pre_p);
3505           ggc_free (init);
3506         }
3507     }
3508 }
3509
3510
3511 /* Returns the appropriate RHS predicate for this LHS.  */
3512
3513 gimple_predicate
3514 rhs_predicate_for (tree lhs)
3515 {
3516   if (is_gimple_reg (lhs))
3517     return is_gimple_reg_rhs_or_call;
3518   else
3519     return is_gimple_mem_rhs_or_call;
3520 }
3521
3522 /* Gimplify a C99 compound literal expression.  This just means adding
3523    the DECL_EXPR before the current statement and using its anonymous
3524    decl instead.  */
3525
3526 static enum gimplify_status
3527 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p)
3528 {
3529   tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
3530   tree decl = DECL_EXPR_DECL (decl_s);
3531   /* Mark the decl as addressable if the compound literal
3532      expression is addressable now, otherwise it is marked too late
3533      after we gimplify the initialization expression.  */
3534   if (TREE_ADDRESSABLE (*expr_p))
3535     TREE_ADDRESSABLE (decl) = 1;
3536
3537   /* Preliminarily mark non-addressed complex variables as eligible
3538      for promotion to gimple registers.  We'll transform their uses
3539      as we find them.  */
3540   if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
3541        || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
3542       && !TREE_THIS_VOLATILE (decl)
3543       && !needs_to_live_in_memory (decl))
3544     DECL_GIMPLE_REG_P (decl) = 1;
3545
3546   /* This decl isn't mentioned in the enclosing block, so add it to the
3547      list of temps.  FIXME it seems a bit of a kludge to say that
3548      anonymous artificial vars aren't pushed, but everything else is.  */
3549   if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
3550     gimple_add_tmp_var (decl);
3551
3552   gimplify_and_add (decl_s, pre_p);
3553   *expr_p = decl;
3554   return GS_OK;
3555 }
3556
3557 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3558    return a new CONSTRUCTOR if something changed.  */
3559
3560 static tree
3561 optimize_compound_literals_in_ctor (tree orig_ctor)
3562 {
3563   tree ctor = orig_ctor;
3564   VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
3565   unsigned int idx, num = VEC_length (constructor_elt, elts);
3566
3567   for (idx = 0; idx < num; idx++)
3568     {
3569       tree value = VEC_index (constructor_elt, elts, idx)->value;
3570       tree newval = value;
3571       if (TREE_CODE (value) == CONSTRUCTOR)
3572         newval = optimize_compound_literals_in_ctor (value);
3573       else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
3574         {
3575           tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
3576           tree decl = DECL_EXPR_DECL (decl_s);
3577           tree init = DECL_INITIAL (decl);
3578
3579           if (!TREE_ADDRESSABLE (value)
3580               && !TREE_ADDRESSABLE (decl)
3581               && init)
3582             newval = optimize_compound_literals_in_ctor (init);
3583         }
3584       if (newval == value)
3585         continue;
3586
3587       if (ctor == orig_ctor)
3588         {
3589           ctor = copy_node (orig_ctor);
3590           CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
3591           elts = CONSTRUCTOR_ELTS (ctor);
3592         }
3593       VEC_index (constructor_elt, elts, idx)->value = newval;
3594     }
3595   return ctor;
3596 }
3597
3598
3599
3600 /* A subroutine of gimplify_modify_expr.  Break out elements of a