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