OSDN Git Service

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