OSDN Git Service

55889ea9dcceb0bc0fa5373bfb027362980c7cba
[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_constructor.  Generate individual
2371    MODIFY_EXPRs for a CONSTRUCTOR.  OBJECT is the LHS against which the
2372    assignments should happen.  LIST is the CONSTRUCTOR_ELTS of the
2373    CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
2374    zeroed first.  */
2375
2376 static void
2377 gimplify_init_ctor_eval (tree object, tree list, tree *pre_p, bool cleared)
2378 {
2379   tree array_elt_type = NULL;
2380
2381   if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
2382     array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
2383
2384   for (; list; list = TREE_CHAIN (list))
2385     {
2386       tree purpose, value, cref, init;
2387
2388       purpose = TREE_PURPOSE (list);
2389       value = TREE_VALUE (list);
2390
2391       /* NULL values are created above for gimplification errors.  */
2392       if (value == NULL)
2393         continue;
2394
2395       if (cleared && initializer_zerop (value))
2396         continue;
2397
2398       if (array_elt_type)
2399         {
2400           /* ??? Here's to hoping the front end fills in all of the indicies,
2401              so we don't have to figure out what's missing ourselves.  */
2402           gcc_assert (purpose);
2403           /* ??? Need to handle this.  */
2404           gcc_assert (TREE_CODE (purpose) != RANGE_EXPR);
2405
2406           cref = build (ARRAY_REF, array_elt_type, unshare_expr (object),
2407                         purpose, NULL_TREE, NULL_TREE);
2408         }
2409       else
2410         cref = build (COMPONENT_REF, TREE_TYPE (purpose),
2411                       unshare_expr (object), purpose, NULL_TREE);
2412
2413       if (TREE_CODE (value) == CONSTRUCTOR)
2414         gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2415                                  pre_p, cleared);
2416       else
2417         {
2418           init = build (MODIFY_EXPR, TREE_TYPE (cref), cref, value);
2419           gimplify_and_add (init, pre_p);
2420         }
2421     }
2422 }
2423
2424 /* A subroutine of gimplify_modify_expr.  Break out elements of a
2425    CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
2426
2427    Note that we still need to clear any elements that don't have explicit
2428    initializers, so if not all elements are initialized we keep the
2429    original MODIFY_EXPR, we just remove all of the constructor elements.  */
2430
2431 static enum gimplify_status
2432 gimplify_init_constructor (tree *expr_p, tree *pre_p,
2433                            tree *post_p, bool want_value)
2434 {
2435   tree object;
2436   tree ctor = TREE_OPERAND (*expr_p, 1);
2437   tree type = TREE_TYPE (ctor);
2438   enum gimplify_status ret;
2439   tree elt_list;
2440
2441   if (TREE_CODE (ctor) != CONSTRUCTOR)
2442     return GS_UNHANDLED;
2443
2444   ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
2445                        is_gimple_lvalue, fb_lvalue);
2446   if (ret == GS_ERROR)
2447     return ret;
2448   object = TREE_OPERAND (*expr_p, 0);
2449
2450   elt_list = CONSTRUCTOR_ELTS (ctor);
2451
2452   ret = GS_ALL_DONE;
2453   switch (TREE_CODE (type))
2454     {
2455     case RECORD_TYPE:
2456     case UNION_TYPE:
2457     case QUAL_UNION_TYPE:
2458     case ARRAY_TYPE:
2459       {
2460         struct gimplify_init_ctor_preeval_data preeval_data;
2461         HOST_WIDE_INT num_elements, num_nonzero_elements;
2462         HOST_WIDE_INT num_nonconstant_elements;
2463         bool cleared;
2464
2465         /* Aggregate types must lower constructors to initialization of
2466            individual elements.  The exception is that a CONSTRUCTOR node
2467            with no elements indicates zero-initialization of the whole.  */
2468         if (elt_list == NULL)
2469           break;
2470
2471         categorize_ctor_elements (ctor, &num_nonzero_elements,
2472                                   &num_nonconstant_elements);
2473
2474         /* If a const aggregate variable is being initialized, then it
2475            should never be a lose to promote the variable to be static.  */
2476         if (num_nonconstant_elements == 0
2477             && TREE_READONLY (object)
2478             && TREE_CODE (object) == VAR_DECL)
2479           {
2480             DECL_INITIAL (object) = ctor;
2481             TREE_STATIC (object) = 1;
2482             if (!DECL_NAME (object))
2483               DECL_NAME (object) = create_tmp_var_name ("C");
2484             walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
2485
2486             /* ??? C++ doesn't automatically append a .<number> to the
2487                assembler name, and even when it does, it looks a FE private
2488                data structures to figure out what that number should be,
2489                which are not set for this variable.  I suppose this is
2490                important for local statics for inline functions, which aren't
2491                "local" in the object file sense.  So in order to get a unique
2492                TU-local symbol, we must invoke the lhd version now.  */
2493             lhd_set_decl_assembler_name (object);
2494
2495             *expr_p = NULL_TREE;
2496             break;
2497           }
2498
2499         /* If there are "lots" of initialized elements, and all of them
2500            are valid address constants, then the entire initializer can
2501            be dropped to memory, and then memcpy'd out.  */
2502         if (num_nonconstant_elements == 0)
2503           {
2504             HOST_WIDE_INT size = int_size_in_bytes (type);
2505             unsigned int align;
2506
2507             /* ??? We can still get unbounded array types, at least
2508                from the C++ front end.  This seems wrong, but attempt
2509                to work around it for now.  */
2510             if (size < 0)
2511               {
2512                 size = int_size_in_bytes (TREE_TYPE (object));
2513                 if (size >= 0)
2514                   TREE_TYPE (ctor) = type = TREE_TYPE (object);
2515               }
2516
2517             /* Find the maximum alignment we can assume for the object.  */
2518             /* ??? Make use of DECL_OFFSET_ALIGN.  */
2519             if (DECL_P (object))
2520               align = DECL_ALIGN (object);
2521             else
2522               align = TYPE_ALIGN (type);
2523
2524             if (size > 0 && !can_move_by_pieces (size, align))
2525               {
2526                 tree new = create_tmp_var_raw (type, "C");
2527
2528                 gimple_add_tmp_var (new);
2529                 TREE_STATIC (new) = 1;
2530                 TREE_READONLY (new) = 1;
2531                 DECL_INITIAL (new) = ctor;
2532                 if (align > DECL_ALIGN (new))
2533                   {
2534                     DECL_ALIGN (new) = align;
2535                     DECL_USER_ALIGN (new) = 1;
2536                   }
2537                 walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
2538
2539                 TREE_OPERAND (*expr_p, 1) = new;
2540
2541                 /* This is no longer an assignment of a CONSTRUCTOR, but
2542                    we still may have processing to do on the LHS.  So
2543                    pretend we didn't do anything here to let that happen.  */
2544                 return GS_UNHANDLED;
2545               }
2546           }
2547
2548         /* If there are "lots" of initialized elements, even discounting
2549            those that are not address constants (and thus *must* be
2550            computed at runtime), then partition the constructor into
2551            constant and non-constant parts.  Block copy the constant
2552            parts in, then generate code for the non-constant parts.  */
2553         /* TODO.  There's code in cp/typeck.c to do this.  */
2554
2555         num_elements = count_type_elements (TREE_TYPE (ctor));
2556
2557         /* If there are "lots" of zeros, then block clear the object first.  */
2558         cleared = false;
2559         if (num_elements - num_nonzero_elements > CLEAR_RATIO
2560             && num_nonzero_elements < num_elements/4)
2561           cleared = true;
2562
2563         /* ??? This bit ought not be needed.  For any element not present
2564            in the initializer, we should simply set them to zero.  Except
2565            we'd need to *find* the elements that are not present, and that
2566            requires trickery to avoid quadratic compile-time behavior in
2567            large cases or excessive memory use in small cases.  */
2568         else
2569           {
2570             HOST_WIDE_INT len = list_length (elt_list);
2571             if (TREE_CODE (type) == ARRAY_TYPE)
2572               {
2573                 tree nelts = array_type_nelts (type);
2574                 if (!host_integerp (nelts, 1)
2575                     || tree_low_cst (nelts, 1) + 1 != len)
2576                   cleared = true;
2577               }
2578             else if (len != fields_length (type))
2579               cleared = true;
2580           }
2581
2582         if (cleared)
2583           {
2584             /* Zap the CONSTRUCTOR element list, which simplifies this case.
2585                Note that we still have to gimplify, in order to handle the
2586                case of variable sized types.  Avoid shared tree structures.  */
2587             CONSTRUCTOR_ELTS (ctor) = NULL_TREE;
2588             object = unshare_expr (object);
2589             gimplify_stmt (expr_p);
2590             append_to_statement_list (*expr_p, pre_p);
2591           }
2592
2593         preeval_data.lhs_base_decl = get_base_address (object);
2594         if (!DECL_P (preeval_data.lhs_base_decl))
2595           preeval_data.lhs_base_decl = NULL;
2596         preeval_data.lhs_alias_set = get_alias_set (object);
2597
2598         gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
2599                                     pre_p, post_p, &preeval_data);
2600         gimplify_init_ctor_eval (object, elt_list, pre_p, cleared);
2601
2602         *expr_p = NULL_TREE;
2603       }
2604       break;
2605
2606     case COMPLEX_TYPE:
2607       {
2608         tree r, i;
2609
2610         /* Extract the real and imaginary parts out of the ctor.  */
2611         r = i = NULL_TREE;
2612         if (elt_list)
2613           {
2614             r = TREE_VALUE (elt_list);
2615             elt_list = TREE_CHAIN (elt_list);
2616             if (elt_list)
2617               {
2618                 i = TREE_VALUE (elt_list);
2619                 gcc_assert (!TREE_CHAIN (elt_list));
2620               }
2621           }
2622         if (r == NULL || i == NULL)
2623           {
2624             tree zero = convert (TREE_TYPE (type), integer_zero_node);
2625             if (r == NULL)
2626               r = zero;
2627             if (i == NULL)
2628               i = zero;
2629           }
2630
2631         /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
2632            represent creation of a complex value.  */
2633         if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
2634           {
2635             ctor = build_complex (type, r, i);
2636             TREE_OPERAND (*expr_p, 1) = ctor;
2637           }
2638         else
2639           {
2640             ctor = build (COMPLEX_EXPR, type, r, i);
2641             TREE_OPERAND (*expr_p, 1) = ctor;
2642             ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
2643                                  rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
2644                                  fb_rvalue);
2645           }
2646       }
2647       break;
2648
2649     case VECTOR_TYPE:
2650       /* Go ahead and simplify constant constructors to VECTOR_CST.  */
2651       if (TREE_CONSTANT (ctor))
2652         TREE_OPERAND (*expr_p, 1) = build_vector (type, elt_list);
2653       else
2654         {
2655           /* Vector types use CONSTRUCTOR all the way through gimple
2656              compilation as a general initializer.  */
2657           for (; elt_list; elt_list = TREE_CHAIN (elt_list))
2658             {
2659               enum gimplify_status tret;
2660               tret = gimplify_expr (&TREE_VALUE (elt_list), pre_p, post_p,
2661                                     is_gimple_val, fb_rvalue);
2662               if (tret == GS_ERROR)
2663                 ret = GS_ERROR;
2664             }
2665         }
2666       break;
2667
2668     default:
2669       /* So how did we get a CONSTRUCTOR for a scalar type?  */
2670       gcc_unreachable ();
2671     }
2672
2673   if (ret == GS_ERROR)
2674     return GS_ERROR;
2675   else if (want_value)
2676     {
2677       append_to_statement_list (*expr_p, pre_p);
2678       *expr_p = object;
2679       return GS_OK;
2680     }
2681   else
2682     return GS_ALL_DONE;
2683 }
2684
2685 /* Subroutine of gimplify_modify_expr to do simplifications of MODIFY_EXPRs
2686    based on the code of the RHS.  We loop for as long as something changes.  */
2687
2688 static enum gimplify_status
2689 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
2690                           tree *post_p, bool want_value)
2691 {
2692   enum gimplify_status ret = GS_OK;
2693
2694   while (ret != GS_UNHANDLED)
2695     switch (TREE_CODE (*from_p))
2696       {
2697       case TARGET_EXPR:
2698         {
2699           /* If we are initializing something from a TARGET_EXPR, strip the
2700              TARGET_EXPR and initialize it directly, if possible.  This can't
2701              be done if the initializer is void, since that implies that the
2702              temporary is set in some non-trivial way.
2703
2704              ??? What about code that pulls out the temp and uses it
2705              elsewhere? I think that such code never uses the TARGET_EXPR as
2706              an initializer.  If I'm wrong, we'll abort because the temp won't
2707              have any RTL.  In that case, I guess we'll need to replace
2708              references somehow.  */
2709           tree init = TARGET_EXPR_INITIAL (*from_p);
2710
2711           if (!VOID_TYPE_P (TREE_TYPE (init)))
2712             {
2713               *from_p = init;
2714               ret = GS_OK;
2715             }
2716           else
2717             ret = GS_UNHANDLED;
2718         }
2719         break;
2720
2721       case COMPOUND_EXPR:
2722         /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
2723            caught.  */
2724         gimplify_compound_expr (from_p, pre_p, true);
2725         ret = GS_OK;
2726         break;
2727
2728       case CONSTRUCTOR:
2729         /* If we're initializing from a CONSTRUCTOR, break this into
2730            individual MODIFY_EXPRs.  */
2731         return gimplify_init_constructor (expr_p, pre_p, post_p, want_value);
2732
2733       case COND_EXPR:
2734         /* If we're assigning to a non-register type, push the assignment
2735            down into the branches.  This is mandatory for ADDRESSABLE types,
2736            since we cannot generate temporaries for such, but it saves a
2737            copy in other cases as well.  */
2738         if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
2739           {
2740             *expr_p = *from_p;
2741             return gimplify_cond_expr (expr_p, pre_p, *to_p);
2742           }
2743         else
2744           ret = GS_UNHANDLED;
2745         break;
2746
2747       default:
2748         ret = GS_UNHANDLED;
2749         break;
2750       }
2751
2752   return ret;
2753 }
2754
2755 /* Gimplify the MODIFY_EXPR node pointed by EXPR_P.
2756
2757       modify_expr
2758               : varname '=' rhs
2759               | '*' ID '=' rhs
2760
2761     PRE_P points to the list where side effects that must happen before
2762         *EXPR_P should be stored.
2763
2764     POST_P points to the list where side effects that must happen after
2765         *EXPR_P should be stored.
2766
2767     WANT_VALUE is nonzero iff we want to use the value of this expression
2768         in another expression.  */
2769
2770 static enum gimplify_status
2771 gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
2772 {
2773   tree *from_p = &TREE_OPERAND (*expr_p, 1);
2774   tree *to_p = &TREE_OPERAND (*expr_p, 0);
2775   enum gimplify_status ret = GS_UNHANDLED;
2776
2777   gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
2778               || TREE_CODE (*expr_p) == INIT_EXPR);
2779
2780   /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer useful.  */
2781   if (TREE_CODE (*expr_p) == INIT_EXPR)
2782     TREE_SET_CODE (*expr_p, MODIFY_EXPR);
2783
2784   /* See if any simplifications can be done based on what the RHS is.  */
2785   ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
2786                                   want_value);
2787   if (ret != GS_UNHANDLED)
2788     return ret;
2789
2790   /* If the value being copied is of variable width, compute the length
2791      of the copy into a WITH_SIZE_EXPR.   Note that we need to do this
2792      before gimplifying any of the operands so that we can resolve any
2793      PLACEHOLDER_EXPRs in the size.  Also note that the RTL expander uses
2794      the size of the expression to be copied, not of the destination, so
2795      that is what we must here.  */
2796   maybe_with_size_expr (from_p);
2797
2798   ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2799   if (ret == GS_ERROR)
2800     return ret;
2801
2802   ret = gimplify_expr (from_p, pre_p, post_p,
2803                        rhs_predicate_for (*to_p), fb_rvalue);
2804   if (ret == GS_ERROR)
2805     return ret;
2806
2807   /* Now see if the above changed *from_p to something we handle specially.  */
2808   ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
2809                                   want_value);
2810   if (ret != GS_UNHANDLED)
2811     return ret;
2812
2813   /* If we've got a variable sized assignment between two lvalues (i.e. does
2814      not involve a call), then we can make things a bit more straightforward
2815      by converting the assignment to memcpy or memset.  */
2816   if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
2817     {
2818       tree from = TREE_OPERAND (*from_p, 0);
2819       tree size = TREE_OPERAND (*from_p, 1);
2820
2821       if (TREE_CODE (from) == CONSTRUCTOR)
2822         return gimplify_modify_expr_to_memset (expr_p, size, want_value);
2823       if (is_gimple_addressable (from))
2824         {
2825           *from_p = from;
2826           return gimplify_modify_expr_to_memcpy (expr_p, size, want_value);
2827         }
2828     }
2829
2830   if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
2831     {
2832       /* If we've somehow already got an SSA_NAME on the LHS, then
2833          we're probably modifying it twice.  Not good.  */
2834       gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
2835       *to_p = make_ssa_name (*to_p, *expr_p);
2836     }
2837
2838   if (want_value)
2839     {
2840       append_to_statement_list (*expr_p, pre_p);
2841       *expr_p = *to_p;
2842       return GS_OK;
2843     }
2844
2845   return GS_ALL_DONE;
2846 }
2847
2848 /*  Gimplify a comparison between two variable-sized objects.  Do this
2849     with a call to BUILT_IN_MEMCMP.  */
2850
2851 static enum gimplify_status
2852 gimplify_variable_sized_compare (tree *expr_p)
2853 {
2854   tree op0 = TREE_OPERAND (*expr_p, 0);
2855   tree op1 = TREE_OPERAND (*expr_p, 1);
2856   tree args, t, dest;
2857
2858   t = TYPE_SIZE_UNIT (TREE_TYPE (op0));
2859   t = unshare_expr (t);
2860   t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, op0);
2861   args = tree_cons (NULL, t, NULL);
2862   t = build_fold_addr_expr (op1);
2863   args = tree_cons (NULL, t, args);
2864   dest = build_fold_addr_expr (op0);
2865   args = tree_cons (NULL, dest, args);
2866   t = implicit_built_in_decls[BUILT_IN_MEMCMP];
2867   t = build_function_call_expr (t, args);
2868   *expr_p
2869     = build (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
2870
2871   return GS_OK;
2872 }
2873
2874 /*  Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions.  EXPR_P
2875     points to the expression to gimplify.
2876
2877     Expressions of the form 'a && b' are gimplified to:
2878
2879         a && b ? true : false
2880
2881     gimplify_cond_expr will do the rest.
2882
2883     PRE_P points to the list where side effects that must happen before
2884         *EXPR_P should be stored.  */
2885
2886 static enum gimplify_status
2887 gimplify_boolean_expr (tree *expr_p)
2888 {
2889   /* Preserve the original type of the expression.  */
2890   tree type = TREE_TYPE (*expr_p);
2891
2892   *expr_p = build (COND_EXPR, type, *expr_p,
2893                    convert (type, boolean_true_node),
2894                    convert (type, boolean_false_node));
2895
2896   return GS_OK;
2897 }
2898
2899 /* Gimplifies an expression sequence.  This function gimplifies each
2900    expression and re-writes the original expression with the last
2901    expression of the sequence in GIMPLE form.
2902
2903    PRE_P points to the list where the side effects for all the
2904        expressions in the sequence will be emitted.
2905
2906    WANT_VALUE is true when the result of the last COMPOUND_EXPR is used.  */
2907 /* ??? Should rearrange to share the pre-queue with all the indirect
2908    invocations of gimplify_expr.  Would probably save on creations
2909    of statement_list nodes.  */
2910
2911 static enum gimplify_status
2912 gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value)
2913 {
2914   tree t = *expr_p;
2915
2916   do
2917     {
2918       tree *sub_p = &TREE_OPERAND (t, 0);
2919
2920       if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
2921         gimplify_compound_expr (sub_p, pre_p, false);
2922       else
2923         gimplify_stmt (sub_p);
2924       append_to_statement_list (*sub_p, pre_p);
2925
2926       t = TREE_OPERAND (t, 1);
2927     }
2928   while (TREE_CODE (t) == COMPOUND_EXPR);
2929
2930   *expr_p = t;
2931   if (want_value)
2932     return GS_OK;
2933   else
2934     {
2935       gimplify_stmt (expr_p);
2936       return GS_ALL_DONE;
2937     }
2938 }
2939
2940 /* Gimplifies a statement list.  These may be created either by an
2941    enlightened front-end, or by shortcut_cond_expr.  */
2942
2943 static enum gimplify_status
2944 gimplify_statement_list (tree *expr_p)
2945 {
2946   tree_stmt_iterator i = tsi_start (*expr_p);
2947
2948   while (!tsi_end_p (i))
2949     {
2950       tree t;
2951
2952       gimplify_stmt (tsi_stmt_ptr (i));
2953
2954       t = tsi_stmt (i);
2955       if (t == NULL)
2956         tsi_delink (&i);
2957       else if (TREE_CODE (t) == STATEMENT_LIST)
2958         {
2959           tsi_link_before (&i, t, TSI_SAME_STMT);
2960           tsi_delink (&i);
2961         }
2962       else
2963         tsi_next (&i);
2964     }
2965
2966   return GS_ALL_DONE;
2967 }
2968
2969 /*  Gimplify a SAVE_EXPR node.  EXPR_P points to the expression to
2970     gimplify.  After gimplification, EXPR_P will point to a new temporary
2971     that holds the original value of the SAVE_EXPR node.
2972
2973     PRE_P points to the list where side effects that must happen before
2974         *EXPR_P should be stored.  */
2975
2976 static enum gimplify_status
2977 gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p)
2978 {
2979   enum gimplify_status ret = GS_ALL_DONE;
2980   tree val;
2981
2982   gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
2983   val = TREE_OPERAND (*expr_p, 0);
2984
2985   /* If the SAVE_EXPR has not been resolved, then evaluate it once.  */
2986   if (!SAVE_EXPR_RESOLVED_P (*expr_p))
2987     {
2988       /* The operand may be a void-valued expression such as SAVE_EXPRs
2989          generated by the Java frontend for class initialization.  It is
2990          being executed only for its side-effects.  */
2991       if (TREE_TYPE (val) == void_type_node)
2992         {
2993           ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
2994                                is_gimple_stmt, fb_none);
2995           append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p);
2996           val = NULL;
2997         }
2998       else
2999         val = get_initialized_tmp_var (val, pre_p, post_p);
3000
3001       TREE_OPERAND (*expr_p, 0) = val;
3002       SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
3003     }
3004
3005   *expr_p = val;
3006
3007   return ret;
3008 }
3009
3010 /*  Re-write the ADDR_EXPR node pointed by EXPR_P
3011
3012       unary_expr
3013               : ...
3014               | '&' varname
3015               ...
3016
3017     PRE_P points to the list where side effects that must happen before
3018         *EXPR_P should be stored.
3019
3020     POST_P points to the list where side effects that must happen after
3021         *EXPR_P should be stored.  */
3022
3023 static enum gimplify_status
3024 gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
3025 {
3026   tree expr = *expr_p;
3027   tree op0 = TREE_OPERAND (expr, 0);
3028   enum gimplify_status ret;
3029
3030   switch (TREE_CODE (op0))
3031     {
3032     case INDIRECT_REF:
3033     case MISALIGNED_INDIRECT_REF:
3034     do_indirect_ref:
3035       /* Check if we are dealing with an expression of the form '&*ptr'.
3036          While the front end folds away '&*ptr' into 'ptr', these
3037          expressions may be generated internally by the compiler (e.g.,
3038          builtins like __builtin_va_end).  */
3039       /* Caution: the silent array decomposition semantics we allow for
3040          ADDR_EXPR means we can't always discard the pair.  */
3041       {
3042         tree op00 = TREE_OPERAND (op0, 0);
3043         tree t_expr = TREE_TYPE (expr);
3044         tree t_op00 = TREE_TYPE (op00);
3045
3046         if (!lang_hooks.types_compatible_p (t_expr, t_op00))
3047           {
3048 #ifdef ENABLE_CHECKING
3049             tree t_op0 = TREE_TYPE (op0);
3050             gcc_assert (TREE_CODE (t_op0) == ARRAY_TYPE
3051                         && POINTER_TYPE_P (t_expr)
3052                         && cpt_same_type (TREE_TYPE (t_op0),
3053                                           TREE_TYPE (t_expr))
3054                         && POINTER_TYPE_P (t_op00)
3055                         && cpt_same_type (t_op0, TREE_TYPE (t_op00)));
3056 #endif
3057             op00 = fold_convert (TREE_TYPE (expr), op00);
3058           }
3059         *expr_p = op00;
3060         ret = GS_OK;
3061       }
3062       break;
3063
3064     case VIEW_CONVERT_EXPR:
3065       /* Take the address of our operand and then convert it to the type of
3066          this ADDR_EXPR.
3067
3068          ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
3069          all clear.  The impact of this transformation is even less clear.  */
3070
3071       /* If the operand is a useless conversion, look through it.  Doing so
3072          guarantees that the ADDR_EXPR and its operand will remain of the
3073          same type.  */
3074       if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
3075         op0 = TREE_OPERAND (op0, 0);
3076
3077       *expr_p = fold_convert (TREE_TYPE (expr),
3078                               build_fold_addr_expr (TREE_OPERAND (op0, 0)));
3079       ret = GS_OK;
3080       break;
3081
3082     default:
3083       /* We use fb_either here because the C frontend sometimes takes
3084          the address of a call that returns a struct; see
3085          gcc.dg/c99-array-lval-1.c.  The gimplifier will correctly make
3086          the implied temporary explicit.  */
3087       ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
3088                            is_gimple_addressable, fb_either);
3089       if (ret != GS_ERROR)
3090         {
3091           op0 = TREE_OPERAND (expr, 0);
3092
3093           /* For various reasons, the gimplification of the expression
3094              may have made a new INDIRECT_REF.  */
3095           if (TREE_CODE (op0) == INDIRECT_REF)
3096             goto do_indirect_ref;
3097
3098           /* Make sure TREE_INVARIANT, TREE_CONSTANT, and TREE_SIDE_EFFECTS
3099              is set properly.  */
3100           recompute_tree_invarant_for_addr_expr (expr);
3101
3102           /* Mark the RHS addressable.  */
3103           lang_hooks.mark_addressable (TREE_OPERAND (expr, 0));
3104         }
3105       break;
3106     }
3107
3108   return ret;
3109 }
3110
3111 /* Gimplify the operands of an ASM_EXPR.  Input operands should be a gimple
3112    value; output operands should be a gimple lvalue.  */
3113
3114 static enum gimplify_status
3115 gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p)
3116 {
3117   tree expr = *expr_p;
3118   int noutputs = list_length (ASM_OUTPUTS (expr));
3119   const char **oconstraints
3120     = (const char **) alloca ((noutputs) * sizeof (const char *));
3121   int i;
3122   tree link;
3123   const char *constraint;
3124   bool allows_mem, allows_reg, is_inout;
3125   enum gimplify_status ret, tret;
3126
3127   ASM_STRING (expr)
3128     = resolve_asm_operand_names (ASM_STRING (expr), ASM_OUTPUTS (expr),
3129                                  ASM_INPUTS (expr));
3130
3131   ret = GS_ALL_DONE;
3132   for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link))
3133     {
3134       size_t constraint_len;
3135       oconstraints[i] = constraint
3136         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
3137       constraint_len = strlen (constraint);
3138       if (constraint_len == 0)
3139         continue;
3140
3141       parse_output_constraint (&constraint, i, 0, 0,
3142                                &allows_mem, &allows_reg, &is_inout);
3143
3144       if (!allows_reg && allows_mem)
3145         lang_hooks.mark_addressable (TREE_VALUE (link));
3146
3147       tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3148                             is_inout ? is_gimple_min_lval : is_gimple_lvalue,
3149                             fb_lvalue | fb_mayfail);
3150       if (tret == GS_ERROR)
3151         {
3152           error ("invalid lvalue in asm output %d", i);
3153           ret = tret;
3154         }
3155
3156       if (is_inout)
3157         {
3158           /* An input/output operand.  To give the optimizers more
3159              flexibility, split it into separate input and output
3160              operands.  */
3161           tree input;
3162           char buf[10];
3163
3164           /* Turn the in/out constraint into an output constraint.  */
3165           char *p = xstrdup (constraint);
3166           p[0] = '=';
3167           TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
3168           free (p);
3169
3170           /* And add a matching input constraint.  */
3171           if (allows_reg)
3172             {
3173               sprintf (buf, "%d", i);
3174               input = build_string (strlen (buf), buf);
3175             }
3176           else
3177             input = build_string (constraint_len - 1, constraint + 1);
3178           input = build_tree_list (build_tree_list (NULL_TREE, input),
3179                                    unshare_expr (TREE_VALUE (link)));
3180           ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
3181         }
3182     }
3183
3184   for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link))
3185     {
3186       constraint
3187         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
3188       parse_input_constraint (&constraint, 0, 0, noutputs, 0,
3189                               oconstraints, &allows_mem, &allows_reg);
3190
3191       /* If the operand is a memory input, it should be an lvalue.  */
3192       if (!allows_reg && allows_mem)
3193         {
3194           lang_hooks.mark_addressable (TREE_VALUE (link));
3195           tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3196                                 is_gimple_lvalue, fb_lvalue | fb_mayfail);
3197           if (tret == GS_ERROR)
3198             {
3199               error ("memory input %d is not directly addressable", i);
3200               ret = tret;
3201             }
3202         }
3203       else
3204         {
3205           tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3206                                 is_gimple_asm_val, fb_rvalue);
3207           if (tret == GS_ERROR)
3208             ret = tret;
3209         }
3210     }
3211
3212   return ret;
3213 }
3214
3215 /* Gimplify a CLEANUP_POINT_EXPR.  Currently this works by adding
3216    WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
3217    gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
3218    return to this function.
3219
3220    FIXME should we complexify the prequeue handling instead?  Or use flags
3221    for all the cleanups and let the optimizer tighten them up?  The current
3222    code seems pretty fragile; it will break on a cleanup within any
3223    non-conditional nesting.  But any such nesting would be broken, anyway;
3224    we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
3225    and continues out of it.  We can do that at the RTL level, though, so
3226    having an optimizer to tighten up try/finally regions would be a Good
3227    Thing.  */
3228
3229 static enum gimplify_status
3230 gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p)
3231 {
3232   tree_stmt_iterator iter;
3233   tree body;
3234
3235   tree temp = voidify_wrapper_expr (*expr_p, NULL);
3236
3237   /* We only care about the number of conditions between the innermost
3238      CLEANUP_POINT_EXPR and the cleanup.  So save and reset the count.  */
3239   int old_conds = gimplify_ctxp->conditions;
3240   gimplify_ctxp->conditions = 0;
3241
3242   body = TREE_OPERAND (*expr_p, 0);
3243   gimplify_to_stmt_list (&body);
3244
3245   gimplify_ctxp->conditions = old_conds;
3246
3247   for (iter = tsi_start (body); !tsi_end_p (iter); )
3248     {
3249       tree *wce_p = tsi_stmt_ptr (iter);
3250       tree wce = *wce_p;
3251
3252       if (TREE_CODE (wce) == WITH_CLEANUP_EXPR)
3253         {
3254           if (tsi_one_before_end_p (iter))
3255             {
3256               tsi_link_before (&iter, TREE_OPERAND (wce, 0), TSI_SAME_STMT);
3257               tsi_delink (&iter);
3258               break;
3259             }
3260           else
3261             {
3262               tree sl, tfe;
3263               enum tree_code code;
3264
3265               if (CLEANUP_EH_ONLY (wce))
3266                 code = TRY_CATCH_EXPR;
3267               else
3268                 code = TRY_FINALLY_EXPR;
3269
3270               sl = tsi_split_statement_list_after (&iter);
3271               tfe = build (code, void_type_node, sl, NULL_TREE);
3272               append_to_statement_list (TREE_OPERAND (wce, 0),
3273                                         &TREE_OPERAND (tfe, 1));
3274               *wce_p = tfe;
3275               iter = tsi_start (sl);
3276             }
3277         }
3278       else
3279         tsi_next (&iter);
3280     }
3281
3282   if (temp)
3283     {
3284       *expr_p = temp;
3285       append_to_statement_list (body, pre_p);
3286       return GS_OK;
3287     }
3288   else
3289     {
3290       *expr_p = body;
3291       return GS_ALL_DONE;
3292     }
3293 }
3294
3295 /* Insert a cleanup marker for gimplify_cleanup_point_expr.  CLEANUP
3296    is the cleanup action required.  */
3297
3298 static void
3299 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p)
3300 {
3301   tree wce;
3302
3303   /* Errors can result in improperly nested cleanups.  Which results in
3304      confusion when trying to resolve the WITH_CLEANUP_EXPR.  */
3305   if (errorcount || sorrycount)
3306     return;
3307
3308   if (gimple_conditional_context ())
3309     {
3310       /* If we're in a conditional context, this is more complex.  We only
3311          want to run the cleanup if we actually ran the initialization that
3312          necessitates it, but we want to run it after the end of the
3313          conditional context.  So we wrap the try/finally around the
3314          condition and use a flag to determine whether or not to actually
3315          run the destructor.  Thus
3316
3317            test ? f(A()) : 0
3318
3319          becomes (approximately)
3320
3321            flag = 0;
3322            try {
3323              if (test) { A::A(temp); flag = 1; val = f(temp); }
3324              else { val = 0; }
3325            } finally {
3326              if (flag) A::~A(temp);
3327            }
3328            val
3329       */
3330
3331       tree flag = create_tmp_var (boolean_type_node, "cleanup");
3332       tree ffalse = build (MODIFY_EXPR, void_type_node, flag,
3333                            boolean_false_node);
3334       tree ftrue = build (MODIFY_EXPR, void_type_node, flag,
3335                           boolean_true_node);
3336       cleanup = build (COND_EXPR, void_type_node, flag, cleanup, NULL);
3337       wce = build (WITH_CLEANUP_EXPR, void_type_node, cleanup);
3338       append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups);
3339       append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups);
3340       append_to_statement_list (ftrue, pre_p);
3341
3342       /* Because of this manipulation, and the EH edges that jump
3343          threading cannot redirect, the temporary (VAR) will appear
3344          to be used uninitialized.  Don't warn.  */
3345       TREE_NO_WARNING (var) = 1;
3346     }
3347   else
3348     {
3349       wce = build (WITH_CLEANUP_EXPR, void_type_node, cleanup);
3350       CLEANUP_EH_ONLY (wce) = eh_only;
3351       append_to_statement_list (wce, pre_p);
3352     }
3353
3354   gimplify_stmt (&TREE_OPERAND (wce, 0));
3355 }
3356
3357 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR.  */
3358
3359 static enum gimplify_status
3360 gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p)
3361 {
3362   tree targ = *expr_p;
3363   tree temp = TARGET_EXPR_SLOT (targ);
3364   tree init = TARGET_EXPR_INITIAL (targ);
3365   enum gimplify_status ret;
3366
3367   if (init)
3368     {
3369       /* TARGET_EXPR temps aren't part of the enclosing block, so add it
3370          to the temps list.  */
3371       gimple_add_tmp_var (temp);
3372
3373       /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
3374          expression is supposed to initialize the slot.  */
3375       if (VOID_TYPE_P (TREE_TYPE (init)))
3376         ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
3377       else
3378         {
3379           /* Special handling for BIND_EXPR can result in fewer temps.  */
3380           ret = GS_OK;
3381           if (TREE_CODE (init) == BIND_EXPR)
3382             gimplify_bind_expr (&init, temp, pre_p);
3383           if (init != temp)
3384             {
3385               init = build (MODIFY_EXPR, void_type_node, temp, init);
3386               ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt,
3387                                    fb_none);
3388             }
3389         }
3390       if (ret == GS_ERROR)
3391         return GS_ERROR;
3392       append_to_statement_list (init, pre_p);
3393
3394       /* If needed, push the cleanup for the temp.  */
3395       if (TARGET_EXPR_CLEANUP (targ))
3396         {
3397           gimplify_stmt (&TARGET_EXPR_CLEANUP (targ));
3398           gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
3399                                CLEANUP_EH_ONLY (targ), pre_p);
3400         }
3401
3402       /* Only expand this once.  */
3403       TREE_OPERAND (targ, 3) = init;
3404       TARGET_EXPR_INITIAL (targ) = NULL_TREE;
3405     }
3406   else
3407     /* We should have expanded this before.  */
3408     gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
3409
3410   *expr_p = temp;
3411   return GS_OK;
3412 }
3413
3414 /* Gimplification of expression trees.  */
3415
3416 /* Gimplify an expression which appears at statement context; usually, this
3417    means replacing it with a suitably gimple STATEMENT_LIST.  */
3418
3419 void
3420 gimplify_stmt (tree *stmt_p)
3421 {
3422   gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none);
3423 }
3424
3425 /* Similarly, but force the result to be a STATEMENT_LIST.  */
3426
3427 void
3428 gimplify_to_stmt_list (tree *stmt_p)
3429 {
3430   gimplify_stmt (stmt_p);
3431   if (!*stmt_p)
3432     *stmt_p = alloc_stmt_list ();
3433   else if (TREE_CODE (*stmt_p) != STATEMENT_LIST)
3434     {
3435       tree t = *stmt_p;
3436       *stmt_p = alloc_stmt_list ();
3437       append_to_statement_list (t, stmt_p);
3438     }
3439 }
3440
3441
3442 /*  Gimplifies the expression tree pointed by EXPR_P.  Return 0 if
3443     gimplification failed.
3444
3445     PRE_P points to the list where side effects that must happen before
3446         EXPR should be stored.
3447
3448     POST_P points to the list where side effects that must happen after
3449         EXPR should be stored, or NULL if there is no suitable list.  In
3450         that case, we copy the result to a temporary, emit the
3451         post-effects, and then return the temporary.
3452
3453     GIMPLE_TEST_F points to a function that takes a tree T and
3454         returns nonzero if T is in the GIMPLE form requested by the
3455         caller.  The GIMPLE predicates are in tree-gimple.c.
3456
3457         This test is used twice.  Before gimplification, the test is
3458         invoked to determine whether *EXPR_P is already gimple enough.  If
3459         that fails, *EXPR_P is gimplified according to its code and
3460         GIMPLE_TEST_F is called again.  If the test still fails, then a new
3461         temporary variable is created and assigned the value of the
3462         gimplified expression.
3463
3464     FALLBACK tells the function what sort of a temporary we want.  If the 1
3465         bit is set, an rvalue is OK.  If the 2 bit is set, an lvalue is OK.
3466         If both are set, either is OK, but an lvalue is preferable.
3467
3468     The return value is either GS_ERROR or GS_ALL_DONE, since this function
3469     iterates until solution.  */
3470
3471 enum gimplify_status
3472 gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
3473                bool (* gimple_test_f) (tree), fallback_t fallback)
3474 {
3475   tree tmp;
3476   tree internal_pre = NULL_TREE;
3477   tree internal_post = NULL_TREE;
3478   tree save_expr;
3479   int is_statement = (pre_p == NULL);
3480   location_t saved_location;
3481   enum gimplify_status ret;
3482
3483   save_expr = *expr_p;
3484   if (save_expr == NULL_TREE)
3485     return GS_ALL_DONE;
3486
3487   /* We used to check the predicate here and return immediately if it
3488      succeeds.  This is wrong; the design is for gimplification to be
3489      idempotent, and for the predicates to only test for valid forms, not
3490      whether they are fully simplified.  */
3491
3492   /* Set up our internal queues if needed.  */
3493   if (pre_p == NULL)
3494     pre_p = &internal_pre;
3495   if (post_p == NULL)
3496     post_p = &internal_post;
3497
3498   saved_location = input_location;
3499   if (save_expr != error_mark_node
3500       && EXPR_HAS_LOCATION (*expr_p))
3501     input_location = EXPR_LOCATION (*expr_p);
3502
3503   /* Loop over the specific gimplifiers until the toplevel node
3504      remains the same.  */
3505   do
3506     {
3507       /* Strip away as many useless type conversions as possible
3508          at the toplevel.  */
3509       STRIP_USELESS_TYPE_CONVERSION (*expr_p);
3510
3511       /* Remember the expr.  */
3512       save_expr = *expr_p;
3513
3514       /* Die, die, die, my darling.  */
3515       if (save_expr == error_mark_node
3516           || (TREE_TYPE (save_expr)
3517               && TREE_TYPE (save_expr) == error_mark_node))
3518         {
3519           ret = GS_ERROR;
3520           break;
3521         }
3522
3523       /* Do any language-specific gimplification.  */
3524       ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p);
3525       if (ret == GS_OK)
3526         {
3527           if (*expr_p == NULL_TREE)
3528             break;
3529           if (*expr_p != save_expr)
3530             continue;
3531         }
3532       else if (ret != GS_UNHANDLED)
3533         break;
3534
3535       ret = GS_OK;
3536       switch (TREE_CODE (*expr_p))
3537         {
3538           /* First deal with the special cases.  */
3539
3540         case POSTINCREMENT_EXPR:
3541         case POSTDECREMENT_EXPR:
3542         case PREINCREMENT_EXPR:
3543         case PREDECREMENT_EXPR:
3544           ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
3545                                         fallback != fb_none);
3546           break;
3547
3548         case ARRAY_REF:
3549         case ARRAY_RANGE_REF:
3550         case REALPART_EXPR:
3551         case IMAGPART_EXPR:
3552         case COMPONENT_REF:
3553         case VIEW_CONVERT_EXPR:
3554           ret = gimplify_compound_lval (expr_p, pre_p, post_p,
3555                                         fallback ? fallback : fb_rvalue);
3556           break;
3557
3558         case COND_EXPR:
3559           ret = gimplify_cond_expr (expr_p, pre_p, NULL_TREE);
3560           break;
3561
3562         case CALL_EXPR:
3563           ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
3564           break;
3565
3566         case TREE_LIST:
3567           gcc_unreachable ();
3568
3569         case COMPOUND_EXPR:
3570           ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
3571           break;
3572
3573         case MODIFY_EXPR:
3574         case INIT_EXPR:
3575           ret = gimplify_modify_expr (expr_p, pre_p, post_p,
3576                                       fallback != fb_none);
3577           break;
3578
3579         case TRUTH_ANDIF_EXPR:
3580         case TRUTH_ORIF_EXPR:
3581           ret = gimplify_boolean_expr (expr_p);
3582           break;
3583
3584         case TRUTH_NOT_EXPR:
3585           TREE_OPERAND (*expr_p, 0)
3586             = gimple_boolify (TREE_OPERAND (*expr_p, 0));
3587           ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3588                                is_gimple_val, fb_rvalue);
3589           recalculate_side_effects (*expr_p);
3590           break;
3591
3592         case ADDR_EXPR:
3593           ret = gimplify_addr_expr (expr_p, pre_p, post_p);
3594           break;
3595
3596         case VA_ARG_EXPR:
3597           ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
3598           break;
3599
3600         case CONVERT_EXPR:
3601         case NOP_EXPR:
3602           if (IS_EMPTY_STMT (*expr_p))
3603             {
3604               ret = GS_ALL_DONE;
3605               break;
3606             }
3607
3608           if (VOID_TYPE_P (TREE_TYPE (*expr_p))
3609               || fallback == fb_none)
3610             {
3611               /* Just strip a conversion to void (or in void context) and
3612                  try again.  */
3613               *expr_p = TREE_OPERAND (*expr_p, 0);
3614               break;
3615             }
3616
3617           ret = gimplify_conversion (expr_p);
3618           if (ret == GS_ERROR)
3619             break;
3620           if (*expr_p != save_expr)
3621             break;
3622           /* FALLTHRU */
3623
3624         case FIX_TRUNC_EXPR:
3625         case FIX_CEIL_EXPR:
3626         case FIX_FLOOR_EXPR:
3627         case FIX_ROUND_EXPR:
3628           /* unary_expr: ... | '(' cast ')' val | ...  */
3629           ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3630                                is_gimple_val, fb_rvalue);
3631           recalculate_side_effects (*expr_p);
3632           break;
3633
3634         case ALIGN_INDIRECT_REF:
3635         case MISALIGNED_INDIRECT_REF:
3636         case INDIRECT_REF:
3637           ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3638                                is_gimple_reg, fb_rvalue);
3639           recalculate_side_effects (*expr_p);
3640           break;
3641
3642           /* Constants need not be gimplified.  */
3643         case INTEGER_CST:
3644         case REAL_CST:
3645         case STRING_CST:
3646         case COMPLEX_CST:
3647         case VECTOR_CST:
3648           ret = GS_ALL_DONE;
3649           break;
3650
3651         case CONST_DECL:
3652           /* If we require an lvalue, such as for ADDR_EXPR, retain the
3653              CONST_DECL node.  Otherwise the decl is replaceable by its
3654              value.  */
3655           /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either.  */
3656           if (fallback & fb_lvalue)
3657             ret = GS_ALL_DONE;
3658           else
3659             *expr_p = DECL_INITIAL (*expr_p);
3660           break;
3661
3662         case DECL_EXPR:
3663           ret = gimplify_decl_expr (expr_p);
3664           break;
3665
3666         case EXC_PTR_EXPR:
3667           /* FIXME make this a decl.  */
3668           ret = GS_ALL_DONE;
3669           break;
3670
3671         case BIND_EXPR:
3672           ret = gimplify_bind_expr (expr_p, NULL, pre_p);
3673           break;
3674
3675         case LOOP_EXPR:
3676           ret = gimplify_loop_expr (expr_p, pre_p);
3677           break;
3678
3679         case SWITCH_EXPR:
3680           ret = gimplify_switch_expr (expr_p, pre_p);
3681           break;
3682
3683         case EXIT_EXPR:
3684           ret = gimplify_exit_expr (expr_p);
3685           break;
3686
3687         case GOTO_EXPR:
3688           /* If the target is not LABEL, then it is a computed jump
3689              and the target needs to be gimplified.  */
3690           if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
3691             ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
3692                                  NULL, is_gimple_val, fb_rvalue);
3693           break;
3694
3695         case LABEL_EXPR:
3696           ret = GS_ALL_DONE;
3697           gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
3698                       == current_function_decl);
3699           break;
3700
3701         case CASE_LABEL_EXPR:
3702           ret = gimplify_case_label_expr (expr_p);
3703           break;
3704
3705         case RETURN_EXPR:
3706           ret = gimplify_return_expr (*expr_p, pre_p);
3707           break;
3708
3709         case CONSTRUCTOR:
3710           /* Don't reduce this in place; let gimplify_init_constructor work its
3711              magic.  Buf if we're just elaborating this for side effects, just
3712              gimplify any element that has side-effects.  */
3713           if (fallback == fb_none)
3714             {
3715               for (tmp = CONSTRUCTOR_ELTS (*expr_p); tmp;
3716                    tmp = TREE_CHAIN (tmp))
3717                 if (TREE_SIDE_EFFECTS (TREE_VALUE (tmp)))
3718                   gimplify_expr (&TREE_VALUE (tmp), pre_p, post_p,
3719                                  gimple_test_f, fallback);
3720
3721               *expr_p = NULL_TREE;
3722             }
3723
3724           ret = GS_ALL_DONE;
3725           break;
3726
3727           /* The following are special cases that are not handled by the
3728              original GIMPLE grammar.  */
3729
3730           /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
3731              eliminated.  */
3732         case SAVE_EXPR:
3733           ret = gimplify_save_expr (expr_p, pre_p, post_p);
3734           break;
3735
3736         case BIT_FIELD_REF:
3737           {
3738             enum gimplify_status r0, r1, r2;
3739
3740             r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3741                                 is_gimple_lvalue, fb_either);
3742             r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3743                                 is_gimple_val, fb_rvalue);
3744             r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p,
3745                                 is_gimple_val, fb_rvalue);
3746             recalculate_side_effects (*expr_p);
3747
3748             ret = MIN (r0, MIN (r1, r2));
3749           }
3750           break;
3751
3752         case NON_LVALUE_EXPR:
3753           /* This should have been stripped above.  */
3754           gcc_unreachable ();
3755
3756         case ASM_EXPR:
3757           ret = gimplify_asm_expr (expr_p, pre_p, post_p);
3758           break;
3759
3760         case TRY_FINALLY_EXPR:
3761         case TRY_CATCH_EXPR:
3762           gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0));
3763           gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1));
3764           ret = GS_ALL_DONE;
3765           break;
3766
3767         case CLEANUP_POINT_EXPR:
3768           ret = gimplify_cleanup_point_expr (expr_p, pre_p);
3769           break;
3770
3771         case TARGET_EXPR:
3772           ret = gimplify_target_expr (expr_p, pre_p, post_p);
3773           break;
3774
3775         case CATCH_EXPR:
3776           gimplify_to_stmt_list (&CATCH_BODY (*expr_p));
3777           ret = GS_ALL_DONE;
3778           break;
3779
3780         case EH_FILTER_EXPR:
3781           gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p));
3782           ret = GS_ALL_DONE;
3783           break;
3784
3785         case OBJ_TYPE_REF:
3786           {
3787             enum gimplify_status r0, r1;
3788             r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p,
3789                                 is_gimple_val, fb_rvalue);
3790             r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
3791                                 is_gimple_val, fb_rvalue);
3792             ret = MIN (r0, r1);
3793           }
3794           break;
3795
3796         case LABEL_DECL:
3797           /* We get here when taking the address of a label.  We mark
3798              the label as "forced"; meaning it can never be removed and
3799              it is a potential target for any computed goto.  */
3800           FORCED_LABEL (*expr_p) = 1;
3801           ret = GS_ALL_DONE;
3802           break;
3803
3804         case STATEMENT_LIST:
3805           ret = gimplify_statement_list (expr_p);
3806           break;
3807
3808         case WITH_SIZE_EXPR:
3809           {
3810             enum gimplify_status r0, r1;
3811             r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
3812                                 post_p == &internal_post ? NULL : post_p,
3813                                 gimple_test_f, fallback);
3814             r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3815                                 is_gimple_val, fb_rvalue);
3816           }
3817           break;
3818
3819         case VAR_DECL:
3820           /* ??? If this is a local variable, and it has not been seen in any
3821              outer BIND_EXPR, then it's probably the result of a duplicate
3822              declaration, for which we've already issued an error.  It would
3823              be really nice if the front end wouldn't leak these at all.
3824              Currently the only known culprit is C++ destructors, as seen
3825              in g++.old-deja/g++.jason/binding.C.  */
3826           tmp = *expr_p;
3827           if (!TREE_STATIC (tmp) && !DECL_EXTERNAL (tmp)
3828               && decl_function_context (tmp) == current_function_decl
3829               && !DECL_SEEN_IN_BIND_EXPR_P (tmp))
3830             {
3831               gcc_assert (errorcount || sorrycount);
3832               ret = GS_ERROR;
3833               break;
3834             }
3835           /* FALLTHRU */
3836
3837         case PARM_DECL:
3838           tmp = *expr_p;
3839
3840           /* If this is a local variable sized decl, it must be accessed
3841              indirectly.  Perform that substitution.  */
3842           if (DECL_VALUE_EXPR (tmp))
3843             {
3844               *expr_p = unshare_expr (DECL_VALUE_EXPR (tmp));
3845               ret = GS_OK;
3846               break;
3847             }
3848
3849           ret = GS_ALL_DONE;
3850           break;
3851
3852         case SSA_NAME:
3853           /* Allow callbacks into the gimplifier during optimization.  */
3854           ret = GS_ALL_DONE;
3855           break;
3856
3857         default:
3858           switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
3859             {
3860             case tcc_comparison:
3861               /* If this is a comparison of objects of aggregate type,
3862                  handle it specially (by converting to a call to
3863                  memcmp).  It would be nice to only have to do this
3864                  for variable-sized objects, but then we'd have to
3865                  allow the same nest of reference nodes we allow for
3866                  MODIFY_EXPR and that's too complex.  */
3867               if (!AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 1))))
3868                 goto expr_2;
3869               ret = gimplify_variable_sized_compare (expr_p);
3870               break;
3871
3872             /* If *EXPR_P does not need to be special-cased, handle it
3873                according to its class.  */
3874             case tcc_unary:
3875               ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
3876                                    post_p, is_gimple_val, fb_rvalue);
3877               break;
3878
3879             case tcc_binary:
3880             expr_2:
3881               {
3882                 enum gimplify_status r0, r1;
3883
3884                 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
3885                                     post_p, is_gimple_val, fb_rvalue);
3886                 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
3887                                     post_p, is_gimple_val, fb_rvalue);
3888
3889                 ret = MIN (r0, r1);
3890                 break;
3891               }
3892
3893             case tcc_declaration:
3894             case tcc_constant:
3895               ret = GS_ALL_DONE;
3896               goto dont_recalculate;
3897
3898             default:
3899               gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
3900                           || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
3901                           || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
3902               goto expr_2;
3903             }
3904
3905           recalculate_side_effects (*expr_p);
3906         dont_recalculate:
3907           break;
3908         }
3909
3910       /* If we replaced *expr_p, gimplify again.  */
3911       if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
3912         ret = GS_ALL_DONE;
3913     }
3914   while (ret == GS_OK);
3915
3916   /* If we encountered an error_mark somewhere nested inside, either
3917      stub out the statement or propagate the error back out.  */
3918   if (ret == GS_ERROR)
3919     {
3920       if (is_statement)
3921         *expr_p = NULL;
3922       goto out;
3923     }
3924
3925   /* This was only valid as a return value from the langhook, which
3926      we handled.  Make sure it doesn't escape from any other context.  */
3927   gcc_assert (ret != GS_UNHANDLED);
3928
3929   if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
3930     {
3931       /* We aren't looking for a value, and we don't have a valid
3932          statement.  If it doesn't have side-effects, throw it away.  */
3933       if (!TREE_SIDE_EFFECTS (*expr_p))
3934         *expr_p = NULL;
3935       else if (!TREE_THIS_VOLATILE (*expr_p))
3936         {
3937           /* This is probably a _REF that contains something nested that
3938              has side effects.  Recurse through the operands to find it.  */
3939           enum tree_code code = TREE_CODE (*expr_p);
3940
3941           switch (code)
3942             {
3943             case COMPONENT_REF:
3944             case REALPART_EXPR: case IMAGPART_EXPR:
3945               gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3946                              gimple_test_f, fallback);
3947               break;
3948
3949             case ARRAY_REF: case ARRAY_RANGE_REF:
3950               gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3951                              gimple_test_f, fallback);
3952               gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3953                              gimple_test_f, fallback);
3954               break;
3955
3956             default:
3957                /* Anything else with side-effects must be converted to
3958                   a valid statement before we get here.  */
3959               gcc_unreachable ();
3960             }
3961
3962           *expr_p = NULL;
3963         }
3964       else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p)))
3965         {
3966           /* Historically, the compiler has treated a bare
3967              reference to a volatile lvalue as forcing a load.  */
3968           tree tmp = create_tmp_var (TREE_TYPE (*expr_p), "vol");
3969           *expr_p = build (MODIFY_EXPR, TREE_TYPE (tmp), tmp, *expr_p);
3970         }
3971       else
3972         /* We can't do anything useful with a volatile reference to
3973            incomplete type, so just throw it away.  */
3974         *expr_p = NULL;
3975     }
3976
3977   /* If we are gimplifying at the statement level, we're done.  Tack
3978      everything together and replace the original statement with the
3979      gimplified form.  */
3980   if (fallback == fb_none || is_statement)
3981     {
3982       if (internal_pre || internal_post)
3983         {
3984           append_to_statement_list (*expr_p, &internal_pre);
3985           append_to_statement_list (internal_post, &internal_pre);
3986           annotate_all_with_locus (&internal_pre, input_location);
3987           *expr_p = internal_pre;
3988         }
3989       else if (!*expr_p)
3990         ;
3991       else if (TREE_CODE (*expr_p) == STATEMENT_LIST)
3992         annotate_all_with_locus (expr_p, input_location);
3993       else
3994         annotate_one_with_locus (*expr_p, input_location);
3995       goto out;
3996     }
3997
3998   /* Otherwise we're gimplifying a subexpression, so the resulting value is
3999      interesting.  */
4000
4001   /* If it's sufficiently simple already, we're done.  Unless we are
4002      handling some post-effects internally; if that's the case, we need to
4003      copy into a temp before adding the post-effects to the tree.  */
4004   if (!internal_post && (*gimple_test_f) (*expr_p))
4005     goto out;
4006
4007   /* Otherwise, we need to create a new temporary for the gimplified
4008      expression.  */
4009
4010   /* We can't return an lvalue if we have an internal postqueue.  The
4011      object the lvalue refers to would (probably) be modified by the
4012      postqueue; we need to copy the value out first, which means an
4013      rvalue.  */
4014   if ((fallback & fb_lvalue) && !internal_post
4015       && is_gimple_addressable (*expr_p))
4016     {
4017       /* An lvalue will do.  Take the address of the expression, store it
4018          in a temporary, and replace the expression with an INDIRECT_REF of
4019          that temporary.  */
4020       tmp = build_fold_addr_expr (*expr_p);
4021       gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
4022       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
4023     }
4024   else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_rhs (*expr_p))
4025     {
4026       gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
4027
4028       /* An rvalue will do.  Assign the gimplified expression into a new
4029          temporary TMP and replace the original expression with TMP.  */
4030
4031       if (internal_post || (fallback & fb_lvalue))
4032         /* The postqueue might change the value of the expression between
4033            the initialization and use of the temporary, so we can't use a
4034            formal temp.  FIXME do we care?  */
4035         *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
4036       else
4037         *expr_p = get_formal_tmp_var (*expr_p, pre_p);
4038
4039       if (TREE_CODE (*expr_p) != SSA_NAME)
4040         DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1;
4041     }
4042   else
4043     {
4044 #ifdef ENABLE_CHECKING
4045       if (!(fallback & fb_mayfail))
4046         {
4047           fprintf (stderr, "gimplification failed:\n");
4048           print_generic_expr (stderr, *expr_p, 0);
4049           debug_tree (*expr_p);
4050           internal_error ("gimplification failed");
4051         }
4052 #endif
4053       gcc_assert (fallback & fb_mayfail);
4054       /* If this is an asm statement, and the user asked for the
4055          impossible, don't abort.  Fail and let gimplify_asm_expr
4056          issue an error.  */
4057       ret = GS_ERROR;
4058       goto out;
4059     }
4060
4061   /* Make sure the temporary matches our predicate.  */
4062   gcc_assert ((*gimple_test_f) (*expr_p));
4063
4064   if (internal_post)
4065     {
4066       annotate_all_with_locus (&internal_post, input_location);
4067       append_to_statement_list (internal_post, pre_p);
4068     }
4069
4070  out:
4071   input_location = saved_location;
4072   return ret;
4073 }
4074
4075 /* Look through TYPE for variable-sized objects and gimplify each such
4076    size that we find.  Add to LIST_P any statements generated.  */
4077
4078 void
4079 gimplify_type_sizes (tree type, tree *list_p)
4080 {
4081   tree field;
4082
4083   switch (TREE_CODE (type))
4084     {
4085     case ERROR_MARK:
4086       return;
4087
4088     case INTEGER_TYPE:
4089     case ENUMERAL_TYPE:
4090     case BOOLEAN_TYPE:
4091     case CHAR_TYPE:
4092     case REAL_TYPE:
4093       gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
4094       gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
4095       break;
4096
4097     case ARRAY_TYPE:
4098       /* These anonymous types don't have declarations, so handle them here.  */
4099       gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
4100       break;
4101
4102     case RECORD_TYPE:
4103     case UNION_TYPE:
4104     case QUAL_UNION_TYPE:
4105       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4106         if (TREE_CODE (field) == FIELD_DECL)
4107           gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
4108       break;
4109
4110     default:
4111       break;
4112     }
4113
4114   gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
4115   gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
4116 }
4117
4118 /* Subroutine of the above to gimplify one size or position, *EXPR_P.
4119    We add any required statements to STMT_P.  */
4120
4121 void
4122 gimplify_one_sizepos (tree *expr_p, tree *stmt_p)
4123 {
4124   /* We don't do anything if the value isn't there, is constant, or contains
4125      A PLACEHOLDER_EXPR.  We also don't want to do anything if it's already
4126      a VAR_DECL.  If it's a VAR_DECL from another function, the gimplfier
4127      will want to replace it with a new variable, but that will cause problems
4128      if this type is from outside the function.  It's OK to have that here.  */
4129   if (*expr_p == NULL_TREE || TREE_CONSTANT (*expr_p)
4130       || TREE_CODE (*expr_p) == VAR_DECL
4131       || CONTAINS_PLACEHOLDER_P (*expr_p))
4132     return;
4133
4134   gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
4135 }
4136 \f
4137 #ifdef ENABLE_CHECKING
4138 /* Compare types A and B for a "close enough" match.  */
4139
4140 static bool
4141 cpt_same_type (tree a, tree b)
4142 {
4143   if (lang_hooks.types_compatible_p (a, b))
4144     return true;
4145
4146   /* ??? The C++ FE decomposes METHOD_TYPES to FUNCTION_TYPES and doesn't
4147      link them together.  This routine is intended to catch type errors
4148      that will affect the optimizers, and the optimizers don't add new
4149      dereferences of function pointers, so ignore it.  */
4150   if ((TREE_CODE (a) == FUNCTION_TYPE || TREE_CODE (a) == METHOD_TYPE)
4151       && (TREE_CODE (b) == FUNCTION_TYPE || TREE_CODE (b) == METHOD_TYPE))
4152     return true;
4153
4154   /* ??? The C FE pushes type qualifiers after the fact into the type of
4155      the element from the type of the array.  See build_unary_op's handling
4156      of ADDR_EXPR.  This seems wrong -- if we were going to do this, we
4157      should have done it when creating the variable in the first place.
4158      Alternately, why aren't the two array types made variants?  */
4159   if (TREE_CODE (a) == ARRAY_TYPE && TREE_CODE (b) == ARRAY_TYPE)
4160     return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
4161
4162   /* And because of those, we have to recurse down through pointers.  */
4163   if (POINTER_TYPE_P (a) && POINTER_TYPE_P (b))
4164     return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
4165
4166   return false;
4167 }
4168
4169 /* Check for some cases of the front end missing cast expressions.
4170    The type of a dereference should correspond to the pointer type;
4171    similarly the type of an address should match its object.  */
4172
4173 static tree
4174 check_pointer_types_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
4175                        void *data ATTRIBUTE_UNUSED)
4176 {
4177   tree t = *tp;
4178   tree ptype, otype, dtype;
4179
4180   switch (TREE_CODE (t))
4181     {
4182     case INDIRECT_REF:
4183     case ARRAY_REF:
4184       otype = TREE_TYPE (t);
4185       ptype = TREE_TYPE (TREE_OPERAND (t, 0));
4186       dtype = TREE_TYPE (ptype);
4187       gcc_assert (cpt_same_type (otype, dtype));
4188       break;
4189
4190     case ADDR_EXPR:
4191       ptype = TREE_TYPE (t);
4192       otype = TREE_TYPE (TREE_OPERAND (t, 0));
4193       dtype = TREE_TYPE (ptype);
4194       if (!cpt_same_type (otype, dtype))
4195         {
4196           /* &array is allowed to produce a pointer to the element, rather than
4197              a pointer to the array type.  We must allow this in order to
4198              properly represent assigning the address of an array in C into
4199              pointer to the element type.  */
4200           gcc_assert (TREE_CODE (otype) == ARRAY_TYPE
4201                       && POINTER_TYPE_P (ptype)
4202                       && cpt_same_type (TREE_TYPE (otype), dtype));
4203           break;
4204