OSDN Git Service

* gimplify.c (gimplify_call_expr): Don't set CALL_CANNOT_INLINE_P
[pf3gnuchains/gcc-fork.git] / gcc / gimplify.c
1 /* Tree lowering pass.  This pass converts the GENERIC functions-as-trees
2    tree representation into the GIMPLE form.
3    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4    Free Software Foundation, Inc.
5    Major work done by Sebastian Pop <s.pop@laposte.net>,
6    Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
13 version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3.  If not see
22 <http://www.gnu.org/licenses/>.  */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "tree.h"
29 #include "rtl.h"
30 #include "varray.h"
31 #include "gimple.h"
32 #include "tree-iterator.h"
33 #include "tree-inline.h"
34 #include "diagnostic.h"
35 #include "langhooks.h"
36 #include "langhooks-def.h"
37 #include "tree-flow.h"
38 #include "cgraph.h"
39 #include "timevar.h"
40 #include "except.h"
41 #include "hashtab.h"
42 #include "flags.h"
43 #include "real.h"
44 #include "function.h"
45 #include "output.h"
46 #include "expr.h"
47 #include "ggc.h"
48 #include "toplev.h"
49 #include "target.h"
50 #include "optabs.h"
51 #include "pointer-set.h"
52 #include "splay-tree.h"
53 #include "vec.h"
54 #include "gimple.h"
55
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     p = NULL_TREE;
2359   for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2360     ;
2361
2362   /* If the last argument is __builtin_va_arg_pack () and it is not
2363      passed as a named argument, decrease the number of CALL_EXPR
2364      arguments and set instead the CALL_EXPR_VA_ARG_PACK flag.  */
2365   if (!p
2366       && i < nargs
2367       && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2368     {
2369       tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2370       tree last_arg_fndecl = get_callee_fndecl (last_arg);
2371
2372       if (last_arg_fndecl
2373           && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2374           && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2375           && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2376         {
2377           tree call = *expr_p;
2378
2379           --nargs;
2380           *expr_p = build_call_array (TREE_TYPE (call), CALL_EXPR_FN (call),
2381                                       nargs, CALL_EXPR_ARGP (call));
2382
2383           /* Copy all CALL_EXPR flags, location and block, except
2384              CALL_EXPR_VA_ARG_PACK flag.  */
2385           CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2386           CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2387           CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2388             = CALL_EXPR_RETURN_SLOT_OPT (call);
2389           CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2390           CALL_CANNOT_INLINE_P (*expr_p) = CALL_CANNOT_INLINE_P (call);
2391           SET_EXPR_LOCUS (*expr_p, EXPR_LOCUS (call));
2392           TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2393
2394           /* Set CALL_EXPR_VA_ARG_PACK.  */
2395           CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2396         }
2397     }
2398
2399   /* Finally, gimplify the function arguments.  */
2400   if (nargs > 0)
2401     {
2402       for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2403            PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2404            PUSH_ARGS_REVERSED ? i-- : i++)
2405         {
2406           enum gimplify_status t;
2407
2408           /* Avoid gimplifying the second argument to va_start, which needs to
2409              be the plain PARM_DECL.  */
2410           if ((i != 1) || !builtin_va_start_p)
2411             {
2412               t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2413                                 EXPR_LOCATION (*expr_p));
2414
2415               if (t == GS_ERROR)
2416                 ret = GS_ERROR;
2417             }
2418         }
2419     }
2420
2421   /* Try this again in case gimplification exposed something.  */
2422   if (ret != GS_ERROR)
2423     {
2424       tree new_tree = fold_call_expr (*expr_p, !want_value);
2425
2426       if (new_tree && new_tree != *expr_p)
2427         {
2428           /* There was a transformation of this call which computes the
2429              same value, but in a more efficient way.  Return and try
2430              again.  */
2431           *expr_p = new_tree;
2432           return GS_OK;
2433         }
2434     }
2435   else
2436     {
2437       *expr_p = error_mark_node;
2438       return GS_ERROR;
2439     }
2440
2441   /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2442      decl.  This allows us to eliminate redundant or useless
2443      calls to "const" functions.  */
2444   if (TREE_CODE (*expr_p) == CALL_EXPR)
2445     {
2446       int flags = call_expr_flags (*expr_p);
2447       if (flags & (ECF_CONST | ECF_PURE)
2448           /* An infinite loop is considered a side effect.  */
2449           && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2450         TREE_SIDE_EFFECTS (*expr_p) = 0;
2451     }
2452
2453   /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2454      and clear *EXPR_P.  Otherwise, leave *EXPR_P in its gimplified
2455      form and delegate the creation of a GIMPLE_CALL to
2456      gimplify_modify_expr.  This is always possible because when
2457      WANT_VALUE is true, the caller wants the result of this call into
2458      a temporary, which means that we will emit an INIT_EXPR in
2459      internal_get_tmp_var which will then be handled by
2460      gimplify_modify_expr.  */
2461   if (!want_value)
2462     {
2463       /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2464          have to do is replicate it as a GIMPLE_CALL tuple.  */
2465       call = gimple_build_call_from_tree (*expr_p);
2466       gimplify_seq_add_stmt (pre_p, call);
2467       *expr_p = NULL_TREE;
2468     }
2469
2470   return ret;
2471 }
2472
2473 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2474    rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2475
2476    TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2477    condition is true or false, respectively.  If null, we should generate
2478    our own to skip over the evaluation of this specific expression.
2479
2480    This function is the tree equivalent of do_jump.
2481
2482    shortcut_cond_r should only be called by shortcut_cond_expr.  */
2483
2484 static tree
2485 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p)
2486 {
2487   tree local_label = NULL_TREE;
2488   tree t, expr = NULL;
2489
2490   /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2491      retain the shortcut semantics.  Just insert the gotos here;
2492      shortcut_cond_expr will append the real blocks later.  */
2493   if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2494     {
2495       /* Turn if (a && b) into
2496
2497          if (a); else goto no;
2498          if (b) goto yes; else goto no;
2499          (no:) */
2500
2501       if (false_label_p == NULL)
2502         false_label_p = &local_label;
2503
2504       t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p);
2505       append_to_statement_list (t, &expr);
2506
2507       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2508                            false_label_p);
2509       append_to_statement_list (t, &expr);
2510     }
2511   else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2512     {
2513       /* Turn if (a || b) into
2514
2515          if (a) goto yes;
2516          if (b) goto yes; else goto no;
2517          (yes:) */
2518
2519       if (true_label_p == NULL)
2520         true_label_p = &local_label;
2521
2522       t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL);
2523       append_to_statement_list (t, &expr);
2524
2525       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2526                            false_label_p);
2527       append_to_statement_list (t, &expr);
2528     }
2529   else if (TREE_CODE (pred) == COND_EXPR)
2530     {
2531       /* As long as we're messing with gotos, turn if (a ? b : c) into
2532          if (a)
2533            if (b) goto yes; else goto no;
2534          else
2535            if (c) goto yes; else goto no;  */
2536       expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2537                      shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2538                                       false_label_p),
2539                      shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2540                                       false_label_p));
2541     }
2542   else
2543     {
2544       expr = build3 (COND_EXPR, void_type_node, pred,
2545                      build_and_jump (true_label_p),
2546                      build_and_jump (false_label_p));
2547     }
2548
2549   if (local_label)
2550     {
2551       t = build1 (LABEL_EXPR, void_type_node, local_label);
2552       append_to_statement_list (t, &expr);
2553     }
2554
2555   return expr;
2556 }
2557
2558 /* Given a conditional expression EXPR with short-circuit boolean
2559    predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2560    predicate appart into the equivalent sequence of conditionals.  */
2561
2562 static tree
2563 shortcut_cond_expr (tree expr)
2564 {
2565   tree pred = TREE_OPERAND (expr, 0);
2566   tree then_ = TREE_OPERAND (expr, 1);
2567   tree else_ = TREE_OPERAND (expr, 2);
2568   tree true_label, false_label, end_label, t;
2569   tree *true_label_p;
2570   tree *false_label_p;
2571   bool emit_end, emit_false, jump_over_else;
2572   bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2573   bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2574
2575   /* First do simple transformations.  */
2576   if (!else_se)
2577     {
2578       /* If there is no 'else', turn (a && b) into if (a) if (b).  */
2579       while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2580         {
2581           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2582           then_ = shortcut_cond_expr (expr);
2583           then_se = then_ && TREE_SIDE_EFFECTS (then_);
2584           pred = TREE_OPERAND (pred, 0);
2585           expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2586         }
2587     }
2588
2589   if (!then_se)
2590     {
2591       /* If there is no 'then', turn
2592            if (a || b); else d
2593          into
2594            if (a); else if (b); else d.  */
2595       while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2596         {
2597           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2598           else_ = shortcut_cond_expr (expr);
2599           else_se = else_ && TREE_SIDE_EFFECTS (else_);
2600           pred = TREE_OPERAND (pred, 0);
2601           expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2602         }
2603     }
2604
2605   /* If we're done, great.  */
2606   if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2607       && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2608     return expr;
2609
2610   /* Otherwise we need to mess with gotos.  Change
2611        if (a) c; else d;
2612      to
2613        if (a); else goto no;
2614        c; goto end;
2615        no: d; end:
2616      and recursively gimplify the condition.  */
2617
2618   true_label = false_label = end_label = NULL_TREE;
2619
2620   /* If our arms just jump somewhere, hijack those labels so we don't
2621      generate jumps to jumps.  */
2622
2623   if (then_
2624       && TREE_CODE (then_) == GOTO_EXPR
2625       && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2626     {
2627       true_label = GOTO_DESTINATION (then_);
2628       then_ = NULL;
2629       then_se = false;
2630     }
2631
2632   if (else_
2633       && TREE_CODE (else_) == GOTO_EXPR
2634       && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2635     {
2636       false_label = GOTO_DESTINATION (else_);
2637       else_ = NULL;
2638       else_se = false;
2639     }
2640
2641   /* If we aren't hijacking a label for the 'then' branch, it falls through.  */
2642   if (true_label)
2643     true_label_p = &true_label;
2644   else
2645     true_label_p = NULL;
2646
2647   /* The 'else' branch also needs a label if it contains interesting code.  */
2648   if (false_label || else_se)
2649     false_label_p = &false_label;
2650   else
2651     false_label_p = NULL;
2652
2653   /* If there was nothing else in our arms, just forward the label(s).  */
2654   if (!then_se && !else_se)
2655     return shortcut_cond_r (pred, true_label_p, false_label_p);
2656
2657   /* If our last subexpression already has a terminal label, reuse it.  */
2658   if (else_se)
2659     expr = expr_last (else_);
2660   else if (then_se)
2661     expr = expr_last (then_);
2662   else
2663     expr = NULL;
2664   if (expr && TREE_CODE (expr) == LABEL_EXPR)
2665     end_label = LABEL_EXPR_LABEL (expr);
2666
2667   /* If we don't care about jumping to the 'else' branch, jump to the end
2668      if the condition is false.  */
2669   if (!false_label_p)
2670     false_label_p = &end_label;
2671
2672   /* We only want to emit these labels if we aren't hijacking them.  */
2673   emit_end = (end_label == NULL_TREE);
2674   emit_false = (false_label == NULL_TREE);
2675
2676   /* We only emit the jump over the else clause if we have to--if the
2677      then clause may fall through.  Otherwise we can wind up with a
2678      useless jump and a useless label at the end of gimplified code,
2679      which will cause us to think that this conditional as a whole
2680      falls through even if it doesn't.  If we then inline a function
2681      which ends with such a condition, that can cause us to issue an
2682      inappropriate warning about control reaching the end of a
2683      non-void function.  */
2684   jump_over_else = block_may_fallthru (then_);
2685
2686   pred = shortcut_cond_r (pred, true_label_p, false_label_p);
2687
2688   expr = NULL;
2689   append_to_statement_list (pred, &expr);
2690
2691   append_to_statement_list (then_, &expr);
2692   if (else_se)
2693     {
2694       if (jump_over_else)
2695         {
2696           t = build_and_jump (&end_label);
2697           append_to_statement_list (t, &expr);
2698         }
2699       if (emit_false)
2700         {
2701           t = build1 (LABEL_EXPR, void_type_node, false_label);
2702           append_to_statement_list (t, &expr);
2703         }
2704       append_to_statement_list (else_, &expr);
2705     }
2706   if (emit_end && end_label)
2707     {
2708       t = build1 (LABEL_EXPR, void_type_node, end_label);
2709       append_to_statement_list (t, &expr);
2710     }
2711
2712   return expr;
2713 }
2714
2715 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE.  */
2716
2717 tree
2718 gimple_boolify (tree expr)
2719 {
2720   tree type = TREE_TYPE (expr);
2721
2722   if (TREE_CODE (type) == BOOLEAN_TYPE)
2723     return expr;
2724
2725   switch (TREE_CODE (expr))
2726     {
2727     case TRUTH_AND_EXPR:
2728     case TRUTH_OR_EXPR:
2729     case TRUTH_XOR_EXPR:
2730     case TRUTH_ANDIF_EXPR:
2731     case TRUTH_ORIF_EXPR:
2732       /* Also boolify the arguments of truth exprs.  */
2733       TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2734       /* FALLTHRU */
2735
2736     case TRUTH_NOT_EXPR:
2737       TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2738       /* FALLTHRU */
2739
2740     case EQ_EXPR: case NE_EXPR:
2741     case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2742       /* These expressions always produce boolean results.  */
2743       TREE_TYPE (expr) = boolean_type_node;
2744       return expr;
2745
2746     default:
2747       /* Other expressions that get here must have boolean values, but
2748          might need to be converted to the appropriate mode.  */
2749       return fold_convert (boolean_type_node, expr);
2750     }
2751 }
2752
2753 /* Given a conditional expression *EXPR_P without side effects, gimplify
2754    its operands.  New statements are inserted to PRE_P.  */
2755
2756 static enum gimplify_status
2757 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
2758 {
2759   tree expr = *expr_p, cond;
2760   enum gimplify_status ret, tret;
2761   enum tree_code code;
2762
2763   cond = gimple_boolify (COND_EXPR_COND (expr));
2764
2765   /* We need to handle && and || specially, as their gimplification
2766      creates pure cond_expr, thus leading to an infinite cycle otherwise.  */
2767   code = TREE_CODE (cond);
2768   if (code == TRUTH_ANDIF_EXPR)
2769     TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2770   else if (code == TRUTH_ORIF_EXPR)
2771     TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2772   ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
2773   COND_EXPR_COND (*expr_p) = cond;
2774
2775   tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2776                                    is_gimple_val, fb_rvalue);
2777   ret = MIN (ret, tret);
2778   tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2779                                    is_gimple_val, fb_rvalue);
2780
2781   return MIN (ret, tret);
2782 }
2783
2784 /* Returns true if evaluating EXPR could trap.
2785    EXPR is GENERIC, while tree_could_trap_p can be called
2786    only on GIMPLE.  */
2787
2788 static bool
2789 generic_expr_could_trap_p (tree expr)
2790 {
2791   unsigned i, n;
2792
2793   if (!expr || is_gimple_val (expr))
2794     return false;
2795
2796   if (!EXPR_P (expr) || tree_could_trap_p (expr))
2797     return true;
2798
2799   n = TREE_OPERAND_LENGTH (expr);
2800   for (i = 0; i < n; i++)
2801     if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
2802       return true;
2803
2804   return false;
2805 }
2806
2807 /*  Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2808     into
2809
2810     if (p)                      if (p)
2811       t1 = a;                     a;
2812     else                or      else
2813       t1 = b;                     b;
2814     t1;
2815
2816     The second form is used when *EXPR_P is of type void.
2817
2818     PRE_P points to the list where side effects that must happen before
2819       *EXPR_P should be stored.  */
2820
2821 static enum gimplify_status
2822 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
2823 {
2824   tree expr = *expr_p;
2825   tree tmp, type, arm1, arm2;
2826   enum gimplify_status ret;
2827   tree label_true, label_false, label_cont;
2828   bool have_then_clause_p, have_else_clause_p;
2829   gimple gimple_cond;
2830   enum tree_code pred_code;
2831   gimple_seq seq = NULL;
2832
2833   type = TREE_TYPE (expr);
2834
2835   /* If this COND_EXPR has a value, copy the values into a temporary within
2836      the arms.  */
2837   if (! VOID_TYPE_P (type))
2838     {
2839       tree result;
2840
2841       /* If an rvalue is ok or we do not require an lvalue, avoid creating
2842          an addressable temporary.  */
2843       if (((fallback & fb_rvalue)
2844            || !(fallback & fb_lvalue))
2845           && !TREE_ADDRESSABLE (type))
2846         {
2847           if (gimplify_ctxp->allow_rhs_cond_expr
2848               /* If either branch has side effects or could trap, it can't be
2849                  evaluated unconditionally.  */
2850               && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
2851               && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
2852               && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
2853               && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 2)))
2854             return gimplify_pure_cond_expr (expr_p, pre_p);
2855
2856           result = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
2857           ret = GS_ALL_DONE;
2858         }
2859       else
2860         {
2861           tree type = build_pointer_type (TREE_TYPE (expr));
2862
2863           if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2864             TREE_OPERAND (expr, 1) =
2865               build_fold_addr_expr (TREE_OPERAND (expr, 1));
2866
2867           if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2868             TREE_OPERAND (expr, 2) =
2869               build_fold_addr_expr (TREE_OPERAND (expr, 2));
2870
2871           tmp = create_tmp_var (type, "iftmp");
2872
2873           expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
2874                          TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
2875
2876           result = build_fold_indirect_ref (tmp);
2877         }
2878
2879       /* Build the then clause, 't1 = a;'.  But don't build an assignment
2880          if this branch is void; in C++ it can be, if it's a throw.  */
2881       if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2882         TREE_OPERAND (expr, 1)
2883           = build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 1));
2884
2885       /* Build the else clause, 't1 = b;'.  */
2886       if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2887         TREE_OPERAND (expr, 2)
2888           = build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 2));
2889
2890       TREE_TYPE (expr) = void_type_node;
2891       recalculate_side_effects (expr);
2892
2893       /* Move the COND_EXPR to the prequeue.  */
2894       gimplify_stmt (&expr, pre_p);
2895
2896       *expr_p = result;
2897       return GS_ALL_DONE;
2898     }
2899
2900   /* Make sure the condition has BOOLEAN_TYPE.  */
2901   TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2902
2903   /* Break apart && and || conditions.  */
2904   if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2905       || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2906     {
2907       expr = shortcut_cond_expr (expr);
2908
2909       if (expr != *expr_p)
2910         {
2911           *expr_p = expr;
2912
2913           /* We can't rely on gimplify_expr to re-gimplify the expanded
2914              form properly, as cleanups might cause the target labels to be
2915              wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
2916              set up a conditional context.  */
2917           gimple_push_condition ();
2918           gimplify_stmt (expr_p, &seq);
2919           gimple_pop_condition (pre_p);
2920           gimple_seq_add_seq (pre_p, seq);
2921
2922           return GS_ALL_DONE;
2923         }
2924     }
2925
2926   /* Now do the normal gimplification.  */
2927
2928   /* Gimplify condition.  */
2929   ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
2930                        fb_rvalue);
2931   if (ret == GS_ERROR)
2932     return GS_ERROR;
2933   gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
2934
2935   gimple_push_condition ();
2936
2937   have_then_clause_p = have_else_clause_p = false;
2938   if (TREE_OPERAND (expr, 1) != NULL
2939       && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
2940       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
2941       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
2942           == current_function_decl)
2943       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
2944          have different locations, otherwise we end up with incorrect
2945          location information on the branches.  */
2946       && (optimize
2947           || !EXPR_HAS_LOCATION (expr)
2948           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
2949           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
2950     {
2951       label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
2952       have_then_clause_p = true;
2953     }
2954   else
2955     label_true = create_artificial_label ();
2956   if (TREE_OPERAND (expr, 2) != NULL
2957       && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
2958       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
2959       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
2960           == current_function_decl)
2961       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
2962          have different locations, otherwise we end up with incorrect
2963          location information on the branches.  */
2964       && (optimize
2965           || !EXPR_HAS_LOCATION (expr)
2966           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
2967           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
2968     {
2969       label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
2970       have_else_clause_p = true;
2971     }
2972   else
2973     label_false = create_artificial_label ();
2974
2975   gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
2976                                  &arm2);
2977
2978   gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
2979                                    label_false);
2980
2981   gimplify_seq_add_stmt (&seq, gimple_cond);
2982   label_cont = NULL_TREE;
2983   if (!have_then_clause_p)
2984     {
2985       /* For if (...) {} else { code; } put label_true after
2986          the else block.  */
2987       if (TREE_OPERAND (expr, 1) == NULL_TREE
2988           && !have_else_clause_p
2989           && TREE_OPERAND (expr, 2) != NULL_TREE)
2990         label_cont = label_true;
2991       else
2992         {
2993           gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
2994           have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
2995           /* For if (...) { code; } else {} or
2996              if (...) { code; } else goto label; or
2997              if (...) { code; return; } else { ... }
2998              label_cont isn't needed.  */
2999           if (!have_else_clause_p
3000               && TREE_OPERAND (expr, 2) != NULL_TREE
3001               && gimple_seq_may_fallthru (seq))
3002             {
3003               gimple g;
3004               label_cont = create_artificial_label ();
3005
3006               g = gimple_build_goto (label_cont);
3007
3008               /* GIMPLE_COND's are very low level; they have embedded
3009                  gotos.  This particular embedded goto should not be marked
3010                  with the location of the original COND_EXPR, as it would
3011                  correspond to the COND_EXPR's condition, not the ELSE or the
3012                  THEN arms.  To avoid marking it with the wrong location, flag
3013                  it as "no location".  */
3014               gimple_set_do_not_emit_location (g);
3015
3016               gimplify_seq_add_stmt (&seq, g);
3017             }
3018         }
3019     }
3020   if (!have_else_clause_p)
3021     {
3022       gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3023       have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3024     }
3025   if (label_cont)
3026     gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3027
3028   gimple_pop_condition (pre_p);
3029   gimple_seq_add_seq (pre_p, seq);
3030
3031   if (ret == GS_ERROR)
3032     ; /* Do nothing.  */
3033   else if (have_then_clause_p || have_else_clause_p)
3034     ret = GS_ALL_DONE;
3035   else
3036     {
3037       /* Both arms are empty; replace the COND_EXPR with its predicate.  */
3038       expr = TREE_OPERAND (expr, 0);
3039       gimplify_stmt (&expr, pre_p);
3040     }
3041
3042   *expr_p = NULL;
3043   return ret;
3044 }
3045
3046 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3047    a call to __builtin_memcpy.  */
3048
3049 static enum gimplify_status
3050 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3051                                 gimple_seq *seq_p)
3052 {
3053   tree t, to, to_ptr, from, from_ptr;
3054   gimple gs;
3055
3056   to = TREE_OPERAND (*expr_p, 0);
3057   from = TREE_OPERAND (*expr_p, 1);
3058
3059   from_ptr = build_fold_addr_expr (from);
3060   gimplify_arg (&from_ptr, seq_p, EXPR_LOCATION (*expr_p));
3061
3062   to_ptr = build_fold_addr_expr (to);
3063   gimplify_arg (&to_ptr, seq_p, EXPR_LOCATION (*expr_p));
3064
3065   t = implicit_built_in_decls[BUILT_IN_MEMCPY];
3066
3067   gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3068
3069   if (want_value)
3070     {
3071       /* tmp = memcpy() */
3072       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3073       gimple_call_set_lhs (gs, t);
3074       gimplify_seq_add_stmt (seq_p, gs);
3075
3076       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3077       return GS_ALL_DONE;
3078     }
3079
3080   gimplify_seq_add_stmt (seq_p, gs);
3081   *expr_p = NULL;
3082   return GS_ALL_DONE;
3083 }
3084
3085 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3086    a call to __builtin_memset.  In this case we know that the RHS is
3087    a CONSTRUCTOR with an empty element list.  */
3088
3089 static enum gimplify_status
3090 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3091                                 gimple_seq *seq_p)
3092 {
3093   tree t, from, to, to_ptr;
3094   gimple gs;
3095
3096   /* Assert our assumptions, to abort instead of producing wrong code
3097      silently if they are not met.  Beware that the RHS CONSTRUCTOR might
3098      not be immediately exposed.  */
3099   from = TREE_OPERAND (*expr_p, 1);  
3100   if (TREE_CODE (from) == WITH_SIZE_EXPR)
3101     from = TREE_OPERAND (from, 0);
3102
3103   gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3104               && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
3105
3106   /* Now proceed.  */
3107   to = TREE_OPERAND (*expr_p, 0);
3108
3109   to_ptr = build_fold_addr_expr (to);
3110   gimplify_arg (&to_ptr, seq_p, EXPR_LOCATION (*expr_p));
3111   t = implicit_built_in_decls[BUILT_IN_MEMSET];
3112
3113   gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3114
3115   if (want_value)
3116     {
3117       /* tmp = memset() */
3118       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3119       gimple_call_set_lhs (gs, t);
3120       gimplify_seq_add_stmt (seq_p, gs);
3121
3122       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3123       return GS_ALL_DONE;
3124     }
3125
3126   gimplify_seq_add_stmt (seq_p, gs);
3127   *expr_p = NULL;
3128   return GS_ALL_DONE;
3129 }
3130
3131 /* A subroutine of gimplify_init_ctor_preeval.  Called via walk_tree,
3132    determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3133    assignment.  Returns non-null if we detect a potential overlap.  */
3134
3135 struct gimplify_init_ctor_preeval_data
3136 {
3137   /* The base decl of the lhs object.  May be NULL, in which case we
3138      have to assume the lhs is indirect.  */
3139   tree lhs_base_decl;
3140
3141   /* The alias set of the lhs object.  */
3142   alias_set_type lhs_alias_set;
3143 };
3144
3145 static tree
3146 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3147 {
3148   struct gimplify_init_ctor_preeval_data *data
3149     = (struct gimplify_init_ctor_preeval_data *) xdata;
3150   tree t = *tp;
3151
3152   /* If we find the base object, obviously we have overlap.  */
3153   if (data->lhs_base_decl == t)
3154     return t;
3155
3156   /* If the constructor component is indirect, determine if we have a
3157      potential overlap with the lhs.  The only bits of information we
3158      have to go on at this point are addressability and alias sets.  */
3159   if (TREE_CODE (t) == INDIRECT_REF
3160       && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3161       && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3162     return t;
3163
3164   /* If the constructor component is a call, determine if it can hide a
3165      potential overlap with the lhs through an INDIRECT_REF like above.  */
3166   if (TREE_CODE (t) == CALL_EXPR)
3167     {
3168       tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3169
3170       for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3171         if (POINTER_TYPE_P (TREE_VALUE (type))
3172             && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3173             && alias_sets_conflict_p (data->lhs_alias_set,
3174                                       get_alias_set
3175                                         (TREE_TYPE (TREE_VALUE (type)))))
3176           return t;
3177     }
3178
3179   if (IS_TYPE_OR_DECL_P (t))
3180     *walk_subtrees = 0;
3181   return NULL;
3182 }
3183
3184 /* A subroutine of gimplify_init_constructor.  Pre-evaluate EXPR,
3185    force values that overlap with the lhs (as described by *DATA)
3186    into temporaries.  */
3187
3188 static void
3189 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3190                             struct gimplify_init_ctor_preeval_data *data)
3191 {
3192   enum gimplify_status one;
3193
3194   /* If the value is constant, then there's nothing to pre-evaluate.  */
3195   if (TREE_CONSTANT (*expr_p))
3196     {
3197       /* Ensure it does not have side effects, it might contain a reference to
3198          the object we're initializing.  */
3199       gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3200       return;
3201     }
3202
3203   /* If the type has non-trivial constructors, we can't pre-evaluate.  */
3204   if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3205     return;
3206
3207   /* Recurse for nested constructors.  */
3208   if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3209     {
3210       unsigned HOST_WIDE_INT ix;
3211       constructor_elt *ce;
3212       VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
3213
3214       for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
3215         gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3216
3217       return;
3218     }
3219
3220   /* If this is a variable sized type, we must remember the size.  */
3221   maybe_with_size_expr (expr_p);
3222
3223   /* Gimplify the constructor element to something appropriate for the rhs
3224      of a MODIFY_EXPR.  Given that we know the LHS is an aggregate, we know
3225      the gimplifier will consider this a store to memory.  Doing this
3226      gimplification now means that we won't have to deal with complicated
3227      language-specific trees, nor trees like SAVE_EXPR that can induce
3228      exponential search behavior.  */
3229   one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3230   if (one == GS_ERROR)
3231     {
3232       *expr_p = NULL;
3233       return;
3234     }
3235
3236   /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3237      with the lhs, since "a = { .x=a }" doesn't make sense.  This will
3238      always be true for all scalars, since is_gimple_mem_rhs insists on a
3239      temporary variable for them.  */
3240   if (DECL_P (*expr_p))
3241     return;
3242
3243   /* If this is of variable size, we have no choice but to assume it doesn't
3244      overlap since we can't make a temporary for it.  */
3245   if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3246     return;
3247
3248   /* Otherwise, we must search for overlap ...  */
3249   if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3250     return;
3251
3252   /* ... and if found, force the value into a temporary.  */
3253   *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3254 }
3255
3256 /* A subroutine of gimplify_init_ctor_eval.  Create a loop for
3257    a RANGE_EXPR in a CONSTRUCTOR for an array.
3258
3259       var = lower;
3260     loop_entry:
3261       object[var] = value;
3262       if (var == upper)
3263         goto loop_exit;
3264       var = var + 1;
3265       goto loop_entry;
3266     loop_exit:
3267
3268    We increment var _after_ the loop exit check because we might otherwise
3269    fail if upper == TYPE_MAX_VALUE (type for upper).
3270
3271    Note that we never have to deal with SAVE_EXPRs here, because this has
3272    already been taken care of for us, in gimplify_init_ctor_preeval().  */
3273
3274 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
3275                                      gimple_seq *, bool);
3276
3277 static void
3278 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3279                                tree value, tree array_elt_type,
3280                                gimple_seq *pre_p, bool cleared)
3281 {
3282   tree loop_entry_label, loop_exit_label, fall_thru_label;
3283   tree var, var_type, cref, tmp;
3284
3285   loop_entry_label = create_artificial_label ();
3286   loop_exit_label = create_artificial_label ();
3287   fall_thru_label = create_artificial_label ();
3288
3289   /* Create and initialize the index variable.  */
3290   var_type = TREE_TYPE (upper);
3291   var = create_tmp_var (var_type, NULL);
3292   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3293
3294   /* Add the loop entry label.  */
3295   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3296
3297   /* Build the reference.  */
3298   cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3299                  var, NULL_TREE, NULL_TREE);
3300
3301   /* If we are a constructor, just call gimplify_init_ctor_eval to do
3302      the store.  Otherwise just assign value to the reference.  */
3303
3304   if (TREE_CODE (value) == CONSTRUCTOR)
3305     /* NB we might have to call ourself recursively through
3306        gimplify_init_ctor_eval if the value is a constructor.  */
3307     gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3308                              pre_p, cleared);
3309   else
3310     gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3311
3312   /* We exit the loop when the index var is equal to the upper bound.  */
3313   gimplify_seq_add_stmt (pre_p,
3314                          gimple_build_cond (EQ_EXPR, var, upper,
3315                                             loop_exit_label, fall_thru_label));
3316
3317   gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3318
3319   /* Otherwise, increment the index var...  */
3320   tmp = build2 (PLUS_EXPR, var_type, var,
3321                 fold_convert (var_type, integer_one_node));
3322   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3323
3324   /* ...and jump back to the loop entry.  */
3325   gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3326
3327   /* Add the loop exit label.  */
3328   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3329 }
3330
3331 /* Return true if FDECL is accessing a field that is zero sized.  */
3332    
3333 static bool
3334 zero_sized_field_decl (const_tree fdecl)
3335 {
3336   if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl) 
3337       && integer_zerop (DECL_SIZE (fdecl)))
3338     return true;
3339   return false;
3340 }
3341
3342 /* Return true if TYPE is zero sized.  */
3343    
3344 static bool
3345 zero_sized_type (const_tree type)
3346 {
3347   if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3348       && integer_zerop (TYPE_SIZE (type)))
3349     return true;
3350   return false;
3351 }
3352
3353 /* A subroutine of gimplify_init_constructor.  Generate individual
3354    MODIFY_EXPRs for a CONSTRUCTOR.  OBJECT is the LHS against which the
3355    assignments should happen.  ELTS is the CONSTRUCTOR_ELTS of the
3356    CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
3357    zeroed first.  */
3358
3359 static void
3360 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3361                          gimple_seq *pre_p, bool cleared)
3362 {
3363   tree array_elt_type = NULL;
3364   unsigned HOST_WIDE_INT ix;
3365   tree purpose, value;
3366
3367   if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3368     array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3369
3370   FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3371     {
3372       tree cref;
3373
3374       /* NULL values are created above for gimplification errors.  */
3375       if (value == NULL)
3376         continue;
3377
3378       if (cleared && initializer_zerop (value))
3379         continue;
3380
3381       /* ??? Here's to hoping the front end fills in all of the indices,
3382          so we don't have to figure out what's missing ourselves.  */
3383       gcc_assert (purpose);
3384
3385       /* Skip zero-sized fields, unless value has side-effects.  This can
3386          happen with calls to functions returning a zero-sized type, which
3387          we shouldn't discard.  As a number of downstream passes don't
3388          expect sets of zero-sized fields, we rely on the gimplification of
3389          the MODIFY_EXPR we make below to drop the assignment statement.  */
3390       if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3391         continue;
3392
3393       /* If we have a RANGE_EXPR, we have to build a loop to assign the
3394          whole range.  */
3395       if (TREE_CODE (purpose) == RANGE_EXPR)
3396         {
3397           tree lower = TREE_OPERAND (purpose, 0);
3398           tree upper = TREE_OPERAND (purpose, 1);
3399
3400           /* If the lower bound is equal to upper, just treat it as if
3401              upper was the index.  */
3402           if (simple_cst_equal (lower, upper))
3403             purpose = upper;
3404           else
3405             {
3406               gimplify_init_ctor_eval_range (object, lower, upper, value,
3407                                              array_elt_type, pre_p, cleared);
3408               continue;
3409             }
3410         }
3411
3412       if (array_elt_type)
3413         {
3414           /* Do not use bitsizetype for ARRAY_REF indices.  */
3415           if (TYPE_DOMAIN (TREE_TYPE (object)))
3416             purpose = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3417                                     purpose);
3418           cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3419                          purpose, NULL_TREE, NULL_TREE);
3420         }
3421       else
3422         {
3423           gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3424           cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3425                          unshare_expr (object), purpose, NULL_TREE);
3426         }
3427
3428       if (TREE_CODE (value) == CONSTRUCTOR
3429           && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3430         gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3431                                  pre_p, cleared);
3432       else
3433         {
3434           tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3435           gimplify_and_add (init, pre_p);
3436           ggc_free (init);
3437         }
3438     }
3439 }
3440
3441
3442 /* Returns the appropriate RHS predicate for this LHS.  */
3443
3444 gimple_predicate
3445 rhs_predicate_for (tree lhs)
3446 {
3447   if (is_gimple_formal_tmp_var (lhs))
3448     return is_gimple_formal_tmp_or_call_rhs;
3449   else if (is_gimple_reg (lhs))
3450     return is_gimple_reg_or_call_rhs;
3451   else
3452     return is_gimple_mem_or_call_rhs;
3453 }
3454
3455
3456 /* A subroutine of gimplify_modify_expr.  Break out elements of a
3457    CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3458
3459    Note that we still need to clear any elements that don't have explicit
3460    initializers, so if not all elements are initialized we keep the
3461    original MODIFY_EXPR, we just remove all of the constructor elements.
3462
3463    If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3464    GS_ERROR if we would have to create a temporary when gimplifying
3465    this constructor.  Otherwise, return GS_OK.
3466
3467    If NOTIFY_TEMP_CREATION is false, just do the gimplification.  */
3468
3469 static enum gimplify_status
3470 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3471                            bool want_value, bool notify_temp_creation)
3472 {
3473   tree object;
3474   tree ctor = TREE_OPERAND (*expr_p, 1);
3475   tree type = TREE_TYPE (ctor);
3476   enum gimplify_status ret;
3477   VEC(constructor_elt,gc) *elts;
3478
3479   if (TREE_CODE (ctor) != CONSTRUCTOR)
3480     return GS_UNHANDLED;
3481
3482   if (!notify_temp_creation)
3483     {
3484       ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3485                            is_gimple_lvalue, fb_lvalue);
3486       if (ret == GS_ERROR)
3487         return ret;
3488     }
3489
3490   object = TREE_OPERAND (*expr_p, 0);
3491   elts = CONSTRUCTOR_ELTS (ctor);
3492   ret = GS_ALL_DONE;
3493
3494   switch (TREE_CODE (type))
3495     {
3496     case RECORD_TYPE:
3497     case UNION_TYPE:
3498     case QUAL_UNION_TYPE:
3499     case ARRAY_TYPE:
3500       {
3501         struct gimplify_init_ctor_preeval_data preeval_data;
3502         HOST_WIDE_INT num_type_elements, num_ctor_elements;
3503         HOST_WIDE_INT num_nonzero_elements;
3504         bool cleared, valid_const_initializer;
3505
3506         /* Aggregate types must lower constructors to initialization of
3507            individual elements.  The exception is that a CONSTRUCTOR node
3508            with no elements indicates zero-initialization of the whole.  */
3509         if (VEC_empty (constructor_elt, elts))
3510           {
3511             if (notify_temp_creation)
3512               return GS_OK;
3513             break;
3514           }
3515  
3516         /* Fetch information about the constructor to direct later processing.
3517            We might want to make static versions of it in various cases, and
3518            can only do so if it known to be a valid constant initializer.  */
3519         valid_const_initializer
3520           = categorize_ctor_elements (ctor, &num_nonzero_elements,
3521                                       &num_ctor_elements, &cleared);
3522
3523         /* If a const aggregate variable is being initialized, then it
3524            should never be a lose to promote the variable to be static.  */
3525         if (valid_const_initializer
3526             && num_nonzero_elements > 1
3527             && TREE_READONLY (object)
3528             && TREE_CODE (object) == VAR_DECL
3529             && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
3530           {
3531             if (notify_temp_creation)
3532               return GS_ERROR;
3533             DECL_INITIAL (object) = ctor;
3534             TREE_STATIC (object) = 1;
3535             if (!DECL_NAME (object))
3536               DECL_NAME (object) = create_tmp_var_name ("C");
3537             walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
3538
3539             /* ??? C++ doesn't automatically append a .<number> to the
3540                assembler name, and even when it does, it looks a FE private
3541                data structures to figure out what that number should be,
3542                which are not set for this variable.  I suppose this is
3543                important for local statics for inline functions, which aren't
3544                "local" in the object file sense.  So in order to get a unique
3545                TU-local symbol, we must invoke the lhd version now.  */
3546             lhd_set_decl_assembler_name (object);
3547
3548             *expr_p = NULL_TREE;
3549             break;
3550           }
3551
3552         /* If there are "lots" of initialized elements, even discounting
3553            those that are not address constants (and thus *must* be
3554            computed at runtime), then partition the constructor into
3555            constant and non-constant parts.  Block copy the constant
3556            parts in, then generate code for the non-constant parts.  */
3557         /* TODO.  There's code in cp/typeck.c to do this.  */
3558
3559         num_type_elements = count_type_elements (type, true);
3560
3561         /* If count_type_elements could not determine number of type elements
3562            for a constant-sized object, assume clearing is needed.
3563            Don't do this for variable-sized objects, as store_constructor
3564            will ignore the clearing of variable-sized objects.  */
3565         if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
3566           cleared = true;
3567         /* If there are "lots" of zeros, then block clear the object first.  */
3568         else if (num_type_elements - num_nonzero_elements
3569                  > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
3570                  && num_nonzero_elements < num_type_elements/4)
3571           cleared = true;
3572         /* ??? This bit ought not be needed.  For any element not present
3573            in the initializer, we should simply set them to zero.  Except
3574            we'd need to *find* the elements that are not present, and that
3575            requires trickery to avoid quadratic compile-time behavior in
3576            large cases or excessive memory use in small cases.  */
3577         else if (num_ctor_elements < num_type_elements)
3578           cleared = true;
3579
3580         /* If there are "lots" of initialized elements, and all of them
3581            are valid address constants, then the entire initializer can
3582            be dropped to memory, and then memcpy'd out.  Don't do this
3583            for sparse arrays, though, as it's more efficient to follow
3584            the standard CONSTRUCTOR behavior of memset followed by
3585            individual element initialization.  Also don't do this for small
3586            all-zero initializers (which aren't big enough to merit
3587            clearing), and don't try to make bitwise copies of
3588            TREE_ADDRESSABLE types.  */
3589         if (valid_const_initializer
3590             && !(cleared || num_nonzero_elements == 0)
3591             && !TREE_ADDRESSABLE (type))
3592           {
3593             HOST_WIDE_INT size = int_size_in_bytes (type);
3594             unsigned int align;
3595
3596             /* ??? We can still get unbounded array types, at least
3597                from the C++ front end.  This seems wrong, but attempt
3598                to work around it for now.  */
3599             if (size < 0)
3600               {
3601                 size = int_size_in_bytes (TREE_TYPE (object));
3602                 if (size >= 0)
3603                   TREE_TYPE (ctor) = type = TREE_TYPE (object);
3604               }
3605
3606             /* Find the maximum alignment we can assume for the object.  */
3607             /* ??? Make use of DECL_OFFSET_ALIGN.  */
3608             if (DECL_P (object))
3609               align = DECL_ALIGN (object);
3610             else
3611               align = TYPE_ALIGN (type);
3612