OSDN Git Service

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