OSDN Git Service

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