OSDN Git Service

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