OSDN Git Service

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