OSDN Git Service

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