OSDN Git Service

PR middle-end/44085
[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 "gimple.h"
31 #include "tree-iterator.h"
32 #include "tree-inline.h"
33 #include "diagnostic.h"
34 #include "langhooks.h"
35 #include "langhooks-def.h"
36 #include "tree-flow.h"
37 #include "cgraph.h"
38 #include "timevar.h"
39 #include "except.h"
40 #include "hashtab.h"
41 #include "flags.h"
42 #include "real.h"
43 #include "function.h"
44 #include "output.h"
45 #include "expr.h"
46 #include "ggc.h"
47 #include "toplev.h"
48 #include "target.h"
49 #include "optabs.h"
50 #include "pointer-set.h"
51 #include "splay-tree.h"
52 #include "vec.h"
53 #include "gimple.h"
54 #include "tree-pass.h"
55
56
57 enum gimplify_omp_var_data
58 {
59   GOVD_SEEN = 1,
60   GOVD_EXPLICIT = 2,
61   GOVD_SHARED = 4,
62   GOVD_PRIVATE = 8,
63   GOVD_FIRSTPRIVATE = 16,
64   GOVD_LASTPRIVATE = 32,
65   GOVD_REDUCTION = 64,
66   GOVD_LOCAL = 128,
67   GOVD_DEBUG_PRIVATE = 256,
68   GOVD_PRIVATE_OUTER_REF = 512,
69   GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
70                            | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
71 };
72
73
74 enum omp_region_type
75 {
76   ORT_WORKSHARE = 0,
77   ORT_PARALLEL = 2,
78   ORT_COMBINED_PARALLEL = 3,
79   ORT_TASK = 4,
80   ORT_UNTIED_TASK = 5
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) == 0)
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     result = NULL_TREE;
1234   else if (aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1235     {
1236       if (TREE_CODE (DECL_SIZE (result_decl)) != INTEGER_CST)
1237         {
1238           if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl)))
1239             gimplify_type_sizes (TREE_TYPE (result_decl), pre_p);
1240           /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1241              should be effectively allocated by the caller, i.e. all calls to
1242              this function must be subject to the Return Slot Optimization.  */
1243           gimplify_one_sizepos (&DECL_SIZE (result_decl), pre_p);
1244           gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl), pre_p);
1245         }
1246       result = result_decl;
1247     }
1248   else if (gimplify_ctxp->return_temp)
1249     result = gimplify_ctxp->return_temp;
1250   else
1251     {
1252       result = create_tmp_reg (TREE_TYPE (result_decl), NULL);
1253
1254       /* ??? With complex control flow (usually involving abnormal edges),
1255          we can wind up warning about an uninitialized value for this.  Due
1256          to how this variable is constructed and initialized, this is never
1257          true.  Give up and never warn.  */
1258       TREE_NO_WARNING (result) = 1;
1259
1260       gimplify_ctxp->return_temp = result;
1261     }
1262
1263   /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1264      Then gimplify the whole thing.  */
1265   if (result != result_decl)
1266     TREE_OPERAND (ret_expr, 0) = result;
1267
1268   gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1269
1270   ret = gimple_build_return (result);
1271   gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1272   gimplify_seq_add_stmt (pre_p, ret);
1273
1274   return GS_ALL_DONE;
1275 }
1276
1277 static void
1278 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1279 {
1280   /* This is a variable-sized decl.  Simplify its size and mark it
1281      for deferred expansion.  Note that mudflap depends on the format
1282      of the emitted code: see mx_register_decls().  */
1283   tree t, addr, ptr_type;
1284
1285   gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1286   gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1287
1288   /* All occurrences of this decl in final gimplified code will be
1289      replaced by indirection.  Setting DECL_VALUE_EXPR does two
1290      things: First, it lets the rest of the gimplifier know what
1291      replacement to use.  Second, it lets the debug info know
1292      where to find the value.  */
1293   ptr_type = build_pointer_type (TREE_TYPE (decl));
1294   addr = create_tmp_var (ptr_type, get_name (decl));
1295   DECL_IGNORED_P (addr) = 0;
1296   t = build_fold_indirect_ref (addr);
1297   SET_DECL_VALUE_EXPR (decl, t);
1298   DECL_HAS_VALUE_EXPR_P (decl) = 1;
1299
1300   t = built_in_decls[BUILT_IN_ALLOCA];
1301   t = build_call_expr (t, 1, DECL_SIZE_UNIT (decl));
1302   t = fold_convert (ptr_type, t);
1303   t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1304
1305   gimplify_and_add (t, seq_p);
1306
1307   /* Indicate that we need to restore the stack level when the
1308      enclosing BIND_EXPR is exited.  */
1309   gimplify_ctxp->save_stack = true;
1310 }
1311
1312
1313 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1314    and initialization explicit.  */
1315
1316 static enum gimplify_status
1317 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1318 {
1319   tree stmt = *stmt_p;
1320   tree decl = DECL_EXPR_DECL (stmt);
1321
1322   *stmt_p = NULL_TREE;
1323
1324   if (TREE_TYPE (decl) == error_mark_node)
1325     return GS_ERROR;
1326
1327   if ((TREE_CODE (decl) == TYPE_DECL
1328        || TREE_CODE (decl) == VAR_DECL)
1329       && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1330     gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1331
1332   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1333     {
1334       tree init = DECL_INITIAL (decl);
1335
1336       if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1337           || (!TREE_STATIC (decl)
1338               && flag_stack_check == GENERIC_STACK_CHECK
1339               && compare_tree_int (DECL_SIZE_UNIT (decl),
1340                                    STACK_CHECK_MAX_VAR_SIZE) > 0))
1341         gimplify_vla_decl (decl, seq_p);
1342
1343       if (init && init != error_mark_node)
1344         {
1345           if (!TREE_STATIC (decl))
1346             {
1347               DECL_INITIAL (decl) = NULL_TREE;
1348               init = build2 (INIT_EXPR, void_type_node, decl, init);
1349               gimplify_and_add (init, seq_p);
1350               ggc_free (init);
1351             }
1352           else
1353             /* We must still examine initializers for static variables
1354                as they may contain a label address.  */
1355             walk_tree (&init, force_labels_r, NULL, NULL);
1356         }
1357
1358       /* Some front ends do not explicitly declare all anonymous
1359          artificial variables.  We compensate here by declaring the
1360          variables, though it would be better if the front ends would
1361          explicitly declare them.  */
1362       if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1363           && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1364         gimple_add_tmp_var (decl);
1365     }
1366
1367   return GS_ALL_DONE;
1368 }
1369
1370 /* Gimplify a LOOP_EXPR.  Normally this just involves gimplifying the body
1371    and replacing the LOOP_EXPR with goto, but if the loop contains an
1372    EXIT_EXPR, we need to append a label for it to jump to.  */
1373
1374 static enum gimplify_status
1375 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1376 {
1377   tree saved_label = gimplify_ctxp->exit_label;
1378   tree start_label = create_artificial_label (UNKNOWN_LOCATION);
1379
1380   gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1381
1382   gimplify_ctxp->exit_label = NULL_TREE;
1383
1384   gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1385
1386   gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1387
1388   if (gimplify_ctxp->exit_label)
1389     gimplify_seq_add_stmt (pre_p, gimple_build_label (gimplify_ctxp->exit_label));
1390
1391   gimplify_ctxp->exit_label = saved_label;
1392
1393   *expr_p = NULL;
1394   return GS_ALL_DONE;
1395 }
1396
1397 /* Gimplifies a statement list onto a sequence.  These may be created either
1398    by an enlightened front-end, or by shortcut_cond_expr.  */
1399
1400 static enum gimplify_status
1401 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1402 {
1403   tree temp = voidify_wrapper_expr (*expr_p, NULL);
1404
1405   tree_stmt_iterator i = tsi_start (*expr_p);
1406
1407   while (!tsi_end_p (i))
1408     {
1409       gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1410       tsi_delink (&i);
1411     }
1412
1413   if (temp)
1414     {
1415       *expr_p = temp;
1416       return GS_OK;
1417     }
1418
1419   return GS_ALL_DONE;
1420 }
1421
1422 /* Compare two case labels.  Because the front end should already have
1423    made sure that case ranges do not overlap, it is enough to only compare
1424    the CASE_LOW values of each case label.  */
1425
1426 static int
1427 compare_case_labels (const void *p1, const void *p2)
1428 {
1429   const_tree const case1 = *(const_tree const*)p1;
1430   const_tree const case2 = *(const_tree const*)p2;
1431
1432   /* The 'default' case label always goes first.  */
1433   if (!CASE_LOW (case1))
1434     return -1;
1435   else if (!CASE_LOW (case2))
1436     return 1;
1437   else
1438     return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1439 }
1440
1441
1442 /* Sort the case labels in LABEL_VEC in place in ascending order.  */
1443
1444 void
1445 sort_case_labels (VEC(tree,heap)* label_vec)
1446 {
1447   size_t len = VEC_length (tree, label_vec);
1448   qsort (VEC_address (tree, label_vec), len, sizeof (tree),
1449          compare_case_labels);
1450 }
1451
1452
1453 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1454    branch to.  */
1455
1456 static enum gimplify_status
1457 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
1458 {
1459   tree switch_expr = *expr_p;
1460   gimple_seq switch_body_seq = NULL;
1461   enum gimplify_status ret;
1462
1463   ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
1464                        fb_rvalue);
1465   if (ret == GS_ERROR || ret == GS_UNHANDLED)
1466     return ret;
1467
1468   if (SWITCH_BODY (switch_expr))
1469     {
1470       VEC (tree,heap) *labels;
1471       VEC (tree,heap) *saved_labels;
1472       tree default_case = NULL_TREE;
1473       size_t i, len;
1474       gimple gimple_switch;
1475
1476       /* If someone can be bothered to fill in the labels, they can
1477          be bothered to null out the body too.  */
1478       gcc_assert (!SWITCH_LABELS (switch_expr));
1479
1480       /* save old labels, get new ones from body, then restore the old
1481          labels.  Save all the things from the switch body to append after.  */
1482       saved_labels = gimplify_ctxp->case_labels;
1483       gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1484
1485       gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
1486       labels = gimplify_ctxp->case_labels;
1487       gimplify_ctxp->case_labels = saved_labels;
1488
1489       i = 0;
1490       while (i < VEC_length (tree, labels))
1491         {
1492           tree elt = VEC_index (tree, labels, i);
1493           tree low = CASE_LOW (elt);
1494           bool remove_element = FALSE;
1495
1496           if (low)
1497             {
1498               /* Discard empty ranges.  */
1499               tree high = CASE_HIGH (elt);
1500               if (high && tree_int_cst_lt (high, low))
1501                 remove_element = TRUE;
1502             }
1503           else
1504             {
1505               /* The default case must be the last label in the list.  */
1506               gcc_assert (!default_case);
1507               default_case = elt;
1508               remove_element = TRUE;
1509             }
1510
1511           if (remove_element)
1512             VEC_ordered_remove (tree, labels, i);
1513           else
1514             i++;
1515         }
1516       len = i;
1517
1518       if (!VEC_empty (tree, labels))
1519         sort_case_labels (labels);
1520
1521       if (!default_case)
1522         {
1523           tree type = TREE_TYPE (switch_expr);
1524
1525           /* If the switch has no default label, add one, so that we jump
1526              around the switch body.  If the labels already cover the whole
1527              range of type, add the default label pointing to one of the
1528              existing labels.  */
1529           if (type == void_type_node)
1530             type = TREE_TYPE (SWITCH_COND (switch_expr));
1531           if (len
1532               && INTEGRAL_TYPE_P (type)
1533               && TYPE_MIN_VALUE (type)
1534               && TYPE_MAX_VALUE (type)
1535               && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
1536                                      TYPE_MIN_VALUE (type)))
1537             {
1538               tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
1539               if (!high)
1540                 high = CASE_LOW (VEC_index (tree, labels, len - 1));
1541               if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
1542                 {
1543                   for (i = 1; i < len; i++)
1544                     {
1545                       high = CASE_LOW (VEC_index (tree, labels, i));
1546                       low = CASE_HIGH (VEC_index (tree, labels, i - 1));
1547                       if (!low)
1548                         low = CASE_LOW (VEC_index (tree, labels, i - 1));
1549                       if ((TREE_INT_CST_LOW (low) + 1
1550                            != TREE_INT_CST_LOW (high))
1551                           || (TREE_INT_CST_HIGH (low)
1552                               + (TREE_INT_CST_LOW (high) == 0)
1553                               != TREE_INT_CST_HIGH (high)))
1554                         break;
1555                     }
1556                   if (i == len)
1557                     default_case = build3 (CASE_LABEL_EXPR, void_type_node,
1558                                            NULL_TREE, NULL_TREE,
1559                                            CASE_LABEL (VEC_index (tree,
1560                                                                   labels, 0)));
1561                 }
1562             }
1563
1564           if (!default_case)
1565             {
1566               gimple new_default;
1567
1568               default_case
1569                 = build3 (CASE_LABEL_EXPR, void_type_node,
1570                           NULL_TREE, NULL_TREE,
1571                           create_artificial_label (UNKNOWN_LOCATION));
1572               new_default = gimple_build_label (CASE_LABEL (default_case));
1573               gimplify_seq_add_stmt (&switch_body_seq, new_default);
1574             }
1575         }
1576
1577       gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
1578                                                default_case, labels);
1579       gimplify_seq_add_stmt (pre_p, gimple_switch);
1580       gimplify_seq_add_seq (pre_p, switch_body_seq);
1581       VEC_free(tree, heap, labels);
1582     }
1583   else
1584     gcc_assert (SWITCH_LABELS (switch_expr));
1585
1586   return GS_ALL_DONE;
1587 }
1588
1589
1590 static enum gimplify_status
1591 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
1592 {
1593   struct gimplify_ctx *ctxp;
1594   gimple gimple_label;
1595
1596   /* Invalid OpenMP programs can play Duff's Device type games with
1597      #pragma omp parallel.  At least in the C front end, we don't
1598      detect such invalid branches until after gimplification.  */
1599   for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1600     if (ctxp->case_labels)
1601       break;
1602
1603   gimple_label = gimple_build_label (CASE_LABEL (*expr_p));
1604   VEC_safe_push (tree, heap, ctxp->case_labels, *expr_p);
1605   gimplify_seq_add_stmt (pre_p, gimple_label);
1606
1607   return GS_ALL_DONE;
1608 }
1609
1610 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1611    if necessary.  */
1612
1613 tree
1614 build_and_jump (tree *label_p)
1615 {
1616   if (label_p == NULL)
1617     /* If there's nowhere to jump, just fall through.  */
1618     return NULL_TREE;
1619
1620   if (*label_p == NULL_TREE)
1621     {
1622       tree label = create_artificial_label (UNKNOWN_LOCATION);
1623       *label_p = label;
1624     }
1625
1626   return build1 (GOTO_EXPR, void_type_node, *label_p);
1627 }
1628
1629 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1630    This also involves building a label to jump to and communicating it to
1631    gimplify_loop_expr through gimplify_ctxp->exit_label.  */
1632
1633 static enum gimplify_status
1634 gimplify_exit_expr (tree *expr_p)
1635 {
1636   tree cond = TREE_OPERAND (*expr_p, 0);
1637   tree expr;
1638
1639   expr = build_and_jump (&gimplify_ctxp->exit_label);
1640   expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1641   *expr_p = expr;
1642
1643   return GS_OK;
1644 }
1645
1646 /* A helper function to be called via walk_tree.  Mark all labels under *TP
1647    as being forced.  To be called for DECL_INITIAL of static variables.  */
1648
1649 tree
1650 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1651 {
1652   if (TYPE_P (*tp))
1653     *walk_subtrees = 0;
1654   if (TREE_CODE (*tp) == LABEL_DECL)
1655     FORCED_LABEL (*tp) = 1;
1656
1657   return NULL_TREE;
1658 }
1659
1660 /* *EXPR_P is a COMPONENT_REF being used as an rvalue.  If its type is
1661    different from its canonical type, wrap the whole thing inside a
1662    NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1663    type.
1664
1665    The canonical type of a COMPONENT_REF is the type of the field being
1666    referenced--unless the field is a bit-field which can be read directly
1667    in a smaller mode, in which case the canonical type is the
1668    sign-appropriate type corresponding to that mode.  */
1669
1670 static void
1671 canonicalize_component_ref (tree *expr_p)
1672 {
1673   tree expr = *expr_p;
1674   tree type;
1675
1676   gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1677
1678   if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1679     type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1680   else
1681     type = TREE_TYPE (TREE_OPERAND (expr, 1));
1682
1683   /* One could argue that all the stuff below is not necessary for
1684      the non-bitfield case and declare it a FE error if type
1685      adjustment would be needed.  */
1686   if (TREE_TYPE (expr) != type)
1687     {
1688 #ifdef ENABLE_TYPES_CHECKING
1689       tree old_type = TREE_TYPE (expr);
1690 #endif
1691       int type_quals;
1692
1693       /* We need to preserve qualifiers and propagate them from
1694          operand 0.  */
1695       type_quals = TYPE_QUALS (type)
1696         | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1697       if (TYPE_QUALS (type) != type_quals)
1698         type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1699
1700       /* Set the type of the COMPONENT_REF to the underlying type.  */
1701       TREE_TYPE (expr) = type;
1702
1703 #ifdef ENABLE_TYPES_CHECKING
1704       /* It is now a FE error, if the conversion from the canonical
1705          type to the original expression type is not useless.  */
1706       gcc_assert (useless_type_conversion_p (old_type, type));
1707 #endif
1708     }
1709 }
1710
1711 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1712    to foo, embed that change in the ADDR_EXPR by converting
1713       T array[U];
1714       (T *)&array
1715    ==>
1716       &array[L]
1717    where L is the lower bound.  For simplicity, only do this for constant
1718    lower bound.
1719    The constraint is that the type of &array[L] is trivially convertible
1720    to T *.  */
1721
1722 static void
1723 canonicalize_addr_expr (tree *expr_p)
1724 {
1725   tree expr = *expr_p;
1726   tree addr_expr = TREE_OPERAND (expr, 0);
1727   tree datype, ddatype, pddatype;
1728
1729   /* We simplify only conversions from an ADDR_EXPR to a pointer type.  */
1730   if (!POINTER_TYPE_P (TREE_TYPE (expr))
1731       || TREE_CODE (addr_expr) != ADDR_EXPR)
1732     return;
1733
1734   /* The addr_expr type should be a pointer to an array.  */
1735   datype = TREE_TYPE (TREE_TYPE (addr_expr));
1736   if (TREE_CODE (datype) != ARRAY_TYPE)
1737     return;
1738
1739   /* The pointer to element type shall be trivially convertible to
1740      the expression pointer type.  */
1741   ddatype = TREE_TYPE (datype);
1742   pddatype = build_pointer_type (ddatype);
1743   if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
1744                                   pddatype))
1745     return;
1746
1747   /* The lower bound and element sizes must be constant.  */
1748   if (!TYPE_SIZE_UNIT (ddatype)
1749       || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1750       || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1751       || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1752     return;
1753
1754   /* All checks succeeded.  Build a new node to merge the cast.  */
1755   *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1756                     TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1757                     NULL_TREE, NULL_TREE);
1758   *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1759
1760   /* We can have stripped a required restrict qualifier above.  */
1761   if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
1762     *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
1763 }
1764
1765 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR.  Remove it and/or other conversions
1766    underneath as appropriate.  */
1767
1768 static enum gimplify_status
1769 gimplify_conversion (tree *expr_p)
1770 {
1771   tree tem;
1772   location_t loc = EXPR_LOCATION (*expr_p);
1773   gcc_assert (CONVERT_EXPR_P (*expr_p));
1774
1775   /* Then strip away all but the outermost conversion.  */
1776   STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1777
1778   /* And remove the outermost conversion if it's useless.  */
1779   if (tree_ssa_useless_type_conversion (*expr_p))
1780     *expr_p = TREE_OPERAND (*expr_p, 0);
1781
1782   /* Attempt to avoid NOP_EXPR by producing reference to a subtype.
1783      For example this fold (subclass *)&A into &A->subclass avoiding
1784      a need for statement.  */
1785   if (CONVERT_EXPR_P (*expr_p)
1786       && POINTER_TYPE_P (TREE_TYPE (*expr_p))
1787       && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0)))
1788       && (tem = maybe_fold_offset_to_address
1789           (EXPR_LOCATION (*expr_p), TREE_OPERAND (*expr_p, 0),
1790            integer_zero_node, TREE_TYPE (*expr_p))) != NULL_TREE)
1791     *expr_p = tem;
1792
1793   /* If we still have a conversion at the toplevel,
1794      then canonicalize some constructs.  */
1795   if (CONVERT_EXPR_P (*expr_p))
1796     {
1797       tree sub = TREE_OPERAND (*expr_p, 0);
1798
1799       /* If a NOP conversion is changing the type of a COMPONENT_REF
1800          expression, then canonicalize its type now in order to expose more
1801          redundant conversions.  */
1802       if (TREE_CODE (sub) == COMPONENT_REF)
1803         canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1804
1805       /* If a NOP conversion is changing a pointer to array of foo
1806          to a pointer to foo, embed that change in the ADDR_EXPR.  */
1807       else if (TREE_CODE (sub) == ADDR_EXPR)
1808         canonicalize_addr_expr (expr_p);
1809     }
1810
1811   /* If we have a conversion to a non-register type force the
1812      use of a VIEW_CONVERT_EXPR instead.  */
1813   if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
1814     *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
1815                                TREE_OPERAND (*expr_p, 0));
1816
1817   return GS_OK;
1818 }
1819
1820 /* Nonlocal VLAs seen in the current function.  */
1821 static struct pointer_set_t *nonlocal_vlas;
1822
1823 /* Gimplify a VAR_DECL or PARM_DECL.  Returns GS_OK if we expanded a
1824    DECL_VALUE_EXPR, and it's worth re-examining things.  */
1825
1826 static enum gimplify_status
1827 gimplify_var_or_parm_decl (tree *expr_p)
1828 {
1829   tree decl = *expr_p;
1830
1831   /* ??? If this is a local variable, and it has not been seen in any
1832      outer BIND_EXPR, then it's probably the result of a duplicate
1833      declaration, for which we've already issued an error.  It would
1834      be really nice if the front end wouldn't leak these at all.
1835      Currently the only known culprit is C++ destructors, as seen
1836      in g++.old-deja/g++.jason/binding.C.  */
1837   if (TREE_CODE (decl) == VAR_DECL
1838       && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1839       && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1840       && decl_function_context (decl) == current_function_decl)
1841     {
1842       gcc_assert (errorcount || sorrycount);
1843       return GS_ERROR;
1844     }
1845
1846   /* When within an OpenMP context, notice uses of variables.  */
1847   if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1848     return GS_ALL_DONE;
1849
1850   /* If the decl is an alias for another expression, substitute it now.  */
1851   if (DECL_HAS_VALUE_EXPR_P (decl))
1852     {
1853       tree value_expr = DECL_VALUE_EXPR (decl);
1854
1855       /* For referenced nonlocal VLAs add a decl for debugging purposes
1856          to the current function.  */
1857       if (TREE_CODE (decl) == VAR_DECL
1858           && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1859           && nonlocal_vlas != NULL
1860           && TREE_CODE (value_expr) == INDIRECT_REF
1861           && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
1862           && decl_function_context (decl) != current_function_decl)
1863         {
1864           struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1865           while (ctx && ctx->region_type == ORT_WORKSHARE)
1866             ctx = ctx->outer_context;
1867           if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
1868             {
1869               tree copy = copy_node (decl), block;
1870
1871               lang_hooks.dup_lang_specific_decl (copy);
1872               SET_DECL_RTL (copy, NULL_RTX);
1873               TREE_USED (copy) = 1;
1874               block = DECL_INITIAL (current_function_decl);
1875               TREE_CHAIN (copy) = BLOCK_VARS (block);
1876               BLOCK_VARS (block) = copy;
1877               SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
1878               DECL_HAS_VALUE_EXPR_P (copy) = 1;
1879             }
1880         }
1881
1882       *expr_p = unshare_expr (value_expr);
1883       return GS_OK;
1884     }
1885
1886   return GS_ALL_DONE;
1887 }
1888
1889
1890 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1891    node *EXPR_P.
1892
1893       compound_lval
1894               : min_lval '[' val ']'
1895               | min_lval '.' ID
1896               | compound_lval '[' val ']'
1897               | compound_lval '.' ID
1898
1899    This is not part of the original SIMPLE definition, which separates
1900    array and member references, but it seems reasonable to handle them
1901    together.  Also, this way we don't run into problems with union
1902    aliasing; gcc requires that for accesses through a union to alias, the
1903    union reference must be explicit, which was not always the case when we
1904    were splitting up array and member refs.
1905
1906    PRE_P points to the sequence where side effects that must happen before
1907      *EXPR_P should be stored.
1908
1909    POST_P points to the sequence where side effects that must happen after
1910      *EXPR_P should be stored.  */
1911
1912 static enum gimplify_status
1913 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
1914                         fallback_t fallback)
1915 {
1916   tree *p;
1917   VEC(tree,heap) *stack;
1918   enum gimplify_status ret = GS_ALL_DONE, tret;
1919   int i;
1920   location_t loc = EXPR_LOCATION (*expr_p);
1921   tree expr = *expr_p;
1922
1923   /* Create a stack of the subexpressions so later we can walk them in
1924      order from inner to outer.  */
1925   stack = VEC_alloc (tree, heap, 10);
1926
1927   /* We can handle anything that get_inner_reference can deal with.  */
1928   for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
1929     {
1930     restart:
1931       /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs.  */
1932       if (TREE_CODE (*p) == INDIRECT_REF)
1933         *p = fold_indirect_ref_loc (loc, *p);
1934
1935       if (handled_component_p (*p))
1936         ;
1937       /* Expand DECL_VALUE_EXPR now.  In some cases that may expose
1938          additional COMPONENT_REFs.  */
1939       else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
1940                && gimplify_var_or_parm_decl (p) == GS_OK)
1941         goto restart;
1942       else
1943         break;
1944
1945       VEC_safe_push (tree, heap, stack, *p);
1946     }
1947
1948   gcc_assert (VEC_length (tree, stack));
1949
1950   /* Now STACK is a stack of pointers to all the refs we've walked through
1951      and P points to the innermost expression.
1952
1953      Java requires that we elaborated nodes in source order.  That
1954      means we must gimplify the inner expression followed by each of
1955      the indices, in order.  But we can't gimplify the inner
1956      expression until we deal with any variable bounds, sizes, or
1957      positions in order to deal with PLACEHOLDER_EXPRs.
1958
1959      So we do this in three steps.  First we deal with the annotations
1960      for any variables in the components, then we gimplify the base,
1961      then we gimplify any indices, from left to right.  */
1962   for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
1963     {
1964       tree t = VEC_index (tree, stack, i);
1965
1966       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1967         {
1968           /* Gimplify the low bound and element type size and put them into
1969              the ARRAY_REF.  If these values are set, they have already been
1970              gimplified.  */
1971           if (TREE_OPERAND (t, 2) == NULL_TREE)
1972             {
1973               tree low = unshare_expr (array_ref_low_bound (t));
1974               if (!is_gimple_min_invariant (low))
1975                 {
1976                   TREE_OPERAND (t, 2) = low;
1977                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
1978                                         post_p, is_gimple_reg,
1979                                         fb_rvalue);
1980                   ret = MIN (ret, tret);
1981                 }
1982             }
1983
1984           if (!TREE_OPERAND (t, 3))
1985             {
1986               tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1987               tree elmt_size = unshare_expr (array_ref_element_size (t));
1988               tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
1989
1990               /* Divide the element size by the alignment of the element
1991                  type (above).  */
1992               elmt_size = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
1993
1994               if (!is_gimple_min_invariant (elmt_size))
1995                 {
1996                   TREE_OPERAND (t, 3) = elmt_size;
1997                   tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
1998                                         post_p, is_gimple_reg,
1999                                         fb_rvalue);
2000                   ret = MIN (ret, tret);
2001                 }
2002             }
2003         }
2004       else if (TREE_CODE (t) == COMPONENT_REF)
2005         {
2006           /* Set the field offset into T and gimplify it.  */
2007           if (!TREE_OPERAND (t, 2))
2008             {
2009               tree offset = unshare_expr (component_ref_field_offset (t));
2010               tree field = TREE_OPERAND (t, 1);
2011               tree factor
2012                 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
2013
2014               /* Divide the offset by its alignment.  */
2015               offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2016
2017               if (!is_gimple_min_invariant (offset))
2018                 {
2019                   TREE_OPERAND (t, 2) = offset;
2020                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2021                                         post_p, is_gimple_reg,
2022                                         fb_rvalue);
2023                   ret = MIN (ret, tret);
2024                 }
2025             }
2026         }
2027     }
2028
2029   /* Step 2 is to gimplify the base expression.  Make sure lvalue is set
2030      so as to match the min_lval predicate.  Failure to do so may result
2031      in the creation of large aggregate temporaries.  */
2032   tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2033                         fallback | fb_lvalue);
2034   ret = MIN (ret, tret);
2035
2036   /* And finally, the indices and operands to BIT_FIELD_REF.  During this
2037      loop we also remove any useless conversions.  */
2038   for (; VEC_length (tree, stack) > 0; )
2039     {
2040       tree t = VEC_pop (tree, stack);
2041
2042       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2043         {
2044           /* Gimplify the dimension.  */
2045           if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2046             {
2047               tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2048                                     is_gimple_val, fb_rvalue);
2049               ret = MIN (ret, tret);
2050             }
2051         }
2052       else if (TREE_CODE (t) == BIT_FIELD_REF)
2053         {
2054           tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2055                                 is_gimple_val, fb_rvalue);
2056           ret = MIN (ret, tret);
2057           tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2058                                 is_gimple_val, fb_rvalue);
2059           ret = MIN (ret, tret);
2060         }
2061
2062       STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2063
2064       /* The innermost expression P may have originally had
2065          TREE_SIDE_EFFECTS set which would have caused all the outer
2066          expressions in *EXPR_P leading to P to also have had
2067          TREE_SIDE_EFFECTS set.  */
2068       recalculate_side_effects (t);
2069     }
2070
2071   /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
2072   if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2073     {
2074       canonicalize_component_ref (expr_p);
2075     }
2076
2077   VEC_free (tree, heap, stack);
2078
2079   gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
2080
2081   return ret;
2082 }
2083
2084 /*  Gimplify the self modifying expression pointed to by EXPR_P
2085     (++, --, +=, -=).
2086
2087     PRE_P points to the list where side effects that must happen before
2088         *EXPR_P should be stored.
2089
2090     POST_P points to the list where side effects that must happen after
2091         *EXPR_P should be stored.
2092
2093     WANT_VALUE is nonzero iff we want to use the value of this expression
2094         in another expression.  */
2095
2096 static enum gimplify_status
2097 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2098                         bool want_value)
2099 {
2100   enum tree_code code;
2101   tree lhs, lvalue, rhs, t1;
2102   gimple_seq post = NULL, *orig_post_p = post_p;
2103   bool postfix;
2104   enum tree_code arith_code;
2105   enum gimplify_status ret;
2106   location_t loc = EXPR_LOCATION (*expr_p);
2107
2108   code = TREE_CODE (*expr_p);
2109
2110   gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2111               || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2112
2113   /* Prefix or postfix?  */
2114   if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2115     /* Faster to treat as prefix if result is not used.  */
2116     postfix = want_value;
2117   else
2118     postfix = false;
2119
2120   /* For postfix, make sure the inner expression's post side effects
2121      are executed after side effects from this expression.  */
2122   if (postfix)
2123     post_p = &post;
2124
2125   /* Add or subtract?  */
2126   if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2127     arith_code = PLUS_EXPR;
2128   else
2129     arith_code = MINUS_EXPR;
2130
2131   /* Gimplify the LHS into a GIMPLE lvalue.  */
2132   lvalue = TREE_OPERAND (*expr_p, 0);
2133   ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2134   if (ret == GS_ERROR)
2135     return ret;
2136
2137   /* Extract the operands to the arithmetic operation.  */
2138   lhs = lvalue;
2139   rhs = TREE_OPERAND (*expr_p, 1);
2140
2141   /* For postfix operator, we evaluate the LHS to an rvalue and then use
2142      that as the result value and in the postqueue operation.  We also
2143      make sure to make lvalue a minimal lval, see
2144      gcc.c-torture/execute/20040313-1.c for an example where this matters.  */
2145   if (postfix)
2146     {
2147       if (!is_gimple_min_lval (lvalue))
2148         {
2149           mark_addressable (lvalue);
2150           lvalue = build_fold_addr_expr_loc (input_location, lvalue);
2151           gimplify_expr (&lvalue, pre_p, post_p, is_gimple_val, fb_rvalue);
2152           lvalue = build_fold_indirect_ref_loc (input_location, lvalue);
2153         }
2154       ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2155       if (ret == GS_ERROR)
2156         return ret;
2157     }
2158
2159   /* For POINTERs increment, use POINTER_PLUS_EXPR.  */
2160   if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2161     {
2162       rhs = fold_convert_loc (loc, sizetype, rhs);
2163       if (arith_code == MINUS_EXPR)
2164         rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2165       arith_code = POINTER_PLUS_EXPR;
2166     }
2167
2168   t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
2169
2170   if (postfix)
2171     {
2172       gimplify_assign (lvalue, t1, orig_post_p);
2173       gimplify_seq_add_seq (orig_post_p, post);
2174       *expr_p = lhs;
2175       return GS_ALL_DONE;
2176     }
2177   else
2178     {
2179       *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2180       return GS_OK;
2181     }
2182 }
2183
2184
2185 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR.  */
2186
2187 static void
2188 maybe_with_size_expr (tree *expr_p)
2189 {
2190   tree expr = *expr_p;
2191   tree type = TREE_TYPE (expr);
2192   tree size;
2193
2194   /* If we've already wrapped this or the type is error_mark_node, we can't do
2195      anything.  */
2196   if (TREE_CODE (expr) == WITH_SIZE_EXPR
2197       || type == error_mark_node)
2198     return;
2199
2200   /* If the size isn't known or is a constant, we have nothing to do.  */
2201   size = TYPE_SIZE_UNIT (type);
2202   if (!size || TREE_CODE (size) == INTEGER_CST)
2203     return;
2204
2205   /* Otherwise, make a WITH_SIZE_EXPR.  */
2206   size = unshare_expr (size);
2207   size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2208   *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2209 }
2210
2211
2212 /* Helper for gimplify_call_expr.  Gimplify a single argument *ARG_P
2213    Store any side-effects in PRE_P.  CALL_LOCATION is the location of
2214    the CALL_EXPR.  */
2215
2216 static enum gimplify_status
2217 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location)
2218 {
2219   bool (*test) (tree);
2220   fallback_t fb;
2221
2222   /* In general, we allow lvalues for function arguments to avoid
2223      extra overhead of copying large aggregates out of even larger
2224      aggregates into temporaries only to copy the temporaries to
2225      the argument list.  Make optimizers happy by pulling out to
2226      temporaries those types that fit in registers.  */
2227   if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2228     test = is_gimple_val, fb = fb_rvalue;
2229   else
2230     test = is_gimple_lvalue, fb = fb_either;
2231
2232   /* If this is a variable sized type, we must remember the size.  */
2233   maybe_with_size_expr (arg_p);
2234
2235   /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c.  */
2236   /* Make sure arguments have the same location as the function call
2237      itself.  */
2238   protected_set_expr_location (*arg_p, call_location);
2239
2240   /* There is a sequence point before a function call.  Side effects in
2241      the argument list must occur before the actual call. So, when
2242      gimplifying arguments, force gimplify_expr to use an internal
2243      post queue which is then appended to the end of PRE_P.  */
2244   return gimplify_expr (arg_p, pre_p, NULL, test, fb);
2245 }
2246
2247
2248 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2249    WANT_VALUE is true if the result of the call is desired.  */
2250
2251 static enum gimplify_status
2252 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2253 {
2254   tree fndecl, parms, p;
2255   enum gimplify_status ret;
2256   int i, nargs;
2257   gimple call;
2258   bool builtin_va_start_p = FALSE;
2259   location_t loc = EXPR_LOCATION (*expr_p);
2260
2261   gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2262
2263   /* For reliable diagnostics during inlining, it is necessary that
2264      every call_expr be annotated with file and line.  */
2265   if (! EXPR_HAS_LOCATION (*expr_p))
2266     SET_EXPR_LOCATION (*expr_p, input_location);
2267
2268   /* This may be a call to a builtin function.
2269
2270      Builtin function calls may be transformed into different
2271      (and more efficient) builtin function calls under certain
2272      circumstances.  Unfortunately, gimplification can muck things
2273      up enough that the builtin expanders are not aware that certain
2274      transformations are still valid.
2275
2276      So we attempt transformation/gimplification of the call before
2277      we gimplify the CALL_EXPR.  At this time we do not manage to
2278      transform all calls in the same manner as the expanders do, but
2279      we do transform most of them.  */
2280   fndecl = get_callee_fndecl (*expr_p);
2281   if (fndecl && DECL_BUILT_IN (fndecl))
2282     {
2283       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2284
2285       if (new_tree && new_tree != *expr_p)
2286         {
2287           /* There was a transformation of this call which computes the
2288              same value, but in a more efficient way.  Return and try
2289              again.  */
2290           *expr_p = new_tree;
2291           return GS_OK;
2292         }
2293
2294       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2295           && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
2296         {
2297           builtin_va_start_p = TRUE;
2298           if (call_expr_nargs (*expr_p) < 2)
2299             {
2300               error ("too few arguments to function %<va_start%>");
2301               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2302               return GS_OK;
2303             }
2304
2305           if (fold_builtin_next_arg (*expr_p, true))
2306             {
2307               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2308               return GS_OK;
2309             }
2310         }
2311     }
2312
2313   /* There is a sequence point before the call, so any side effects in
2314      the calling expression must occur before the actual call.  Force
2315      gimplify_expr to use an internal post queue.  */
2316   ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2317                        is_gimple_call_addr, fb_rvalue);
2318
2319   nargs = call_expr_nargs (*expr_p);
2320
2321   /* Get argument types for verification.  */
2322   fndecl = get_callee_fndecl (*expr_p);
2323   parms = NULL_TREE;
2324   if (fndecl)
2325     parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2326   else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2327     parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2328
2329   if (fndecl && DECL_ARGUMENTS (fndecl))
2330     p = DECL_ARGUMENTS (fndecl);
2331   else if (parms)
2332     p = parms;
2333   else
2334     p = NULL_TREE;
2335   for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2336     ;
2337
2338   /* If the last argument is __builtin_va_arg_pack () and it is not
2339      passed as a named argument, decrease the number of CALL_EXPR
2340      arguments and set instead the CALL_EXPR_VA_ARG_PACK flag.  */
2341   if (!p
2342       && i < nargs
2343       && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2344     {
2345       tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2346       tree last_arg_fndecl = get_callee_fndecl (last_arg);
2347
2348       if (last_arg_fndecl
2349           && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2350           && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2351           && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2352         {
2353           tree call = *expr_p;
2354
2355           --nargs;
2356           *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
2357                                           CALL_EXPR_FN (call),
2358                                           nargs, CALL_EXPR_ARGP (call));
2359
2360           /* Copy all CALL_EXPR flags, location and block, except
2361              CALL_EXPR_VA_ARG_PACK flag.  */
2362           CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2363           CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2364           CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2365             = CALL_EXPR_RETURN_SLOT_OPT (call);
2366           CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2367           CALL_CANNOT_INLINE_P (*expr_p) = CALL_CANNOT_INLINE_P (call);
2368           SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
2369           TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2370
2371           /* Set CALL_EXPR_VA_ARG_PACK.  */
2372           CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2373         }
2374     }
2375
2376   /* Finally, gimplify the function arguments.  */
2377   if (nargs > 0)
2378     {
2379       for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2380            PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2381            PUSH_ARGS_REVERSED ? i-- : i++)
2382         {
2383           enum gimplify_status t;
2384
2385           /* Avoid gimplifying the second argument to va_start, which needs to
2386              be the plain PARM_DECL.  */
2387           if ((i != 1) || !builtin_va_start_p)
2388             {
2389               t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2390                                 EXPR_LOCATION (*expr_p));
2391
2392               if (t == GS_ERROR)
2393                 ret = GS_ERROR;
2394             }
2395         }
2396     }
2397
2398   /* Verify the function result.  */
2399   if (want_value && fndecl
2400       && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl))))
2401     {
2402       error_at (loc, "using result of function returning %<void%>");
2403       ret = GS_ERROR;
2404     }
2405
2406   /* Try this again in case gimplification exposed something.  */
2407   if (ret != GS_ERROR)
2408     {
2409       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2410
2411       if (new_tree && new_tree != *expr_p)
2412         {
2413           /* There was a transformation of this call which computes the
2414              same value, but in a more efficient way.  Return and try
2415              again.  */
2416           *expr_p = new_tree;
2417           return GS_OK;
2418         }
2419     }
2420   else
2421     {
2422       *expr_p = error_mark_node;
2423       return GS_ERROR;
2424     }
2425
2426   /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2427      decl.  This allows us to eliminate redundant or useless
2428      calls to "const" functions.  */
2429   if (TREE_CODE (*expr_p) == CALL_EXPR)
2430     {
2431       int flags = call_expr_flags (*expr_p);
2432       if (flags & (ECF_CONST | ECF_PURE)
2433           /* An infinite loop is considered a side effect.  */
2434           && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2435         TREE_SIDE_EFFECTS (*expr_p) = 0;
2436     }
2437
2438   /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2439      and clear *EXPR_P.  Otherwise, leave *EXPR_P in its gimplified
2440      form and delegate the creation of a GIMPLE_CALL to
2441      gimplify_modify_expr.  This is always possible because when
2442      WANT_VALUE is true, the caller wants the result of this call into
2443      a temporary, which means that we will emit an INIT_EXPR in
2444      internal_get_tmp_var which will then be handled by
2445      gimplify_modify_expr.  */
2446   if (!want_value)
2447     {
2448       /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2449          have to do is replicate it as a GIMPLE_CALL tuple.  */
2450       call = gimple_build_call_from_tree (*expr_p);
2451       gimplify_seq_add_stmt (pre_p, call);
2452       *expr_p = NULL_TREE;
2453     }
2454
2455   return ret;
2456 }
2457
2458 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2459    rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2460
2461    TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2462    condition is true or false, respectively.  If null, we should generate
2463    our own to skip over the evaluation of this specific expression.
2464
2465    LOCUS is the source location of the COND_EXPR.
2466
2467    This function is the tree equivalent of do_jump.
2468
2469    shortcut_cond_r should only be called by shortcut_cond_expr.  */
2470
2471 static tree
2472 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
2473                  location_t locus)
2474 {
2475   tree local_label = NULL_TREE;
2476   tree t, expr = NULL;
2477
2478   /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2479      retain the shortcut semantics.  Just insert the gotos here;
2480      shortcut_cond_expr will append the real blocks later.  */
2481   if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2482     {
2483       location_t new_locus;
2484
2485       /* Turn if (a && b) into
2486
2487          if (a); else goto no;
2488          if (b) goto yes; else goto no;
2489          (no:) */
2490
2491       if (false_label_p == NULL)
2492         false_label_p = &local_label;
2493
2494       /* Keep the original source location on the first 'if'.  */
2495       t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
2496       append_to_statement_list (t, &expr);
2497
2498       /* Set the source location of the && on the second 'if'.  */
2499       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2500       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2501                            new_locus);
2502       append_to_statement_list (t, &expr);
2503     }
2504   else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2505     {
2506       location_t new_locus;
2507
2508       /* Turn if (a || b) into
2509
2510          if (a) goto yes;
2511          if (b) goto yes; else goto no;
2512          (yes:) */
2513
2514       if (true_label_p == NULL)
2515         true_label_p = &local_label;
2516
2517       /* Keep the original source location on the first 'if'.  */
2518       t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
2519       append_to_statement_list (t, &expr);
2520
2521       /* Set the source location of the || on the second 'if'.  */
2522       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2523       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2524                            new_locus);
2525       append_to_statement_list (t, &expr);
2526     }
2527   else if (TREE_CODE (pred) == COND_EXPR)
2528     {
2529       location_t new_locus;
2530
2531       /* As long as we're messing with gotos, turn if (a ? b : c) into
2532          if (a)
2533            if (b) goto yes; else goto no;
2534          else
2535            if (c) goto yes; else goto no;  */
2536
2537       /* Keep the original source location on the first 'if'.  Set the source
2538          location of the ? on the second 'if'.  */
2539       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2540       expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2541                      shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2542                                       false_label_p, locus),
2543                      shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2544                                       false_label_p, new_locus));
2545     }
2546   else
2547     {
2548       expr = build3 (COND_EXPR, void_type_node, pred,
2549                      build_and_jump (true_label_p),
2550                      build_and_jump (false_label_p));
2551       SET_EXPR_LOCATION (expr, locus);
2552     }
2553
2554   if (local_label)
2555     {
2556       t = build1 (LABEL_EXPR, void_type_node, local_label);
2557       append_to_statement_list (t, &expr);
2558     }
2559
2560   return expr;
2561 }
2562
2563 /* Given a conditional expression EXPR with short-circuit boolean
2564    predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2565    predicate appart into the equivalent sequence of conditionals.  */
2566
2567 static tree
2568 shortcut_cond_expr (tree expr)
2569 {
2570   tree pred = TREE_OPERAND (expr, 0);
2571   tree then_ = TREE_OPERAND (expr, 1);
2572   tree else_ = TREE_OPERAND (expr, 2);
2573   tree true_label, false_label, end_label, t;
2574   tree *true_label_p;
2575   tree *false_label_p;
2576   bool emit_end, emit_false, jump_over_else;
2577   bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2578   bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2579
2580   /* First do simple transformations.  */
2581   if (!else_se)
2582     {
2583       /* If there is no 'else', turn
2584            if (a && b) then c
2585          into
2586            if (a) if (b) then c.  */
2587       while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2588         {
2589           /* Keep the original source location on the first 'if'.  */
2590           location_t locus = EXPR_HAS_LOCATION (expr)
2591                              ? EXPR_LOCATION (expr) : input_location;
2592           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2593           /* Set the source location of the && on the second 'if'.  */
2594           if (EXPR_HAS_LOCATION (pred))
2595             SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2596           then_ = shortcut_cond_expr (expr);
2597           then_se = then_ && TREE_SIDE_EFFECTS (then_);
2598           pred = TREE_OPERAND (pred, 0);
2599           expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2600           SET_EXPR_LOCATION (expr, locus);
2601         }
2602     }
2603
2604   if (!then_se)
2605     {
2606       /* If there is no 'then', turn
2607            if (a || b); else d
2608          into
2609            if (a); else if (b); else d.  */
2610       while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2611         {
2612           /* Keep the original source location on the first 'if'.  */
2613           location_t locus = EXPR_HAS_LOCATION (expr)
2614                              ? EXPR_LOCATION (expr) : input_location;
2615           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2616           /* Set the source location of the || on the second 'if'.  */
2617           if (EXPR_HAS_LOCATION (pred))
2618             SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2619           else_ = shortcut_cond_expr (expr);
2620           else_se = else_ && TREE_SIDE_EFFECTS (else_);
2621           pred = TREE_OPERAND (pred, 0);
2622           expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2623           SET_EXPR_LOCATION (expr, locus);
2624         }
2625     }
2626
2627   /* If we're done, great.  */
2628   if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2629       && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2630     return expr;
2631
2632   /* Otherwise we need to mess with gotos.  Change
2633        if (a) c; else d;
2634      to
2635        if (a); else goto no;
2636        c; goto end;
2637        no: d; end:
2638      and recursively gimplify the condition.  */
2639
2640   true_label = false_label = end_label = NULL_TREE;
2641
2642   /* If our arms just jump somewhere, hijack those labels so we don't
2643      generate jumps to jumps.  */
2644
2645   if (then_
2646       && TREE_CODE (then_) == GOTO_EXPR
2647       && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2648     {
2649       true_label = GOTO_DESTINATION (then_);
2650       then_ = NULL;
2651       then_se = false;
2652     }
2653
2654   if (else_
2655       && TREE_CODE (else_) == GOTO_EXPR
2656       && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2657     {
2658       false_label = GOTO_DESTINATION (else_);
2659       else_ = NULL;
2660       else_se = false;
2661     }
2662
2663   /* If we aren't hijacking a label for the 'then' branch, it falls through.  */
2664   if (true_label)
2665     true_label_p = &true_label;
2666   else
2667     true_label_p = NULL;
2668
2669   /* The 'else' branch also needs a label if it contains interesting code.  */
2670   if (false_label || else_se)
2671     false_label_p = &false_label;
2672   else
2673     false_label_p = NULL;
2674
2675   /* If there was nothing else in our arms, just forward the label(s).  */
2676   if (!then_se && !else_se)
2677     return shortcut_cond_r (pred, true_label_p, false_label_p,
2678                             EXPR_HAS_LOCATION (expr)
2679                             ? EXPR_LOCATION (expr) : input_location);
2680
2681   /* If our last subexpression already has a terminal label, reuse it.  */
2682   if (else_se)
2683     t = expr_last (else_);
2684   else if (then_se)
2685     t = expr_last (then_);
2686   else
2687     t = NULL;
2688   if (t && TREE_CODE (t) == LABEL_EXPR)
2689     end_label = LABEL_EXPR_LABEL (t);
2690
2691   /* If we don't care about jumping to the 'else' branch, jump to the end
2692      if the condition is false.  */
2693   if (!false_label_p)
2694     false_label_p = &end_label;
2695
2696   /* We only want to emit these labels if we aren't hijacking them.  */
2697   emit_end = (end_label == NULL_TREE);
2698   emit_false = (false_label == NULL_TREE);
2699
2700   /* We only emit the jump over the else clause if we have to--if the
2701      then clause may fall through.  Otherwise we can wind up with a
2702      useless jump and a useless label at the end of gimplified code,
2703      which will cause us to think that this conditional as a whole
2704      falls through even if it doesn't.  If we then inline a function
2705      which ends with such a condition, that can cause us to issue an
2706      inappropriate warning about control reaching the end of a
2707      non-void function.  */
2708   jump_over_else = block_may_fallthru (then_);
2709
2710   pred = shortcut_cond_r (pred, true_label_p, false_label_p,
2711                           EXPR_HAS_LOCATION (expr)
2712                           ? EXPR_LOCATION (expr) : input_location);
2713
2714   expr = NULL;
2715   append_to_statement_list (pred, &expr);
2716
2717   append_to_statement_list (then_, &expr);
2718   if (else_se)
2719     {
2720       if (jump_over_else)
2721         {
2722           tree last = expr_last (expr);
2723           t = build_and_jump (&end_label);
2724           if (EXPR_HAS_LOCATION (last))
2725             SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
2726           append_to_statement_list (t, &expr);
2727         }
2728       if (emit_false)
2729         {
2730           t = build1 (LABEL_EXPR, void_type_node, false_label);
2731           append_to_statement_list (t, &expr);
2732         }
2733       append_to_statement_list (else_, &expr);
2734     }
2735   if (emit_end && end_label)
2736     {
2737       t = build1 (LABEL_EXPR, void_type_node, end_label);
2738       append_to_statement_list (t, &expr);
2739     }
2740
2741   return expr;
2742 }
2743
2744 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE.  */
2745
2746 tree
2747 gimple_boolify (tree expr)
2748 {
2749   tree type = TREE_TYPE (expr);
2750   location_t loc = EXPR_LOCATION (expr);
2751
2752   if (TREE_CODE (expr) == NE_EXPR
2753       && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
2754       && integer_zerop (TREE_OPERAND (expr, 1)))
2755     {
2756       tree call = TREE_OPERAND (expr, 0);
2757       tree fn = get_callee_fndecl (call);
2758
2759       /* For __builtin_expect ((long) (x), y) recurse into x as well
2760          if x is truth_value_p.  */
2761       if (fn
2762           && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2763           && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
2764           && call_expr_nargs (call) == 2)
2765         {
2766           tree arg = CALL_EXPR_ARG (call, 0);
2767           if (arg)
2768             {
2769               if (TREE_CODE (arg) == NOP_EXPR
2770                   && TREE_TYPE (arg) == TREE_TYPE (call))
2771                 arg = TREE_OPERAND (arg, 0);
2772               if (truth_value_p (TREE_CODE (arg)))
2773                 {
2774                   arg = gimple_boolify (arg);
2775                   CALL_EXPR_ARG (call, 0)
2776                     = fold_convert_loc (loc, TREE_TYPE (call), arg);
2777                 }
2778             }
2779         }
2780     }
2781
2782   if (TREE_CODE (type) == BOOLEAN_TYPE)
2783     return expr;
2784
2785   switch (TREE_CODE (expr))
2786     {
2787     case TRUTH_AND_EXPR:
2788     case TRUTH_OR_EXPR:
2789     case TRUTH_XOR_EXPR:
2790     case TRUTH_ANDIF_EXPR:
2791     case TRUTH_ORIF_EXPR:
2792       /* Also boolify the arguments of truth exprs.  */
2793       TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2794       /* FALLTHRU */
2795
2796     case TRUTH_NOT_EXPR:
2797       TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2798       /* FALLTHRU */
2799
2800     case EQ_EXPR: case NE_EXPR:
2801     case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2802       /* These expressions always produce boolean results.  */
2803       TREE_TYPE (expr) = boolean_type_node;
2804       return expr;
2805
2806     default:
2807       /* Other expressions that get here must have boolean values, but
2808          might need to be converted to the appropriate mode.  */
2809       return fold_convert_loc (loc, boolean_type_node, expr);
2810     }
2811 }
2812
2813 /* Given a conditional expression *EXPR_P without side effects, gimplify
2814    its operands.  New statements are inserted to PRE_P.  */
2815
2816 static enum gimplify_status
2817 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
2818 {
2819   tree expr = *expr_p, cond;
2820   enum gimplify_status ret, tret;
2821   enum tree_code code;
2822
2823   cond = gimple_boolify (COND_EXPR_COND (expr));
2824
2825   /* We need to handle && and || specially, as their gimplification
2826      creates pure cond_expr, thus leading to an infinite cycle otherwise.  */
2827   code = TREE_CODE (cond);
2828   if (code == TRUTH_ANDIF_EXPR)
2829     TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2830   else if (code == TRUTH_ORIF_EXPR)
2831     TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2832   ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
2833   COND_EXPR_COND (*expr_p) = cond;
2834
2835   tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2836                                    is_gimple_val, fb_rvalue);
2837   ret = MIN (ret, tret);
2838   tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2839                                    is_gimple_val, fb_rvalue);
2840
2841   return MIN (ret, tret);
2842 }
2843
2844 /* Returns true if evaluating EXPR could trap.
2845    EXPR is GENERIC, while tree_could_trap_p can be called
2846    only on GIMPLE.  */
2847
2848 static bool
2849 generic_expr_could_trap_p (tree expr)
2850 {
2851   unsigned i, n;
2852
2853   if (!expr || is_gimple_val (expr))
2854     return false;
2855
2856   if (!EXPR_P (expr) || tree_could_trap_p (expr))
2857     return true;
2858
2859   n = TREE_OPERAND_LENGTH (expr);
2860   for (i = 0; i < n; i++)
2861     if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
2862       return true;
2863
2864   return false;
2865 }
2866
2867 /*  Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2868     into
2869
2870     if (p)                      if (p)
2871       t1 = a;                     a;
2872     else                or      else
2873       t1 = b;                     b;
2874     t1;
2875
2876     The second form is used when *EXPR_P is of type void.
2877
2878     PRE_P points to the list where side effects that must happen before
2879       *EXPR_P should be stored.  */
2880
2881 static enum gimplify_status
2882 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
2883 {
2884   tree expr = *expr_p;
2885   tree type = TREE_TYPE (expr);
2886   location_t loc = EXPR_LOCATION (expr);
2887   tree tmp, arm1, arm2;
2888   enum gimplify_status ret;
2889   tree label_true, label_false, label_cont;
2890   bool have_then_clause_p, have_else_clause_p;
2891   gimple gimple_cond;
2892   enum tree_code pred_code;
2893   gimple_seq seq = NULL;
2894
2895   /* If this COND_EXPR has a value, copy the values into a temporary within
2896      the arms.  */
2897   if (!VOID_TYPE_P (type))
2898     {
2899       tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
2900       tree result;
2901
2902       /* If either an rvalue is ok or we do not require an lvalue, create the
2903          temporary.  But we cannot do that if the type is addressable.  */
2904       if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
2905           && !TREE_ADDRESSABLE (type))
2906         {
2907           if (gimplify_ctxp->allow_rhs_cond_expr
2908               /* If either branch has side effects or could trap, it can't be
2909                  evaluated unconditionally.  */
2910               && !TREE_SIDE_EFFECTS (then_)
2911               && !generic_expr_could_trap_p (then_)
2912               && !TREE_SIDE_EFFECTS (else_)
2913               && !generic_expr_could_trap_p (else_))
2914             return gimplify_pure_cond_expr (expr_p, pre_p);
2915
2916           tmp = create_tmp_var (type, "iftmp");
2917           result = tmp;
2918         }
2919
2920       /* Otherwise, only create and copy references to the values.  */
2921       else
2922         {
2923           type = build_pointer_type (type);
2924
2925           if (!VOID_TYPE_P (TREE_TYPE (then_)))
2926             then_ = build_fold_addr_expr_loc (loc, then_);
2927
2928           if (!VOID_TYPE_P (TREE_TYPE (else_)))
2929             else_ = build_fold_addr_expr_loc (loc, else_);
2930  
2931           expr
2932             = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
2933
2934           tmp = create_tmp_var (type, "iftmp");
2935           result = build_fold_indirect_ref_loc (loc, tmp);
2936         }
2937
2938       /* Build the new then clause, `tmp = then_;'.  But don't build the
2939          assignment if the value is void; in C++ it can be if it's a throw.  */
2940       if (!VOID_TYPE_P (TREE_TYPE (then_)))
2941         TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
2942
2943       /* Similarly, build the new else clause, `tmp = else_;'.  */
2944       if (!VOID_TYPE_P (TREE_TYPE (else_)))
2945         TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
2946
2947       TREE_TYPE (expr) = void_type_node;
2948       recalculate_side_effects (expr);
2949
2950       /* Move the COND_EXPR to the prequeue.  */
2951       gimplify_stmt (&expr, pre_p);
2952
2953       *expr_p = result;
2954       return GS_ALL_DONE;
2955     }
2956
2957   /* Make sure the condition has BOOLEAN_TYPE.  */
2958   TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2959
2960   /* Break apart && and || conditions.  */
2961   if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2962       || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2963     {
2964       expr = shortcut_cond_expr (expr);
2965
2966       if (expr != *expr_p)
2967         {
2968           *expr_p = expr;
2969
2970           /* We can't rely on gimplify_expr to re-gimplify the expanded
2971              form properly, as cleanups might cause the target labels to be
2972              wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
2973              set up a conditional context.  */
2974           gimple_push_condition ();
2975           gimplify_stmt (expr_p, &seq);
2976           gimple_pop_condition (pre_p);
2977           gimple_seq_add_seq (pre_p, seq);
2978
2979           return GS_ALL_DONE;
2980         }
2981     }
2982
2983   /* Now do the normal gimplification.  */
2984
2985   /* Gimplify condition.  */
2986   ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
2987                        fb_rvalue);
2988   if (ret == GS_ERROR)
2989     return GS_ERROR;
2990   gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
2991
2992   gimple_push_condition ();
2993
2994   have_then_clause_p = have_else_clause_p = false;
2995   if (TREE_OPERAND (expr, 1) != NULL
2996       && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
2997       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
2998       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
2999           == current_function_decl)
3000       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3001          have different locations, otherwise we end up with incorrect
3002          location information on the branches.  */
3003       && (optimize
3004           || !EXPR_HAS_LOCATION (expr)
3005           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
3006           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
3007     {
3008       label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
3009       have_then_clause_p = true;
3010     }
3011   else
3012     label_true = create_artificial_label (UNKNOWN_LOCATION);
3013   if (TREE_OPERAND (expr, 2) != NULL
3014       && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
3015       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3016       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3017           == current_function_decl)
3018       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3019          have different locations, otherwise we end up with incorrect
3020          location information on the branches.  */
3021       && (optimize
3022           || !EXPR_HAS_LOCATION (expr)
3023           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3024           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3025     {
3026       label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3027       have_else_clause_p = true;
3028     }
3029   else
3030     label_false = create_artificial_label (UNKNOWN_LOCATION);
3031
3032   gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3033                                  &arm2);
3034
3035   gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
3036                                    label_false);
3037
3038   gimplify_seq_add_stmt (&seq, gimple_cond);
3039   label_cont = NULL_TREE;
3040   if (!have_then_clause_p)
3041     {
3042       /* For if (...) {} else { code; } put label_true after
3043          the else block.  */
3044       if (TREE_OPERAND (expr, 1) == NULL_TREE
3045           && !have_else_clause_p
3046           && TREE_OPERAND (expr, 2) != NULL_TREE)
3047         label_cont = label_true;
3048       else
3049         {
3050           gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3051           have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3052           /* For if (...) { code; } else {} or
3053              if (...) { code; } else goto label; or
3054              if (...) { code; return; } else { ... }
3055              label_cont isn't needed.  */
3056           if (!have_else_clause_p
3057               && TREE_OPERAND (expr, 2) != NULL_TREE
3058               && gimple_seq_may_fallthru (seq))
3059             {
3060               gimple g;
3061               label_cont = create_artificial_label (UNKNOWN_LOCATION);
3062
3063               g = gimple_build_goto (label_cont);
3064
3065               /* GIMPLE_COND's are very low level; they have embedded
3066                  gotos.  This particular embedded goto should not be marked
3067                  with the location of the original COND_EXPR, as it would
3068                  correspond to the COND_EXPR's condition, not the ELSE or the
3069                  THEN arms.  To avoid marking it with the wrong location, flag
3070                  it as "no location".  */
3071               gimple_set_do_not_emit_location (g);
3072
3073               gimplify_seq_add_stmt (&seq, g);
3074             }
3075         }
3076     }
3077   if (!have_else_clause_p)
3078     {
3079       gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3080       have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3081     }
3082   if (label_cont)
3083     gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3084
3085   gimple_pop_condition (pre_p);
3086   gimple_seq_add_seq (pre_p, seq);
3087
3088   if (ret == GS_ERROR)
3089     ; /* Do nothing.  */
3090   else if (have_then_clause_p || have_else_clause_p)
3091     ret = GS_ALL_DONE;
3092   else
3093     {
3094       /* Both arms are empty; replace the COND_EXPR with its predicate.  */
3095       expr = TREE_OPERAND (expr, 0);
3096       gimplify_stmt (&expr, pre_p);
3097     }
3098
3099   *expr_p = NULL;
3100   return ret;
3101 }
3102
3103 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3104    to be marked addressable.
3105
3106    We cannot rely on such an expression being directly markable if a temporary
3107    has been created by the gimplification.  In this case, we create another
3108    temporary and initialize it with a copy, which will become a store after we
3109    mark it addressable.  This can happen if the front-end passed us something
3110    that it could not mark addressable yet, like a Fortran pass-by-reference
3111    parameter (int) floatvar.  */
3112
3113 static void
3114 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
3115 {
3116   while (handled_component_p (*expr_p))
3117     expr_p = &TREE_OPERAND (*expr_p, 0);
3118   if (is_gimple_reg (*expr_p))
3119     *expr_p = get_initialized_tmp_var (*expr_p, seq_p, NULL);
3120 }
3121
3122 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3123    a call to __builtin_memcpy.  */
3124
3125 static enum gimplify_status
3126 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3127                                 gimple_seq *seq_p)
3128 {
3129   tree t, to, to_ptr, from, from_ptr;
3130   gimple gs;
3131   location_t loc = EXPR_LOCATION (*expr_p);
3132
3133   to = TREE_OPERAND (*expr_p, 0);
3134   from = TREE_OPERAND (*expr_p, 1);
3135
3136   /* Mark the RHS addressable.  Beware that it may not be possible to do so
3137      directly if a temporary has been created by the gimplification.  */
3138   prepare_gimple_addressable (&from, seq_p);
3139
3140   mark_addressable (from);
3141   from_ptr = build_fold_addr_expr_loc (loc, from);
3142   gimplify_arg (&from_ptr, seq_p, loc);
3143
3144   mark_addressable (to);
3145   to_ptr = build_fold_addr_expr_loc (loc, to);
3146   gimplify_arg (&to_ptr, seq_p, loc);
3147
3148   t = implicit_built_in_decls[BUILT_IN_MEMCPY];
3149
3150   gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3151
3152   if (want_value)
3153     {
3154       /* tmp = memcpy() */
3155       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3156       gimple_call_set_lhs (gs, t);
3157       gimplify_seq_add_stmt (seq_p, gs);
3158
3159       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3160       return GS_ALL_DONE;
3161     }
3162
3163   gimplify_seq_add_stmt (seq_p, gs);
3164   *expr_p = NULL;
3165   return GS_ALL_DONE;
3166 }
3167
3168 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3169    a call to __builtin_memset.  In this case we know that the RHS is
3170    a CONSTRUCTOR with an empty element list.  */
3171
3172 static enum gimplify_status
3173 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3174                                 gimple_seq *seq_p)
3175 {
3176   tree t, from, to, to_ptr;
3177   gimple gs;
3178   location_t loc = EXPR_LOCATION (*expr_p);
3179
3180   /* Assert our assumptions, to abort instead of producing wrong code
3181      silently if they are not met.  Beware that the RHS CONSTRUCTOR might
3182      not be immediately exposed.  */
3183   from = TREE_OPERAND (*expr_p, 1);
3184   if (TREE_CODE (from) == WITH_SIZE_EXPR)
3185     from = TREE_OPERAND (from, 0);
3186
3187   gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3188               && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
3189
3190   /* Now proceed.  */
3191   to = TREE_OPERAND (*expr_p, 0);
3192
3193   to_ptr = build_fold_addr_expr_loc (loc, to);
3194   gimplify_arg (&to_ptr, seq_p, loc);
3195   t = implicit_built_in_decls[BUILT_IN_MEMSET];
3196
3197   gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3198
3199   if (want_value)
3200     {
3201       /* tmp = memset() */
3202       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3203       gimple_call_set_lhs (gs, t);
3204       gimplify_seq_add_stmt (seq_p, gs);
3205
3206       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3207       return GS_ALL_DONE;
3208     }
3209
3210   gimplify_seq_add_stmt (seq_p, gs);
3211   *expr_p = NULL;
3212   return GS_ALL_DONE;
3213 }
3214
3215 /* A subroutine of gimplify_init_ctor_preeval.  Called via walk_tree,
3216    determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3217    assignment.  Returns non-null if we detect a potential overlap.  */
3218
3219 struct gimplify_init_ctor_preeval_data
3220 {
3221   /* The base decl of the lhs object.  May be NULL, in which case we
3222      have to assume the lhs is indirect.  */
3223   tree lhs_base_decl;
3224
3225   /* The alias set of the lhs object.  */
3226   alias_set_type lhs_alias_set;
3227 };
3228
3229 static tree
3230 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3231 {
3232   struct gimplify_init_ctor_preeval_data *data
3233     = (struct gimplify_init_ctor_preeval_data *) xdata;
3234   tree t = *tp;
3235
3236   /* If we find the base object, obviously we have overlap.  */
3237   if (data->lhs_base_decl == t)
3238     return t;
3239
3240   /* If the constructor component is indirect, determine if we have a
3241      potential overlap with the lhs.  The only bits of information we
3242      have to go on at this point are addressability and alias sets.  */
3243   if (TREE_CODE (t) == INDIRECT_REF
3244       && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3245       && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3246     return t;
3247
3248   /* If the constructor component is a call, determine if it can hide a
3249      potential overlap with the lhs through an INDIRECT_REF like above.  */
3250   if (TREE_CODE (t) == CALL_EXPR)
3251     {
3252       tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3253
3254       for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3255         if (POINTER_TYPE_P (TREE_VALUE (type))
3256             && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3257             && alias_sets_conflict_p (data->lhs_alias_set,
3258                                       get_alias_set
3259                                         (TREE_TYPE (TREE_VALUE (type)))))
3260           return t;
3261     }
3262
3263   if (IS_TYPE_OR_DECL_P (t))
3264     *walk_subtrees = 0;
3265   return NULL;
3266 }
3267
3268 /* A subroutine of gimplify_init_constructor.  Pre-evaluate EXPR,
3269    force values that overlap with the lhs (as described by *DATA)
3270    into temporaries.  */
3271
3272 static void
3273 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3274                             struct gimplify_init_ctor_preeval_data *data)
3275 {
3276   enum gimplify_status one;
3277
3278   /* If the value is constant, then there's nothing to pre-evaluate.  */
3279   if (TREE_CONSTANT (*expr_p))
3280     {
3281       /* Ensure it does not have side effects, it might contain a reference to
3282          the object we're initializing.  */
3283       gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3284       return;
3285     }
3286
3287   /* If the type has non-trivial constructors, we can't pre-evaluate.  */
3288   if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3289     return;
3290
3291   /* Recurse for nested constructors.  */
3292   if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3293     {
3294       unsigned HOST_WIDE_INT ix;
3295       constructor_elt *ce;
3296       VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
3297
3298       for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
3299         gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3300
3301       return;
3302     }
3303
3304   /* If this is a variable sized type, we must remember the size.  */
3305   maybe_with_size_expr (expr_p);
3306
3307   /* Gimplify the constructor element to something appropriate for the rhs
3308      of a MODIFY_EXPR.  Given that we know the LHS is an aggregate, we know
3309      the gimplifier will consider this a store to memory.  Doing this
3310      gimplification now means that we won't have to deal with complicated
3311      language-specific trees, nor trees like SAVE_EXPR that can induce
3312      exponential search behavior.  */
3313   one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3314   if (one == GS_ERROR)
3315     {
3316       *expr_p = NULL;
3317       return;
3318     }
3319
3320   /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3321      with the lhs, since "a = { .x=a }" doesn't make sense.  This will
3322      always be true for all scalars, since is_gimple_mem_rhs insists on a
3323      temporary variable for them.  */
3324   if (DECL_P (*expr_p))
3325     return;
3326
3327   /* If this is of variable size, we have no choice but to assume it doesn't
3328      overlap since we can't make a temporary for it.  */
3329   if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3330     return;
3331
3332   /* Otherwise, we must search for overlap ...  */
3333   if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3334     return;
3335
3336   /* ... and if found, force the value into a temporary.  */
3337   *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3338 }
3339
3340 /* A subroutine of gimplify_init_ctor_eval.  Create a loop for
3341    a RANGE_EXPR in a CONSTRUCTOR for an array.
3342
3343       var = lower;
3344     loop_entry:
3345       object[var] = value;
3346       if (var == upper)
3347         goto loop_exit;
3348       var = var + 1;
3349       goto loop_entry;
3350     loop_exit:
3351
3352    We increment var _after_ the loop exit check because we might otherwise
3353    fail if upper == TYPE_MAX_VALUE (type for upper).
3354
3355    Note that we never have to deal with SAVE_EXPRs here, because this has
3356    already been taken care of for us, in gimplify_init_ctor_preeval().  */
3357
3358 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
3359                                      gimple_seq *, bool);
3360
3361 static void
3362 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3363                                tree value, tree array_elt_type,
3364                                gimple_seq *pre_p, bool cleared)
3365 {
3366   tree loop_entry_label, loop_exit_label, fall_thru_label;
3367   tree var, var_type, cref, tmp;
3368
3369   loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
3370   loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
3371   fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
3372
3373   /* Create and initialize the index variable.  */
3374   var_type = TREE_TYPE (upper);
3375   var = create_tmp_var (var_type, NULL);
3376   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3377
3378   /* Add the loop entry label.  */
3379   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3380
3381   /* Build the reference.  */
3382   cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3383                  var, NULL_TREE, NULL_TREE);
3384
3385   /* If we are a constructor, just call gimplify_init_ctor_eval to do
3386      the store.  Otherwise just assign value to the reference.  */
3387
3388   if (TREE_CODE (value) == CONSTRUCTOR)
3389     /* NB we might have to call ourself recursively through
3390        gimplify_init_ctor_eval if the value is a constructor.  */
3391     gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3392                              pre_p, cleared);
3393   else
3394     gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3395
3396   /* We exit the loop when the index var is equal to the upper bound.  */
3397   gimplify_seq_add_stmt (pre_p,
3398                          gimple_build_cond (EQ_EXPR, var, upper,
3399                                             loop_exit_label, fall_thru_label));
3400
3401   gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3402
3403   /* Otherwise, increment the index var...  */
3404   tmp = build2 (PLUS_EXPR, var_type, var,
3405                 fold_convert (var_type, integer_one_node));
3406   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3407
3408   /* ...and jump back to the loop entry.  */
3409   gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3410
3411   /* Add the loop exit label.  */
3412   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3413 }
3414
3415 /* Return true if FDECL is accessing a field that is zero sized.  */
3416
3417 static bool
3418 zero_sized_field_decl (const_tree fdecl)
3419 {
3420   if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3421       && integer_zerop (DECL_SIZE (fdecl)))
3422     return true;
3423   return false;
3424 }
3425
3426 /* Return true if TYPE is zero sized.  */
3427
3428 static bool
3429 zero_sized_type (const_tree type)
3430 {
3431   if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3432       && integer_zerop (TYPE_SIZE (type)))
3433     return true;
3434   return false;
3435 }
3436
3437 /* A subroutine of gimplify_init_constructor.  Generate individual
3438    MODIFY_EXPRs for a CONSTRUCTOR.  OBJECT is the LHS against which the
3439    assignments should happen.  ELTS is the CONSTRUCTOR_ELTS of the
3440    CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
3441    zeroed first.  */
3442
3443 static void
3444 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3445                          gimple_seq *pre_p, bool cleared)
3446 {
3447   tree array_elt_type = NULL;
3448   unsigned HOST_WIDE_INT ix;
3449   tree purpose, value;
3450
3451   if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3452     array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3453
3454   FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3455     {
3456       tree cref;
3457
3458       /* NULL values are created above for gimplification errors.  */
3459       if (value == NULL)
3460         continue;
3461
3462       if (cleared && initializer_zerop (value))
3463         continue;
3464
3465       /* ??? Here's to hoping the front end fills in all of the indices,
3466          so we don't have to figure out what's missing ourselves.  */
3467       gcc_assert (purpose);
3468
3469       /* Skip zero-sized fields, unless value has side-effects.  This can
3470          happen with calls to functions returning a zero-sized type, which
3471          we shouldn't discard.  As a number of downstream passes don't
3472          expect sets of zero-sized fields, we rely on the gimplification of
3473          the MODIFY_EXPR we make below to drop the assignment statement.  */
3474       if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3475         continue;
3476
3477       /* If we have a RANGE_EXPR, we have to build a loop to assign the
3478          whole range.  */
3479       if (TREE_CODE (purpose) == RANGE_EXPR)
3480         {
3481           tree lower = TREE_OPERAND (purpose, 0);
3482           tree upper = TREE_OPERAND (purpose, 1);
3483
3484           /* If the lower bound is equal to upper, just treat it as if
3485              upper was the index.  */
3486           if (simple_cst_equal (lower, upper))
3487             purpose = upper;
3488           else
3489             {
3490               gimplify_init_ctor_eval_range (object, lower, upper, value,
3491                                              array_elt_type, pre_p, cleared);
3492               continue;
3493             }
3494         }
3495
3496       if (array_elt_type)
3497         {
3498           /* Do not use bitsizetype for ARRAY_REF indices.  */
3499           if (TYPE_DOMAIN (TREE_TYPE (object)))
3500             purpose = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3501                                     purpose);
3502           cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3503                          purpose, NULL_TREE, NULL_TREE);
3504         }
3505       else
3506         {
3507           gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3508           cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3509                          unshare_expr (object), purpose, NULL_TREE);
3510         }
3511
3512       if (TREE_CODE (value) == CONSTRUCTOR
3513           && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3514         gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3515                                  pre_p, cleared);
3516       else
3517         {
3518           tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3519           gimplify_and_add (init, pre_p);
3520           ggc_free (init);
3521         }
3522     }
3523 }
3524
3525
3526 /* Returns the appropriate RHS predicate for this LHS.  */
3527
3528 gimple_predicate
3529 rhs_predicate_for (tree lhs)
3530 {
3531   if (is_gimple_reg (lhs))
3532     return is_gimple_reg_rhs_or_call;
3533   else
3534     return is_gimple_mem_rhs_or_call;
3535 }
3536
3537 /* Gimplify a C99 compound literal expression.  This just means adding
3538    the DECL_EXPR before the current statement and using its anonymous
3539    decl instead.  */
3540
3541 static enum gimplify_status
3542 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p)
3543 {
3544   tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
3545   tree decl = DECL_EXPR_DECL (decl_s);
3546   /* Mark the decl as addressable if the compound literal
3547      expression is addressable now, otherwise it is marked too late
3548      after we gimplify the initialization expression.  */
3549   if (TREE_ADDRESSABLE (*expr_p))
3550     TREE_ADDRESSABLE (decl) = 1;
3551
3552   /* Preliminarily mark non-addressed complex variables as eligible
3553      for promotion to gimple registers.  We'll transform their uses
3554      as we find them.  */
3555   if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
3556        || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
3557       && !TREE_THIS_VOLATILE (decl)
3558       && !needs_to_live_in_memory (decl))
3559     DECL_GIMPLE_REG_P (decl) = 1;
3560
3561   /* This decl isn't mentioned in the enclosing block, so add it to the
3562      list of temps.  FIXME it seems a bit of a kludge to say that
3563      anonymous artificial vars aren't pushed, but everything else is.  */
3564   if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
3565     gimple_add_tmp_var (decl);
3566
3567   gimplify_and_add (decl_s, pre_p);
3568   *expr_p = decl;
3569   return GS_OK;
3570 }
3571
3572 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3573    return a new CONSTRUCTOR if something changed.  */
3574
3575 static tree
3576 optimize_compound_literals_in_ctor (tree orig_ctor)
3577 {
3578   tree ctor = orig_ctor;
3579   VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
3580   unsigned int idx, num = VEC_length (constructor_elt, elts);
3581
3582   for (idx = 0; idx < num; idx++)
3583     {
3584       tree value = VEC_index (constructor_elt, elts, idx)->value;
3585       tree newval = value;
3586       if (TREE_CODE (value) == CONSTRUCTOR)
3587         newval = optimize_compound_literals_in_ctor (value);
3588       else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
3589         {
3590           tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
3591           tree decl = DECL_EXPR_DECL (decl_s);
3592           tree init = DECL_INITIAL (decl);
3593
3594           if (!TREE_ADDRESSABLE (value)
3595               && !TREE_ADDRESSABLE (decl)
3596               && init)
3597             newval = optimize_compound_literals_in_ctor (init);