OSDN Git Service

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