OSDN Git Service

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