OSDN Git Service

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