OSDN Git Service

gcc/ChangeLog:
[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       || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1233     result = result_decl;
1234   else if (gimplify_ctxp->return_temp)
1235     result = gimplify_ctxp->return_temp;
1236   else
1237     {
1238       result = create_tmp_reg (TREE_TYPE (result_decl), NULL);
1239
1240       /* ??? With complex control flow (usually involving abnormal edges),
1241          we can wind up warning about an uninitialized value for this.  Due
1242          to how this variable is constructed and initialized, this is never
1243          true.  Give up and never warn.  */
1244       TREE_NO_WARNING (result) = 1;
1245
1246       gimplify_ctxp->return_temp = result;
1247     }
1248
1249   /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1250      Then gimplify the whole thing.  */
1251   if (result != result_decl)
1252     TREE_OPERAND (ret_expr, 0) = result;
1253
1254   gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1255
1256   ret = gimple_build_return (result);
1257   gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1258   gimplify_seq_add_stmt (pre_p, ret);
1259
1260   return GS_ALL_DONE;
1261 }
1262
1263 static void
1264 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1265 {
1266   /* This is a variable-sized decl.  Simplify its size and mark it
1267      for deferred expansion.  Note that mudflap depends on the format
1268      of the emitted code: see mx_register_decls().  */
1269   tree t, addr, ptr_type;
1270
1271   gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1272   gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1273
1274   /* All occurrences of this decl in final gimplified code will be
1275      replaced by indirection.  Setting DECL_VALUE_EXPR does two
1276      things: First, it lets the rest of the gimplifier know what
1277      replacement to use.  Second, it lets the debug info know
1278      where to find the value.  */
1279   ptr_type = build_pointer_type (TREE_TYPE (decl));
1280   addr = create_tmp_var (ptr_type, get_name (decl));
1281   DECL_IGNORED_P (addr) = 0;
1282   t = build_fold_indirect_ref (addr);
1283   SET_DECL_VALUE_EXPR (decl, t);
1284   DECL_HAS_VALUE_EXPR_P (decl) = 1;
1285
1286   t = built_in_decls[BUILT_IN_ALLOCA];
1287   t = build_call_expr (t, 1, DECL_SIZE_UNIT (decl));
1288   t = fold_convert (ptr_type, t);
1289   t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1290
1291   gimplify_and_add (t, seq_p);
1292
1293   /* Indicate that we need to restore the stack level when the
1294      enclosing BIND_EXPR is exited.  */
1295   gimplify_ctxp->save_stack = true;
1296 }
1297
1298
1299 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1300    and initialization explicit.  */
1301
1302 static enum gimplify_status
1303 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1304 {
1305   tree stmt = *stmt_p;
1306   tree decl = DECL_EXPR_DECL (stmt);
1307
1308   *stmt_p = NULL_TREE;
1309
1310   if (TREE_TYPE (decl) == error_mark_node)
1311     return GS_ERROR;
1312
1313   if ((TREE_CODE (decl) == TYPE_DECL
1314        || TREE_CODE (decl) == VAR_DECL)
1315       && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1316     gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1317
1318   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1319     {
1320       tree init = DECL_INITIAL (decl);
1321
1322       if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1323           || (!TREE_STATIC (decl)
1324               && flag_stack_check == GENERIC_STACK_CHECK
1325               && compare_tree_int (DECL_SIZE_UNIT (decl),
1326                                    STACK_CHECK_MAX_VAR_SIZE) > 0))
1327         gimplify_vla_decl (decl, seq_p);
1328
1329       if (init && init != error_mark_node)
1330         {
1331           if (!TREE_STATIC (decl))
1332             {
1333               DECL_INITIAL (decl) = NULL_TREE;
1334               init = build2 (INIT_EXPR, void_type_node, decl, init);
1335               gimplify_and_add (init, seq_p);
1336               ggc_free (init);
1337             }
1338           else
1339             /* We must still examine initializers for static variables
1340                as they may contain a label address.  */
1341             walk_tree (&init, force_labels_r, NULL, NULL);
1342         }
1343
1344       /* Some front ends do not explicitly declare all anonymous
1345          artificial variables.  We compensate here by declaring the
1346          variables, though it would be better if the front ends would
1347          explicitly declare them.  */
1348       if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1349           && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1350         gimple_add_tmp_var (decl);
1351     }
1352
1353   return GS_ALL_DONE;
1354 }
1355
1356 /* Gimplify a LOOP_EXPR.  Normally this just involves gimplifying the body
1357    and replacing the LOOP_EXPR with goto, but if the loop contains an
1358    EXIT_EXPR, we need to append a label for it to jump to.  */
1359
1360 static enum gimplify_status
1361 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1362 {
1363   tree saved_label = gimplify_ctxp->exit_label;
1364   tree start_label = create_artificial_label (UNKNOWN_LOCATION);
1365
1366   gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1367
1368   gimplify_ctxp->exit_label = NULL_TREE;
1369
1370   gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1371
1372   gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1373
1374   if (gimplify_ctxp->exit_label)
1375     gimplify_seq_add_stmt (pre_p, gimple_build_label (gimplify_ctxp->exit_label));
1376
1377   gimplify_ctxp->exit_label = saved_label;
1378
1379   *expr_p = NULL;
1380   return GS_ALL_DONE;
1381 }
1382
1383 /* Gimplifies a statement list onto a sequence.  These may be created either
1384    by an enlightened front-end, or by shortcut_cond_expr.  */
1385
1386 static enum gimplify_status
1387 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1388 {
1389   tree temp = voidify_wrapper_expr (*expr_p, NULL);
1390
1391   tree_stmt_iterator i = tsi_start (*expr_p);
1392
1393   while (!tsi_end_p (i))
1394     {
1395       gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1396       tsi_delink (&i);
1397     }
1398
1399   if (temp)
1400     {
1401       *expr_p = temp;
1402       return GS_OK;
1403     }
1404
1405   return GS_ALL_DONE;
1406 }
1407
1408 /* Compare two case labels.  Because the front end should already have
1409    made sure that case ranges do not overlap, it is enough to only compare
1410    the CASE_LOW values of each case label.  */
1411
1412 static int
1413 compare_case_labels (const void *p1, const void *p2)
1414 {
1415   const_tree const case1 = *(const_tree const*)p1;
1416   const_tree const case2 = *(const_tree const*)p2;
1417
1418   /* The 'default' case label always goes first.  */
1419   if (!CASE_LOW (case1))
1420     return -1;
1421   else if (!CASE_LOW (case2))
1422     return 1;
1423   else
1424     return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1425 }
1426
1427
1428 /* Sort the case labels in LABEL_VEC in place in ascending order.  */
1429
1430 void
1431 sort_case_labels (VEC(tree,heap)* label_vec)
1432 {
1433   size_t len = VEC_length (tree, label_vec);
1434   qsort (VEC_address (tree, label_vec), len, sizeof (tree),
1435          compare_case_labels);
1436 }
1437
1438
1439 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1440    branch to.  */
1441
1442 static enum gimplify_status
1443 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
1444 {
1445   tree switch_expr = *expr_p;
1446   gimple_seq switch_body_seq = NULL;
1447   enum gimplify_status ret;
1448
1449   ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
1450                        fb_rvalue);
1451   if (ret == GS_ERROR || ret == GS_UNHANDLED)
1452     return ret;
1453
1454   if (SWITCH_BODY (switch_expr))
1455     {
1456       VEC (tree,heap) *labels;
1457       VEC (tree,heap) *saved_labels;
1458       tree default_case = NULL_TREE;
1459       size_t i, len;
1460       gimple gimple_switch;
1461
1462       /* If someone can be bothered to fill in the labels, they can
1463          be bothered to null out the body too.  */
1464       gcc_assert (!SWITCH_LABELS (switch_expr));
1465
1466       /* save old labels, get new ones from body, then restore the old
1467          labels.  Save all the things from the switch body to append after.  */
1468       saved_labels = gimplify_ctxp->case_labels;
1469       gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1470
1471       gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
1472       labels = gimplify_ctxp->case_labels;
1473       gimplify_ctxp->case_labels = saved_labels;
1474
1475       i = 0;
1476       while (i < VEC_length (tree, labels))
1477         {
1478           tree elt = VEC_index (tree, labels, i);
1479           tree low = CASE_LOW (elt);
1480           bool remove_element = FALSE;
1481
1482           if (low)
1483             {
1484               /* Discard empty ranges.  */
1485               tree high = CASE_HIGH (elt);
1486               if (high && tree_int_cst_lt (high, low))
1487                 remove_element = TRUE;
1488             }
1489           else
1490             {
1491               /* The default case must be the last label in the list.  */
1492               gcc_assert (!default_case);
1493               default_case = elt;
1494               remove_element = TRUE;
1495             }
1496
1497           if (remove_element)
1498             VEC_ordered_remove (tree, labels, i);
1499           else
1500             i++;
1501         }
1502       len = i;
1503
1504       if (!VEC_empty (tree, labels))
1505         sort_case_labels (labels);
1506
1507       if (!default_case)
1508         {
1509           tree type = TREE_TYPE (switch_expr);
1510
1511           /* If the switch has no default label, add one, so that we jump
1512              around the switch body.  If the labels already cover the whole
1513              range of type, add the default label pointing to one of the
1514              existing labels.  */
1515           if (type == void_type_node)
1516             type = TREE_TYPE (SWITCH_COND (switch_expr));
1517           if (len
1518               && INTEGRAL_TYPE_P (type)
1519               && TYPE_MIN_VALUE (type)
1520               && TYPE_MAX_VALUE (type)
1521               && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
1522                                      TYPE_MIN_VALUE (type)))
1523             {
1524               tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
1525               if (!high)
1526                 high = CASE_LOW (VEC_index (tree, labels, len - 1));
1527               if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
1528                 {
1529                   for (i = 1; i < len; i++)
1530                     {
1531                       high = CASE_LOW (VEC_index (tree, labels, i));
1532                       low = CASE_HIGH (VEC_index (tree, labels, i - 1));
1533                       if (!low)
1534                         low = CASE_LOW (VEC_index (tree, labels, i - 1));
1535                       if ((TREE_INT_CST_LOW (low) + 1
1536                            != TREE_INT_CST_LOW (high))
1537                           || (TREE_INT_CST_HIGH (low)
1538                               + (TREE_INT_CST_LOW (high) == 0)
1539                               != TREE_INT_CST_HIGH (high)))
1540                         break;
1541                     }
1542                   if (i == len)
1543                     default_case = build3 (CASE_LABEL_EXPR, void_type_node,
1544                                            NULL_TREE, NULL_TREE,
1545                                            CASE_LABEL (VEC_index (tree,
1546                                                                   labels, 0)));
1547                 }
1548             }
1549
1550           if (!default_case)
1551             {
1552               gimple new_default;
1553
1554               default_case
1555                 = build3 (CASE_LABEL_EXPR, void_type_node,
1556                           NULL_TREE, NULL_TREE,
1557                           create_artificial_label (UNKNOWN_LOCATION));
1558               new_default = gimple_build_label (CASE_LABEL (default_case));
1559               gimplify_seq_add_stmt (&switch_body_seq, new_default);
1560             }
1561         }
1562
1563       gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
1564                                                default_case, labels);
1565       gimplify_seq_add_stmt (pre_p, gimple_switch);
1566       gimplify_seq_add_seq (pre_p, switch_body_seq);
1567       VEC_free(tree, heap, labels);
1568     }
1569   else
1570     gcc_assert (SWITCH_LABELS (switch_expr));
1571
1572   return GS_ALL_DONE;
1573 }
1574
1575
1576 static enum gimplify_status
1577 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
1578 {
1579   struct gimplify_ctx *ctxp;
1580   gimple gimple_label;
1581
1582   /* Invalid OpenMP programs can play Duff's Device type games with
1583      #pragma omp parallel.  At least in the C front end, we don't
1584      detect such invalid branches until after gimplification.  */
1585   for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1586     if (ctxp->case_labels)
1587       break;
1588
1589   gimple_label = gimple_build_label (CASE_LABEL (*expr_p));
1590   VEC_safe_push (tree, heap, ctxp->case_labels, *expr_p);
1591   gimplify_seq_add_stmt (pre_p, gimple_label);
1592
1593   return GS_ALL_DONE;
1594 }
1595
1596 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1597    if necessary.  */
1598
1599 tree
1600 build_and_jump (tree *label_p)
1601 {
1602   if (label_p == NULL)
1603     /* If there's nowhere to jump, just fall through.  */
1604     return NULL_TREE;
1605
1606   if (*label_p == NULL_TREE)
1607     {
1608       tree label = create_artificial_label (UNKNOWN_LOCATION);
1609       *label_p = label;
1610     }
1611
1612   return build1 (GOTO_EXPR, void_type_node, *label_p);
1613 }
1614
1615 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1616    This also involves building a label to jump to and communicating it to
1617    gimplify_loop_expr through gimplify_ctxp->exit_label.  */
1618
1619 static enum gimplify_status
1620 gimplify_exit_expr (tree *expr_p)
1621 {
1622   tree cond = TREE_OPERAND (*expr_p, 0);
1623   tree expr;
1624
1625   expr = build_and_jump (&gimplify_ctxp->exit_label);
1626   expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1627   *expr_p = expr;
1628
1629   return GS_OK;
1630 }
1631
1632 /* A helper function to be called via walk_tree.  Mark all labels under *TP
1633    as being forced.  To be called for DECL_INITIAL of static variables.  */
1634
1635 tree
1636 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1637 {
1638   if (TYPE_P (*tp))
1639     *walk_subtrees = 0;
1640   if (TREE_CODE (*tp) == LABEL_DECL)
1641     FORCED_LABEL (*tp) = 1;
1642
1643   return NULL_TREE;
1644 }
1645
1646 /* *EXPR_P is a COMPONENT_REF being used as an rvalue.  If its type is
1647    different from its canonical type, wrap the whole thing inside a
1648    NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1649    type.
1650
1651    The canonical type of a COMPONENT_REF is the type of the field being
1652    referenced--unless the field is a bit-field which can be read directly
1653    in a smaller mode, in which case the canonical type is the
1654    sign-appropriate type corresponding to that mode.  */
1655
1656 static void
1657 canonicalize_component_ref (tree *expr_p)
1658 {
1659   tree expr = *expr_p;
1660   tree type;
1661
1662   gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1663
1664   if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1665     type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1666   else
1667     type = TREE_TYPE (TREE_OPERAND (expr, 1));
1668
1669   /* One could argue that all the stuff below is not necessary for
1670      the non-bitfield case and declare it a FE error if type
1671      adjustment would be needed.  */
1672   if (TREE_TYPE (expr) != type)
1673     {
1674 #ifdef ENABLE_TYPES_CHECKING
1675       tree old_type = TREE_TYPE (expr);
1676 #endif
1677       int type_quals;
1678
1679       /* We need to preserve qualifiers and propagate them from
1680          operand 0.  */
1681       type_quals = TYPE_QUALS (type)
1682         | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1683       if (TYPE_QUALS (type) != type_quals)
1684         type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1685
1686       /* Set the type of the COMPONENT_REF to the underlying type.  */
1687       TREE_TYPE (expr) = type;
1688
1689 #ifdef ENABLE_TYPES_CHECKING
1690       /* It is now a FE error, if the conversion from the canonical
1691          type to the original expression type is not useless.  */
1692       gcc_assert (useless_type_conversion_p (old_type, type));
1693 #endif
1694     }
1695 }
1696
1697 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1698    to foo, embed that change in the ADDR_EXPR by converting
1699       T array[U];
1700       (T *)&array
1701    ==>
1702       &array[L]
1703    where L is the lower bound.  For simplicity, only do this for constant
1704    lower bound.
1705    The constraint is that the type of &array[L] is trivially convertible
1706    to T *.  */
1707
1708 static void
1709 canonicalize_addr_expr (tree *expr_p)
1710 {
1711   tree expr = *expr_p;
1712   tree addr_expr = TREE_OPERAND (expr, 0);
1713   tree datype, ddatype, pddatype;
1714
1715   /* We simplify only conversions from an ADDR_EXPR to a pointer type.  */
1716   if (!POINTER_TYPE_P (TREE_TYPE (expr))
1717       || TREE_CODE (addr_expr) != ADDR_EXPR)
1718     return;
1719
1720   /* The addr_expr type should be a pointer to an array.  */
1721   datype = TREE_TYPE (TREE_TYPE (addr_expr));
1722   if (TREE_CODE (datype) != ARRAY_TYPE)
1723     return;
1724
1725   /* The pointer to element type shall be trivially convertible to
1726      the expression pointer type.  */
1727   ddatype = TREE_TYPE (datype);
1728   pddatype = build_pointer_type (ddatype);
1729   if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
1730                                   pddatype))
1731     return;
1732
1733   /* The lower bound and element sizes must be constant.  */
1734   if (!TYPE_SIZE_UNIT (ddatype)
1735       || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1736       || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1737       || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1738     return;
1739
1740   /* All checks succeeded.  Build a new node to merge the cast.  */
1741   *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1742                     TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1743                     NULL_TREE, NULL_TREE);
1744   *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1745
1746   /* We can have stripped a required restrict qualifier above.  */
1747   if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
1748     *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
1749 }
1750
1751 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR.  Remove it and/or other conversions
1752    underneath as appropriate.  */
1753
1754 static enum gimplify_status
1755 gimplify_conversion (tree *expr_p)
1756 {
1757   tree tem;
1758   location_t loc = EXPR_LOCATION (*expr_p);
1759   gcc_assert (CONVERT_EXPR_P (*expr_p));
1760
1761   /* Then strip away all but the outermost conversion.  */
1762   STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1763
1764   /* And remove the outermost conversion if it's useless.  */
1765   if (tree_ssa_useless_type_conversion (*expr_p))
1766     *expr_p = TREE_OPERAND (*expr_p, 0);
1767
1768   /* Attempt to avoid NOP_EXPR by producing reference to a subtype.
1769      For example this fold (subclass *)&A into &A->subclass avoiding
1770      a need for statement.  */
1771   if (CONVERT_EXPR_P (*expr_p)
1772       && POINTER_TYPE_P (TREE_TYPE (*expr_p))
1773       && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0)))
1774       && (tem = maybe_fold_offset_to_address
1775           (EXPR_LOCATION (*expr_p), TREE_OPERAND (*expr_p, 0),
1776            integer_zero_node, TREE_TYPE (*expr_p))) != NULL_TREE)
1777     *expr_p = tem;
1778
1779   /* If we still have a conversion at the toplevel,
1780      then canonicalize some constructs.  */
1781   if (CONVERT_EXPR_P (*expr_p))
1782     {
1783       tree sub = TREE_OPERAND (*expr_p, 0);
1784
1785       /* If a NOP conversion is changing the type of a COMPONENT_REF
1786          expression, then canonicalize its type now in order to expose more
1787          redundant conversions.  */
1788       if (TREE_CODE (sub) == COMPONENT_REF)
1789         canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1790
1791       /* If a NOP conversion is changing a pointer to array of foo
1792          to a pointer to foo, embed that change in the ADDR_EXPR.  */
1793       else if (TREE_CODE (sub) == ADDR_EXPR)
1794         canonicalize_addr_expr (expr_p);
1795     }
1796
1797   /* If we have a conversion to a non-register type force the
1798      use of a VIEW_CONVERT_EXPR instead.  */
1799   if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
1800     *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
1801                                TREE_OPERAND (*expr_p, 0));
1802
1803   return GS_OK;
1804 }
1805
1806 /* Nonlocal VLAs seen in the current function.  */
1807 static struct pointer_set_t *nonlocal_vlas;
1808
1809 /* Gimplify a VAR_DECL or PARM_DECL.  Returns GS_OK if we expanded a
1810    DECL_VALUE_EXPR, and it's worth re-examining things.  */
1811
1812 static enum gimplify_status
1813 gimplify_var_or_parm_decl (tree *expr_p)
1814 {
1815   tree decl = *expr_p;
1816
1817   /* ??? If this is a local variable, and it has not been seen in any
1818      outer BIND_EXPR, then it's probably the result of a duplicate
1819      declaration, for which we've already issued an error.  It would
1820      be really nice if the front end wouldn't leak these at all.
1821      Currently the only known culprit is C++ destructors, as seen
1822      in g++.old-deja/g++.jason/binding.C.  */
1823   if (TREE_CODE (decl) == VAR_DECL
1824       && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1825       && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1826       && decl_function_context (decl) == current_function_decl)
1827     {
1828       gcc_assert (errorcount || sorrycount);
1829       return GS_ERROR;
1830     }
1831
1832   /* When within an OpenMP context, notice uses of variables.  */
1833   if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1834     return GS_ALL_DONE;
1835
1836   /* If the decl is an alias for another expression, substitute it now.  */
1837   if (DECL_HAS_VALUE_EXPR_P (decl))
1838     {
1839       tree value_expr = DECL_VALUE_EXPR (decl);
1840
1841       /* For referenced nonlocal VLAs add a decl for debugging purposes
1842          to the current function.  */
1843       if (TREE_CODE (decl) == VAR_DECL
1844           && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1845           && nonlocal_vlas != NULL
1846           && TREE_CODE (value_expr) == INDIRECT_REF
1847           && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
1848           && decl_function_context (decl) != current_function_decl)
1849         {
1850           struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1851           while (ctx && ctx->region_type == ORT_WORKSHARE)
1852             ctx = ctx->outer_context;
1853           if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
1854             {
1855               tree copy = copy_node (decl), block;
1856
1857               lang_hooks.dup_lang_specific_decl (copy);
1858               SET_DECL_RTL (copy, NULL_RTX);
1859               TREE_USED (copy) = 1;
1860               block = DECL_INITIAL (current_function_decl);
1861               TREE_CHAIN (copy) = BLOCK_VARS (block);
1862               BLOCK_VARS (block) = copy;
1863               SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
1864               DECL_HAS_VALUE_EXPR_P (copy) = 1;
1865             }
1866         }
1867
1868       *expr_p = unshare_expr (value_expr);
1869       return GS_OK;
1870     }
1871
1872   return GS_ALL_DONE;
1873 }
1874
1875
1876 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1877    node *EXPR_P.
1878
1879       compound_lval
1880               : min_lval '[' val ']'
1881               | min_lval '.' ID
1882               | compound_lval '[' val ']'
1883               | compound_lval '.' ID
1884
1885    This is not part of the original SIMPLE definition, which separates
1886    array and member references, but it seems reasonable to handle them
1887    together.  Also, this way we don't run into problems with union
1888    aliasing; gcc requires that for accesses through a union to alias, the
1889    union reference must be explicit, which was not always the case when we
1890    were splitting up array and member refs.
1891
1892    PRE_P points to the sequence where side effects that must happen before
1893      *EXPR_P should be stored.
1894
1895    POST_P points to the sequence where side effects that must happen after
1896      *EXPR_P should be stored.  */
1897
1898 static enum gimplify_status
1899 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
1900                         fallback_t fallback)
1901 {
1902   tree *p;
1903   VEC(tree,heap) *stack;
1904   enum gimplify_status ret = GS_OK, tret;
1905   int i;
1906   location_t loc = EXPR_LOCATION (*expr_p);
1907
1908   /* Create a stack of the subexpressions so later we can walk them in
1909      order from inner to outer.  */
1910   stack = VEC_alloc (tree, heap, 10);
1911
1912   /* We can handle anything that get_inner_reference can deal with.  */
1913   for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
1914     {
1915     restart:
1916       /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs.  */
1917       if (TREE_CODE (*p) == INDIRECT_REF)
1918         *p = fold_indirect_ref_loc (loc, *p);
1919
1920       if (handled_component_p (*p))
1921         ;
1922       /* Expand DECL_VALUE_EXPR now.  In some cases that may expose
1923          additional COMPONENT_REFs.  */
1924       else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
1925                && gimplify_var_or_parm_decl (p) == GS_OK)
1926         goto restart;
1927       else
1928         break;
1929
1930       VEC_safe_push (tree, heap, stack, *p);
1931     }
1932
1933   gcc_assert (VEC_length (tree, stack));
1934
1935   /* Now STACK is a stack of pointers to all the refs we've walked through
1936      and P points to the innermost expression.
1937
1938      Java requires that we elaborated nodes in source order.  That
1939      means we must gimplify the inner expression followed by each of
1940      the indices, in order.  But we can't gimplify the inner
1941      expression until we deal with any variable bounds, sizes, or
1942      positions in order to deal with PLACEHOLDER_EXPRs.
1943
1944      So we do this in three steps.  First we deal with the annotations
1945      for any variables in the components, then we gimplify the base,
1946      then we gimplify any indices, from left to right.  */
1947   for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
1948     {
1949       tree t = VEC_index (tree, stack, i);
1950
1951       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1952         {
1953           /* Gimplify the low bound and element type size and put them into
1954              the ARRAY_REF.  If these values are set, they have already been
1955              gimplified.  */
1956           if (TREE_OPERAND (t, 2) == NULL_TREE)
1957             {
1958               tree low = unshare_expr (array_ref_low_bound (t));
1959               if (!is_gimple_min_invariant (low))
1960                 {
1961                   TREE_OPERAND (t, 2) = low;
1962                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
1963                                         post_p, is_gimple_reg,
1964                                         fb_rvalue);
1965                   ret = MIN (ret, tret);
1966                 }
1967             }
1968
1969           if (!TREE_OPERAND (t, 3))
1970             {
1971               tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1972               tree elmt_size = unshare_expr (array_ref_element_size (t));
1973               tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
1974
1975               /* Divide the element size by the alignment of the element
1976                  type (above).  */
1977               elmt_size = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
1978
1979               if (!is_gimple_min_invariant (elmt_size))
1980                 {
1981                   TREE_OPERAND (t, 3) = elmt_size;
1982                   tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
1983                                         post_p, is_gimple_reg,
1984                                         fb_rvalue);
1985                   ret = MIN (ret, tret);
1986                 }
1987             }
1988         }
1989       else if (TREE_CODE (t) == COMPONENT_REF)
1990         {
1991           /* Set the field offset into T and gimplify it.  */
1992           if (!TREE_OPERAND (t, 2))
1993             {
1994               tree offset = unshare_expr (component_ref_field_offset (t));
1995               tree field = TREE_OPERAND (t, 1);
1996               tree factor
1997                 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
1998
1999               /* Divide the offset by its alignment.  */
2000               offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2001
2002               if (!is_gimple_min_invariant (offset))
2003                 {
2004                   TREE_OPERAND (t, 2) = offset;
2005                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2006                                         post_p, is_gimple_reg,
2007                                         fb_rvalue);
2008                   ret = MIN (ret, tret);
2009                 }
2010             }
2011         }
2012     }
2013
2014   /* Step 2 is to gimplify the base expression.  Make sure lvalue is set
2015      so as to match the min_lval predicate.  Failure to do so may result
2016      in the creation of large aggregate temporaries.  */
2017   tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2018                         fallback | fb_lvalue);
2019   ret = MIN (ret, tret);
2020
2021   /* And finally, the indices and operands to BIT_FIELD_REF.  During this
2022      loop we also remove any useless conversions.  */
2023   for (; VEC_length (tree, stack) > 0; )
2024     {
2025       tree t = VEC_pop (tree, stack);
2026
2027       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2028         {
2029           /* Gimplify the dimension.  */
2030           if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2031             {
2032               tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2033                                     is_gimple_val, fb_rvalue);
2034               ret = MIN (ret, tret);
2035             }
2036         }
2037       else if (TREE_CODE (t) == BIT_FIELD_REF)
2038         {
2039           tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2040                                 is_gimple_val, fb_rvalue);
2041           ret = MIN (ret, tret);
2042           tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2043                                 is_gimple_val, fb_rvalue);
2044           ret = MIN (ret, tret);
2045         }
2046
2047       STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2048
2049       /* The innermost expression P may have originally had
2050          TREE_SIDE_EFFECTS set which would have caused all the outer
2051          expressions in *EXPR_P leading to P to also have had
2052          TREE_SIDE_EFFECTS set.  */
2053       recalculate_side_effects (t);
2054     }
2055
2056   /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
2057   if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2058     {
2059       canonicalize_component_ref (expr_p);
2060       ret = MIN (ret, GS_OK);
2061     }
2062
2063   VEC_free (tree, heap, stack);
2064
2065   return ret;
2066 }
2067
2068 /*  Gimplify the self modifying expression pointed to by EXPR_P
2069     (++, --, +=, -=).
2070
2071     PRE_P points to the list where side effects that must happen before
2072         *EXPR_P should be stored.
2073
2074     POST_P points to the list where side effects that must happen after
2075         *EXPR_P should be stored.
2076
2077     WANT_VALUE is nonzero iff we want to use the value of this expression
2078         in another expression.  */
2079
2080 static enum gimplify_status
2081 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2082                         bool want_value)
2083 {
2084   enum tree_code code;
2085   tree lhs, lvalue, rhs, t1;
2086   gimple_seq post = NULL, *orig_post_p = post_p;
2087   bool postfix;
2088   enum tree_code arith_code;
2089   enum gimplify_status ret;
2090   location_t loc = EXPR_LOCATION (*expr_p);
2091
2092   code = TREE_CODE (*expr_p);
2093
2094   gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2095               || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2096
2097   /* Prefix or postfix?  */
2098   if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2099     /* Faster to treat as prefix if result is not used.  */
2100     postfix = want_value;
2101   else
2102     postfix = false;
2103
2104   /* For postfix, make sure the inner expression's post side effects
2105      are executed after side effects from this expression.  */
2106   if (postfix)
2107     post_p = &post;
2108
2109   /* Add or subtract?  */
2110   if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2111     arith_code = PLUS_EXPR;
2112   else
2113     arith_code = MINUS_EXPR;
2114
2115   /* Gimplify the LHS into a GIMPLE lvalue.  */
2116   lvalue = TREE_OPERAND (*expr_p, 0);
2117   ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2118   if (ret == GS_ERROR)
2119     return ret;
2120
2121   /* Extract the operands to the arithmetic operation.  */
2122   lhs = lvalue;
2123   rhs = TREE_OPERAND (*expr_p, 1);
2124
2125   /* For postfix operator, we evaluate the LHS to an rvalue and then use
2126      that as the result value and in the postqueue operation.  We also
2127      make sure to make lvalue a minimal lval, see
2128      gcc.c-torture/execute/20040313-1.c for an example where this matters.  */
2129   if (postfix)
2130     {
2131       if (!is_gimple_min_lval (lvalue))
2132         {
2133           mark_addressable (lvalue);
2134           lvalue = build_fold_addr_expr_loc (input_location, lvalue);
2135           gimplify_expr (&lvalue, pre_p, post_p, is_gimple_val, fb_rvalue);
2136           lvalue = build_fold_indirect_ref_loc (input_location, lvalue);
2137         }
2138       ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2139       if (ret == GS_ERROR)
2140         return ret;
2141     }
2142
2143   /* For POINTERs increment, use POINTER_PLUS_EXPR.  */
2144   if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2145     {
2146       rhs = fold_convert_loc (loc, sizetype, rhs);
2147       if (arith_code == MINUS_EXPR)
2148         rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2149       arith_code = POINTER_PLUS_EXPR;
2150     }
2151
2152   t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
2153
2154   if (postfix)
2155     {
2156       gimplify_assign (lvalue, t1, orig_post_p);
2157       gimplify_seq_add_seq (orig_post_p, post);
2158       *expr_p = lhs;
2159       return GS_ALL_DONE;
2160     }
2161   else
2162     {
2163       *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2164       return GS_OK;
2165     }
2166 }
2167
2168
2169 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR.  */
2170
2171 static void
2172 maybe_with_size_expr (tree *expr_p)
2173 {
2174   tree expr = *expr_p;
2175   tree type = TREE_TYPE (expr);
2176   tree size;
2177
2178   /* If we've already wrapped this or the type is error_mark_node, we can't do
2179      anything.  */
2180   if (TREE_CODE (expr) == WITH_SIZE_EXPR
2181       || type == error_mark_node)
2182     return;
2183
2184   /* If the size isn't known or is a constant, we have nothing to do.  */
2185   size = TYPE_SIZE_UNIT (type);
2186   if (!size || TREE_CODE (size) == INTEGER_CST)
2187     return;
2188
2189   /* Otherwise, make a WITH_SIZE_EXPR.  */
2190   size = unshare_expr (size);
2191   size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2192   *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2193 }
2194
2195
2196 /* Helper for gimplify_call_expr.  Gimplify a single argument *ARG_P
2197    Store any side-effects in PRE_P.  CALL_LOCATION is the location of
2198    the CALL_EXPR.  */
2199
2200 static enum gimplify_status
2201 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location)
2202 {
2203   bool (*test) (tree);
2204   fallback_t fb;
2205
2206   /* In general, we allow lvalues for function arguments to avoid
2207      extra overhead of copying large aggregates out of even larger
2208      aggregates into temporaries only to copy the temporaries to
2209      the argument list.  Make optimizers happy by pulling out to
2210      temporaries those types that fit in registers.  */
2211   if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2212     test = is_gimple_val, fb = fb_rvalue;
2213   else
2214     test = is_gimple_lvalue, fb = fb_either;
2215
2216   /* If this is a variable sized type, we must remember the size.  */
2217   maybe_with_size_expr (arg_p);
2218
2219   /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c.  */
2220   /* Make sure arguments have the same location as the function call
2221      itself.  */
2222   protected_set_expr_location (*arg_p, call_location);
2223
2224   /* There is a sequence point before a function call.  Side effects in
2225      the argument list must occur before the actual call. So, when
2226      gimplifying arguments, force gimplify_expr to use an internal
2227      post queue which is then appended to the end of PRE_P.  */
2228   return gimplify_expr (arg_p, pre_p, NULL, test, fb);
2229 }
2230
2231
2232 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2233    WANT_VALUE is true if the result of the call is desired.  */
2234
2235 static enum gimplify_status
2236 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2237 {
2238   tree fndecl, parms, p;
2239   enum gimplify_status ret;
2240   int i, nargs;
2241   gimple call;
2242   bool builtin_va_start_p = FALSE;
2243   location_t loc = EXPR_LOCATION (*expr_p);
2244
2245   gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2246
2247   /* For reliable diagnostics during inlining, it is necessary that
2248      every call_expr be annotated with file and line.  */
2249   if (! EXPR_HAS_LOCATION (*expr_p))
2250     SET_EXPR_LOCATION (*expr_p, input_location);
2251
2252   /* This may be a call to a builtin function.
2253
2254      Builtin function calls may be transformed into different
2255      (and more efficient) builtin function calls under certain
2256      circumstances.  Unfortunately, gimplification can muck things
2257      up enough that the builtin expanders are not aware that certain
2258      transformations are still valid.
2259
2260      So we attempt transformation/gimplification of the call before
2261      we gimplify the CALL_EXPR.  At this time we do not manage to
2262      transform all calls in the same manner as the expanders do, but
2263      we do transform most of them.  */
2264   fndecl = get_callee_fndecl (*expr_p);
2265   if (fndecl && DECL_BUILT_IN (fndecl))
2266     {
2267       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2268
2269       if (new_tree && new_tree != *expr_p)
2270         {
2271           /* There was a transformation of this call which computes the
2272              same value, but in a more efficient way.  Return and try
2273              again.  */
2274           *expr_p = new_tree;
2275           return GS_OK;
2276         }
2277
2278       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2279           && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
2280         {
2281           builtin_va_start_p = TRUE;
2282           if (call_expr_nargs (*expr_p) < 2)
2283             {
2284               error ("too few arguments to function %<va_start%>");
2285               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2286               return GS_OK;
2287             }
2288
2289           if (fold_builtin_next_arg (*expr_p, true))
2290             {
2291               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2292               return GS_OK;
2293             }
2294         }
2295     }
2296
2297   /* There is a sequence point before the call, so any side effects in
2298      the calling expression must occur before the actual call.  Force
2299      gimplify_expr to use an internal post queue.  */
2300   ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2301                        is_gimple_call_addr, fb_rvalue);
2302
2303   nargs = call_expr_nargs (*expr_p);
2304
2305   /* Get argument types for verification.  */
2306   fndecl = get_callee_fndecl (*expr_p);
2307   parms = NULL_TREE;
2308   if (fndecl)
2309     parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2310   else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2311     parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2312
2313   if (fndecl && DECL_ARGUMENTS (fndecl))
2314     p = DECL_ARGUMENTS (fndecl);
2315   else if (parms)
2316     p = parms;
2317   else
2318     p = NULL_TREE;
2319   for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2320     ;
2321
2322   /* If the last argument is __builtin_va_arg_pack () and it is not
2323      passed as a named argument, decrease the number of CALL_EXPR
2324      arguments and set instead the CALL_EXPR_VA_ARG_PACK flag.  */
2325   if (!p
2326       && i < nargs
2327       && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2328     {
2329       tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2330       tree last_arg_fndecl = get_callee_fndecl (last_arg);
2331
2332       if (last_arg_fndecl
2333           && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2334           && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2335           && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2336         {
2337           tree call = *expr_p;
2338
2339           --nargs;
2340           *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
2341                                           CALL_EXPR_FN (call),
2342                                           nargs, CALL_EXPR_ARGP (call));
2343
2344           /* Copy all CALL_EXPR flags, location and block, except
2345              CALL_EXPR_VA_ARG_PACK flag.  */
2346           CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2347           CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2348           CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2349             = CALL_EXPR_RETURN_SLOT_OPT (call);
2350           CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2351           CALL_CANNOT_INLINE_P (*expr_p) = CALL_CANNOT_INLINE_P (call);
2352           SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
2353           TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2354
2355           /* Set CALL_EXPR_VA_ARG_PACK.  */
2356           CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2357         }
2358     }
2359
2360   /* Finally, gimplify the function arguments.  */
2361   if (nargs > 0)
2362     {
2363       for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2364            PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2365            PUSH_ARGS_REVERSED ? i-- : i++)
2366         {
2367           enum gimplify_status t;
2368
2369           /* Avoid gimplifying the second argument to va_start, which needs to
2370              be the plain PARM_DECL.  */
2371           if ((i != 1) || !builtin_va_start_p)
2372             {
2373               t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2374                                 EXPR_LOCATION (*expr_p));
2375
2376               if (t == GS_ERROR)
2377                 ret = GS_ERROR;
2378             }
2379         }
2380     }
2381
2382   /* Verify the function result.  */
2383   if (want_value && fndecl
2384       && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl))))
2385     {
2386       error_at (loc, "using result of function returning %<void%>");
2387       ret = GS_ERROR;
2388     }
2389
2390   /* Try this again in case gimplification exposed something.  */
2391   if (ret != GS_ERROR)
2392     {
2393       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2394
2395       if (new_tree && new_tree != *expr_p)
2396         {
2397           /* There was a transformation of this call which computes the
2398              same value, but in a more efficient way.  Return and try
2399              again.  */
2400           *expr_p = new_tree;
2401           return GS_OK;
2402         }
2403     }
2404   else
2405     {
2406       *expr_p = error_mark_node;
2407       return GS_ERROR;
2408     }
2409
2410   /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2411      decl.  This allows us to eliminate redundant or useless
2412      calls to "const" functions.  */
2413   if (TREE_CODE (*expr_p) == CALL_EXPR)
2414     {
2415       int flags = call_expr_flags (*expr_p);
2416       if (flags & (ECF_CONST | ECF_PURE)
2417           /* An infinite loop is considered a side effect.  */
2418           && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2419         TREE_SIDE_EFFECTS (*expr_p) = 0;
2420     }
2421
2422   /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2423      and clear *EXPR_P.  Otherwise, leave *EXPR_P in its gimplified
2424      form and delegate the creation of a GIMPLE_CALL to
2425      gimplify_modify_expr.  This is always possible because when
2426      WANT_VALUE is true, the caller wants the result of this call into
2427      a temporary, which means that we will emit an INIT_EXPR in
2428      internal_get_tmp_var which will then be handled by
2429      gimplify_modify_expr.  */
2430   if (!want_value)
2431     {
2432       /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2433          have to do is replicate it as a GIMPLE_CALL tuple.  */
2434       call = gimple_build_call_from_tree (*expr_p);
2435       gimplify_seq_add_stmt (pre_p, call);
2436       *expr_p = NULL_TREE;
2437     }
2438
2439   return ret;
2440 }
2441
2442 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2443    rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2444
2445    TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2446    condition is true or false, respectively.  If null, we should generate
2447    our own to skip over the evaluation of this specific expression.
2448
2449    LOCUS is the source location of the COND_EXPR.
2450
2451    This function is the tree equivalent of do_jump.
2452
2453    shortcut_cond_r should only be called by shortcut_cond_expr.  */
2454
2455 static tree
2456 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
2457                  location_t locus)
2458 {
2459   tree local_label = NULL_TREE;
2460   tree t, expr = NULL;
2461
2462   /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2463      retain the shortcut semantics.  Just insert the gotos here;
2464      shortcut_cond_expr will append the real blocks later.  */
2465   if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2466     {
2467       location_t new_locus;
2468
2469       /* Turn if (a && b) into
2470
2471          if (a); else goto no;
2472          if (b) goto yes; else goto no;
2473          (no:) */
2474
2475       if (false_label_p == NULL)
2476         false_label_p = &local_label;
2477
2478       /* Keep the original source location on the first 'if'.  */
2479       t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
2480       append_to_statement_list (t, &expr);
2481
2482       /* Set the source location of the && on the second 'if'.  */
2483       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2484       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2485                            new_locus);
2486       append_to_statement_list (t, &expr);
2487     }
2488   else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2489     {
2490       location_t new_locus;
2491
2492       /* Turn if (a || b) into
2493
2494          if (a) goto yes;
2495          if (b) goto yes; else goto no;
2496          (yes:) */
2497
2498       if (true_label_p == NULL)
2499         true_label_p = &local_label;
2500
2501       /* Keep the original source location on the first 'if'.  */
2502       t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
2503       append_to_statement_list (t, &expr);
2504
2505       /* Set the source location of the || on the second 'if'.  */
2506       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2507       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2508                            new_locus);
2509       append_to_statement_list (t, &expr);
2510     }
2511   else if (TREE_CODE (pred) == COND_EXPR)
2512     {
2513       location_t new_locus;
2514
2515       /* As long as we're messing with gotos, turn if (a ? b : c) into
2516          if (a)
2517            if (b) goto yes; else goto no;
2518          else
2519            if (c) goto yes; else goto no;  */
2520
2521       /* Keep the original source location on the first 'if'.  Set the source
2522          location of the ? on the second 'if'.  */
2523       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2524       expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2525                      shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2526                                       false_label_p, locus),
2527                      shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2528                                       false_label_p, new_locus));
2529     }
2530   else
2531     {
2532       expr = build3 (COND_EXPR, void_type_node, pred,
2533                      build_and_jump (true_label_p),
2534                      build_and_jump (false_label_p));
2535       SET_EXPR_LOCATION (expr, locus);
2536     }
2537
2538   if (local_label)
2539     {
2540       t = build1 (LABEL_EXPR, void_type_node, local_label);
2541       append_to_statement_list (t, &expr);
2542     }
2543
2544   return expr;
2545 }
2546
2547 /* Given a conditional expression EXPR with short-circuit boolean
2548    predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2549    predicate appart into the equivalent sequence of conditionals.  */
2550
2551 static tree
2552 shortcut_cond_expr (tree expr)
2553 {
2554   tree pred = TREE_OPERAND (expr, 0);
2555   tree then_ = TREE_OPERAND (expr, 1);
2556   tree else_ = TREE_OPERAND (expr, 2);
2557   tree true_label, false_label, end_label, t;
2558   tree *true_label_p;
2559   tree *false_label_p;
2560   bool emit_end, emit_false, jump_over_else;
2561   bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2562   bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2563
2564   /* First do simple transformations.  */
2565   if (!else_se)
2566     {
2567       /* If there is no 'else', turn
2568            if (a && b) then c
2569          into
2570            if (a) if (b) then c.  */
2571       while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2572         {
2573           /* Keep the original source location on the first 'if'.  */
2574           location_t locus = EXPR_HAS_LOCATION (expr)
2575                              ? EXPR_LOCATION (expr) : input_location;
2576           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2577           /* Set the source location of the && on the second 'if'.  */
2578           if (EXPR_HAS_LOCATION (pred))
2579             SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2580           then_ = shortcut_cond_expr (expr);
2581           then_se = then_ && TREE_SIDE_EFFECTS (then_);
2582           pred = TREE_OPERAND (pred, 0);
2583           expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2584           SET_EXPR_LOCATION (expr, locus);
2585         }
2586     }
2587
2588   if (!then_se)
2589     {
2590       /* If there is no 'then', turn
2591            if (a || b); else d
2592          into
2593            if (a); else if (b); else d.  */
2594       while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2595         {
2596           /* Keep the original source location on the first 'if'.  */
2597           location_t locus = EXPR_HAS_LOCATION (expr)
2598                              ? EXPR_LOCATION (expr) : input_location;
2599           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2600           /* Set the source location of the || on the second 'if'.  */
2601           if (EXPR_HAS_LOCATION (pred))
2602             SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2603           else_ = shortcut_cond_expr (expr);
2604           else_se = else_ && TREE_SIDE_EFFECTS (else_);
2605           pred = TREE_OPERAND (pred, 0);
2606           expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2607           SET_EXPR_LOCATION (expr, locus);
2608         }
2609     }
2610
2611   /* If we're done, great.  */
2612   if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2613       && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2614     return expr;
2615
2616   /* Otherwise we need to mess with gotos.  Change
2617        if (a) c; else d;
2618      to
2619        if (a); else goto no;
2620        c; goto end;
2621        no: d; end:
2622      and recursively gimplify the condition.  */
2623
2624   true_label = false_label = end_label = NULL_TREE;
2625
2626   /* If our arms just jump somewhere, hijack those labels so we don't
2627      generate jumps to jumps.  */
2628
2629   if (then_
2630       && TREE_CODE (then_) == GOTO_EXPR
2631       && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2632     {
2633       true_label = GOTO_DESTINATION (then_);
2634       then_ = NULL;
2635       then_se = false;
2636     }
2637
2638   if (else_
2639       && TREE_CODE (else_) == GOTO_EXPR
2640       && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2641     {
2642       false_label = GOTO_DESTINATION (else_);
2643       else_ = NULL;
2644       else_se = false;
2645     }
2646
2647   /* If we aren't hijacking a label for the 'then' branch, it falls through.  */
2648   if (true_label)
2649     true_label_p = &true_label;
2650   else
2651     true_label_p = NULL;
2652
2653   /* The 'else' branch also needs a label if it contains interesting code.  */
2654   if (false_label || else_se)
2655     false_label_p = &false_label;
2656   else
2657     false_label_p = NULL;
2658
2659   /* If there was nothing else in our arms, just forward the label(s).  */
2660   if (!then_se && !else_se)
2661     return shortcut_cond_r (pred, true_label_p, false_label_p,
2662                             EXPR_HAS_LOCATION (expr)
2663                             ? EXPR_LOCATION (expr) : input_location);
2664
2665   /* If our last subexpression already has a terminal label, reuse it.  */
2666   if (else_se)
2667     t = expr_last (else_);
2668   else if (then_se)
2669     t = expr_last (then_);
2670   else
2671     t = NULL;
2672   if (t && TREE_CODE (t) == LABEL_EXPR)
2673     end_label = LABEL_EXPR_LABEL (t);
2674
2675   /* If we don't care about jumping to the 'else' branch, jump to the end
2676      if the condition is false.  */
2677   if (!false_label_p)
2678     false_label_p = &end_label;
2679
2680   /* We only want to emit these labels if we aren't hijacking them.  */
2681   emit_end = (end_label == NULL_TREE);
2682   emit_false = (false_label == NULL_TREE);
2683
2684   /* We only emit the jump over the else clause if we have to--if the
2685      then clause may fall through.  Otherwise we can wind up with a
2686      useless jump and a useless label at the end of gimplified code,
2687      which will cause us to think that this conditional as a whole
2688      falls through even if it doesn't.  If we then inline a function
2689      which ends with such a condition, that can cause us to issue an
2690      inappropriate warning about control reaching the end of a
2691      non-void function.  */
2692   jump_over_else = block_may_fallthru (then_);
2693
2694   pred = shortcut_cond_r (pred, true_label_p, false_label_p,
2695                           EXPR_HAS_LOCATION (expr)
2696                           ? EXPR_LOCATION (expr) : input_location);
2697
2698   expr = NULL;
2699   append_to_statement_list (pred, &expr);
2700
2701   append_to_statement_list (then_, &expr);
2702   if (else_se)
2703     {
2704       if (jump_over_else)
2705         {
2706           tree last = expr_last (expr);
2707           t = build_and_jump (&end_label);
2708           if (EXPR_HAS_LOCATION (last))
2709             SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
2710           append_to_statement_list (t, &expr);
2711         }
2712       if (emit_false)
2713         {
2714           t = build1 (LABEL_EXPR, void_type_node, false_label);
2715           append_to_statement_list (t, &expr);
2716         }
2717       append_to_statement_list (else_, &expr);
2718     }
2719   if (emit_end && end_label)
2720     {
2721       t = build1 (LABEL_EXPR, void_type_node, end_label);
2722       append_to_statement_list (t, &expr);
2723     }
2724
2725   return expr;
2726 }
2727
2728 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE.  */
2729
2730 tree
2731 gimple_boolify (tree expr)
2732 {
2733   tree type = TREE_TYPE (expr);
2734   location_t loc = EXPR_LOCATION (expr);
2735
2736   if (TREE_CODE (expr) == NE_EXPR
2737       && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
2738       && integer_zerop (TREE_OPERAND (expr, 1)))
2739     {
2740       tree call = TREE_OPERAND (expr, 0);
2741       tree fn = get_callee_fndecl (call);
2742
2743       /* For __builtin_expect ((long) (x), y) recurse into x as well
2744          if x is truth_value_p.  */
2745       if (fn
2746           && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2747           && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
2748           && call_expr_nargs (call) == 2)
2749         {
2750           tree arg = CALL_EXPR_ARG (call, 0);
2751           if (arg)
2752             {
2753               if (TREE_CODE (arg) == NOP_EXPR
2754                   && TREE_TYPE (arg) == TREE_TYPE (call))
2755                 arg = TREE_OPERAND (arg, 0);
2756               if (truth_value_p (TREE_CODE (arg)))
2757                 {
2758                   arg = gimple_boolify (arg);
2759                   CALL_EXPR_ARG (call, 0)
2760                     = fold_convert_loc (loc, TREE_TYPE (call), arg);
2761                 }
2762             }
2763         }
2764     }
2765
2766   if (TREE_CODE (type) == BOOLEAN_TYPE)
2767     return expr;
2768
2769   switch (TREE_CODE (expr))
2770     {
2771     case TRUTH_AND_EXPR:
2772     case TRUTH_OR_EXPR:
2773     case TRUTH_XOR_EXPR:
2774     case TRUTH_ANDIF_EXPR:
2775     case TRUTH_ORIF_EXPR:
2776       /* Also boolify the arguments of truth exprs.  */
2777       TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2778       /* FALLTHRU */
2779
2780     case TRUTH_NOT_EXPR:
2781       TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2782       /* FALLTHRU */
2783
2784     case EQ_EXPR: case NE_EXPR:
2785     case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2786       /* These expressions always produce boolean results.  */
2787       TREE_TYPE (expr) = boolean_type_node;
2788       return expr;
2789
2790     default:
2791       /* Other expressions that get here must have boolean values, but
2792          might need to be converted to the appropriate mode.  */
2793       return fold_convert_loc (loc, boolean_type_node, expr);
2794     }
2795 }
2796
2797 /* Given a conditional expression *EXPR_P without side effects, gimplify
2798    its operands.  New statements are inserted to PRE_P.  */
2799
2800 static enum gimplify_status
2801 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
2802 {
2803   tree expr = *expr_p, cond;
2804   enum gimplify_status ret, tret;
2805   enum tree_code code;
2806
2807   cond = gimple_boolify (COND_EXPR_COND (expr));
2808
2809   /* We need to handle && and || specially, as their gimplification
2810      creates pure cond_expr, thus leading to an infinite cycle otherwise.  */
2811   code = TREE_CODE (cond);
2812   if (code == TRUTH_ANDIF_EXPR)
2813     TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2814   else if (code == TRUTH_ORIF_EXPR)
2815     TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2816   ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
2817   COND_EXPR_COND (*expr_p) = cond;
2818
2819   tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2820                                    is_gimple_val, fb_rvalue);
2821   ret = MIN (ret, tret);
2822   tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2823                                    is_gimple_val, fb_rvalue);
2824
2825   return MIN (ret, tret);
2826 }
2827
2828 /* Returns true if evaluating EXPR could trap.
2829    EXPR is GENERIC, while tree_could_trap_p can be called
2830    only on GIMPLE.  */
2831
2832 static bool
2833 generic_expr_could_trap_p (tree expr)
2834 {
2835   unsigned i, n;
2836
2837   if (!expr || is_gimple_val (expr))
2838     return false;
2839
2840   if (!EXPR_P (expr) || tree_could_trap_p (expr))
2841     return true;
2842
2843   n = TREE_OPERAND_LENGTH (expr);
2844   for (i = 0; i < n; i++)
2845     if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
2846       return true;
2847
2848   return false;
2849 }
2850
2851 /*  Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2852     into
2853
2854     if (p)                      if (p)
2855       t1 = a;                     a;
2856     else                or      else
2857       t1 = b;                     b;
2858     t1;
2859
2860     The second form is used when *EXPR_P is of type void.
2861
2862     PRE_P points to the list where side effects that must happen before
2863       *EXPR_P should be stored.  */
2864
2865 static enum gimplify_status
2866 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
2867 {
2868   tree expr = *expr_p;
2869   tree type = TREE_TYPE (expr);
2870   location_t loc = EXPR_LOCATION (expr);
2871   tree tmp, arm1, arm2;
2872   enum gimplify_status ret;
2873   tree label_true, label_false, label_cont;
2874   bool have_then_clause_p, have_else_clause_p;
2875   gimple gimple_cond;
2876   enum tree_code pred_code;
2877   gimple_seq seq = NULL;
2878
2879   /* If this COND_EXPR has a value, copy the values into a temporary within
2880      the arms.  */
2881   if (!VOID_TYPE_P (type))
2882     {
2883       tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
2884       tree result;
2885
2886       /* If either an rvalue is ok or we do not require an lvalue, create the
2887          temporary.  But we cannot do that if the type is addressable.  */
2888       if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
2889           && !TREE_ADDRESSABLE (type))
2890         {
2891           if (gimplify_ctxp->allow_rhs_cond_expr
2892               /* If either branch has side effects or could trap, it can't be
2893                  evaluated unconditionally.  */
2894               && !TREE_SIDE_EFFECTS (then_)
2895               && !generic_expr_could_trap_p (then_)
2896               && !TREE_SIDE_EFFECTS (else_)
2897               && !generic_expr_could_trap_p (else_))
2898             return gimplify_pure_cond_expr (expr_p, pre_p);
2899
2900           tmp = create_tmp_var (type, "iftmp");
2901           result = tmp;
2902         }
2903
2904       /* Otherwise, only create and copy references to the values.  */
2905       else
2906         {
2907           type = build_pointer_type (type);
2908
2909           if (!VOID_TYPE_P (TREE_TYPE (then_)))
2910             then_ = build_fold_addr_expr_loc (loc, then_);
2911
2912           if (!VOID_TYPE_P (TREE_TYPE (else_)))
2913             else_ = build_fold_addr_expr_loc (loc, else_);
2914  
2915           expr
2916             = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
2917
2918           tmp = create_tmp_var (type, "iftmp");
2919           result = build_fold_indirect_ref_loc (loc, tmp);
2920         }
2921
2922       /* Build the new then clause, `tmp = then_;'.  But don't build the
2923          assignment if the value is void; in C++ it can be if it's a throw.  */
2924       if (!VOID_TYPE_P (TREE_TYPE (then_)))
2925         TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
2926
2927       /* Similarly, build the new else clause, `tmp = else_;'.  */
2928       if (!VOID_TYPE_P (TREE_TYPE (else_)))
2929         TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
2930
2931       TREE_TYPE (expr) = void_type_node;
2932       recalculate_side_effects (expr);
2933
2934       /* Move the COND_EXPR to the prequeue.  */
2935       gimplify_stmt (&expr, pre_p);
2936
2937       *expr_p = result;
2938       return GS_ALL_DONE;
2939     }
2940
2941   /* Make sure the condition has BOOLEAN_TYPE.  */
2942   TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2943
2944   /* Break apart && and || conditions.  */
2945   if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2946       || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2947     {
2948       expr = shortcut_cond_expr (expr);
2949
2950       if (expr != *expr_p)
2951         {
2952           *expr_p = expr;
2953
2954           /* We can't rely on gimplify_expr to re-gimplify the expanded
2955              form properly, as cleanups might cause the target labels to be
2956              wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
2957              set up a conditional context.  */
2958           gimple_push_condition ();
2959           gimplify_stmt (expr_p, &seq);
2960           gimple_pop_condition (pre_p);
2961           gimple_seq_add_seq (pre_p, seq);
2962
2963           return GS_ALL_DONE;
2964         }
2965     }
2966
2967   /* Now do the normal gimplification.  */
2968
2969   /* Gimplify condition.  */
2970   ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
2971                        fb_rvalue);
2972   if (ret == GS_ERROR)
2973     return GS_ERROR;
2974   gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
2975
2976   gimple_push_condition ();
2977
2978   have_then_clause_p = have_else_clause_p = false;
2979   if (TREE_OPERAND (expr, 1) != NULL
2980       && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
2981       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
2982       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
2983           == current_function_decl)
2984       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
2985          have different locations, otherwise we end up with incorrect
2986          location information on the branches.  */
2987       && (optimize
2988           || !EXPR_HAS_LOCATION (expr)
2989           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
2990           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
2991     {
2992       label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
2993       have_then_clause_p = true;
2994     }
2995   else
2996     label_true = create_artificial_label (UNKNOWN_LOCATION);
2997   if (TREE_OPERAND (expr, 2) != NULL
2998       && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
2999       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3000       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3001           == current_function_decl)
3002       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3003          have different locations, otherwise we end up with incorrect
3004          location information on the branches.  */
3005       && (optimize
3006           || !EXPR_HAS_LOCATION (expr)
3007           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3008           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3009     {
3010       label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3011       have_else_clause_p = true;
3012     }
3013   else
3014     label_false = create_artificial_label (UNKNOWN_LOCATION);
3015
3016   gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3017                                  &arm2);
3018
3019   gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
3020                                    label_false);
3021
3022   gimplify_seq_add_stmt (&seq, gimple_cond);
3023   label_cont = NULL_TREE;
3024   if (!have_then_clause_p)
3025     {
3026       /* For if (...) {} else { code; } put label_true after
3027          the else block.  */
3028       if (TREE_OPERAND (expr, 1) == NULL_TREE
3029           && !have_else_clause_p
3030           && TREE_OPERAND (expr, 2) != NULL_TREE)
3031         label_cont = label_true;
3032       else
3033         {
3034           gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3035           have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3036           /* For if (...) { code; } else {} or
3037              if (...) { code; } else goto label; or
3038              if (...) { code; return; } else { ... }
3039              label_cont isn't needed.  */
3040           if (!have_else_clause_p
3041               && TREE_OPERAND (expr, 2) != NULL_TREE
3042               && gimple_seq_may_fallthru (seq))
3043             {
3044               gimple g;
3045               label_cont = create_artificial_label (UNKNOWN_LOCATION);
3046
3047               g = gimple_build_goto (label_cont);
3048
3049               /* GIMPLE_COND's are very low level; they have embedded
3050                  gotos.  This particular embedded goto should not be marked
3051                  with the location of the original COND_EXPR, as it would
3052                  correspond to the COND_EXPR's condition, not the ELSE or the
3053                  THEN arms.  To avoid marking it with the wrong location, flag
3054                  it as "no location".  */
3055               gimple_set_do_not_emit_location (g);
3056
3057               gimplify_seq_add_stmt (&seq, g);
3058             }
3059         }
3060     }
3061   if (!have_else_clause_p)
3062     {
3063       gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3064       have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3065     }
3066   if (label_cont)
3067     gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3068
3069   gimple_pop_condition (pre_p);
3070   gimple_seq_add_seq (pre_p, seq);
3071
3072   if (ret == GS_ERROR)
3073     ; /* Do nothing.  */
3074   else if (have_then_clause_p || have_else_clause_p)
3075     ret = GS_ALL_DONE;
3076   else
3077     {
3078       /* Both arms are empty; replace the COND_EXPR with its predicate.  */
3079       expr = TREE_OPERAND (expr, 0);
3080       gimplify_stmt (&expr, pre_p);
3081     }
3082
3083   *expr_p = NULL;
3084   return ret;
3085 }
3086
3087 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3088    to be marked addressable.
3089
3090    We cannot rely on such an expression being directly markable if a temporary
3091    has been created by the gimplification.  In this case, we create another
3092    temporary and initialize it with a copy, which will become a store after we
3093    mark it addressable.  This can happen if the front-end passed us something
3094    that it could not mark addressable yet, like a Fortran pass-by-reference
3095    parameter (int) floatvar.  */
3096
3097 static void
3098 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
3099 {
3100   while (handled_component_p (*expr_p))
3101     expr_p = &TREE_OPERAND (*expr_p, 0);
3102   if (is_gimple_reg (*expr_p))
3103     *expr_p = get_initialized_tmp_var (*expr_p, seq_p, NULL);
3104 }
3105
3106 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3107    a call to __builtin_memcpy.  */
3108
3109 static enum gimplify_status
3110 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3111                                 gimple_seq *seq_p)
3112 {
3113   tree t, to, to_ptr, from, from_ptr;
3114   gimple gs;
3115   location_t loc = EXPR_LOCATION (*expr_p);
3116
3117   to = TREE_OPERAND (*expr_p, 0);
3118   from = TREE_OPERAND (*expr_p, 1);
3119
3120   /* Mark the RHS addressable.  Beware that it may not be possible to do so
3121      directly if a temporary has been created by the gimplification.  */
3122   prepare_gimple_addressable (&from, seq_p);
3123
3124   mark_addressable (from);
3125   from_ptr = build_fold_addr_expr_loc (loc, from);
3126   gimplify_arg (&from_ptr, seq_p, loc);
3127
3128   mark_addressable (to);
3129   to_ptr = build_fold_addr_expr_loc (loc, to);
3130   gimplify_arg (&to_ptr, seq_p, loc);
3131
3132   t = implicit_built_in_decls[BUILT_IN_MEMCPY];
3133
3134   gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3135
3136   if (want_value)
3137     {
3138       /* tmp = memcpy() */
3139       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3140       gimple_call_set_lhs (gs, t);
3141       gimplify_seq_add_stmt (seq_p, gs);
3142
3143       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3144       return GS_ALL_DONE;
3145     }
3146
3147   gimplify_seq_add_stmt (seq_p, gs);
3148   *expr_p = NULL;
3149   return GS_ALL_DONE;
3150 }
3151
3152 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3153    a call to __builtin_memset.  In this case we know that the RHS is
3154    a CONSTRUCTOR with an empty element list.  */
3155
3156 static enum gimplify_status
3157 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3158                                 gimple_seq *seq_p)
3159 {
3160   tree t, from, to, to_ptr;
3161   gimple gs;
3162   location_t loc = EXPR_LOCATION (*expr_p);
3163
3164   /* Assert our assumptions, to abort instead of producing wrong code
3165      silently if they are not met.  Beware that the RHS CONSTRUCTOR might
3166      not be immediately exposed.  */
3167   from = TREE_OPERAND (*expr_p, 1);
3168   if (TREE_CODE (from) == WITH_SIZE_EXPR)
3169     from = TREE_OPERAND (from, 0);
3170
3171   gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3172               && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
3173
3174   /* Now proceed.  */
3175   to = TREE_OPERAND (*expr_p, 0);
3176
3177   to_ptr = build_fold_addr_expr_loc (loc, to);
3178   gimplify_arg (&to_ptr, seq_p, loc);
3179   t = implicit_built_in_decls[BUILT_IN_MEMSET];
3180
3181   gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3182
3183   if (want_value)
3184     {
3185       /* tmp = memset() */
3186       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3187       gimple_call_set_lhs (gs, t);
3188       gimplify_seq_add_stmt (seq_p, gs);
3189
3190       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3191       return GS_ALL_DONE;
3192     }
3193
3194   gimplify_seq_add_stmt (seq_p, gs);
3195   *expr_p = NULL;
3196   return GS_ALL_DONE;
3197 }
3198
3199 /* A subroutine of gimplify_init_ctor_preeval.  Called via walk_tree,
3200    determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3201    assignment.  Returns non-null if we detect a potential overlap.  */
3202
3203 struct gimplify_init_ctor_preeval_data
3204 {
3205   /* The base decl of the lhs object.  May be NULL, in which case we
3206      have to assume the lhs is indirect.  */
3207   tree lhs_base_decl;
3208
3209   /* The alias set of the lhs object.  */
3210   alias_set_type lhs_alias_set;
3211 };
3212
3213 static tree
3214 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3215 {
3216   struct gimplify_init_ctor_preeval_data *data
3217     = (struct gimplify_init_ctor_preeval_data *) xdata;
3218   tree t = *tp;
3219
3220   /* If we find the base object, obviously we have overlap.  */
3221   if (data->lhs_base_decl == t)
3222     return t;
3223
3224   /* If the constructor component is indirect, determine if we have a
3225      potential overlap with the lhs.  The only bits of information we
3226      have to go on at this point are addressability and alias sets.  */
3227   if (TREE_CODE (t) == INDIRECT_REF
3228       && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3229       && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3230     return t;
3231
3232   /* If the constructor component is a call, determine if it can hide a
3233      potential overlap with the lhs through an INDIRECT_REF like above.  */
3234   if (TREE_CODE (t) == CALL_EXPR)
3235     {
3236       tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3237
3238       for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3239         if (POINTER_TYPE_P (TREE_VALUE (type))
3240             && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3241             && alias_sets_conflict_p (data->lhs_alias_set,
3242                                       get_alias_set
3243                                         (TREE_TYPE (TREE_VALUE (type)))))
3244           return t;
3245     }
3246
3247   if (IS_TYPE_OR_DECL_P (t))
3248     *walk_subtrees = 0;
3249   return NULL;
3250 }
3251
3252 /* A subroutine of gimplify_init_constructor.  Pre-evaluate EXPR,
3253    force values that overlap with the lhs (as described by *DATA)
3254    into temporaries.  */
3255
3256 static void
3257 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3258                             struct gimplify_init_ctor_preeval_data *data)
3259 {
3260   enum gimplify_status one;
3261
3262   /* If the value is constant, then there's nothing to pre-evaluate.  */
3263   if (TREE_CONSTANT (*expr_p))
3264     {
3265       /* Ensure it does not have side effects, it might contain a reference to
3266          the object we're initializing.  */
3267       gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3268       return;
3269     }
3270
3271   /* If the type has non-trivial constructors, we can't pre-evaluate.  */
3272   if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3273     return;
3274
3275   /* Recurse for nested constructors.  */
3276   if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3277     {
3278       unsigned HOST_WIDE_INT ix;
3279       constructor_elt *ce;
3280       VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
3281
3282       for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
3283         gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3284
3285       return;
3286     }
3287
3288   /* If this is a variable sized type, we must remember the size.  */
3289   maybe_with_size_expr (expr_p);
3290
3291   /* Gimplify the constructor element to something appropriate for the rhs
3292      of a MODIFY_EXPR.  Given that we know the LHS is an aggregate, we know
3293      the gimplifier will consider this a store to memory.  Doing this
3294      gimplification now means that we won't have to deal with complicated
3295      language-specific trees, nor trees like SAVE_EXPR that can induce
3296      exponential search behavior.  */
3297   one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3298   if (one == GS_ERROR)
3299     {
3300       *expr_p = NULL;
3301       return;
3302     }
3303
3304   /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3305      with the lhs, since "a = { .x=a }" doesn't make sense.  This will
3306      always be true for all scalars, since is_gimple_mem_rhs insists on a
3307      temporary variable for them.  */
3308   if (DECL_P (*expr_p))
3309     return;
3310
3311   /* If this is of variable size, we have no choice but to assume it doesn't
3312      overlap since we can't make a temporary for it.  */
3313   if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3314     return;
3315
3316   /* Otherwise, we must search for overlap ...  */
3317   if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3318     return;
3319
3320   /* ... and if found, force the value into a temporary.  */
3321   *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3322 }
3323
3324 /* A subroutine of gimplify_init_ctor_eval.  Create a loop for
3325    a RANGE_EXPR in a CONSTRUCTOR for an array.
3326
3327       var = lower;
3328     loop_entry:
3329       object[var] = value;
3330       if (var == upper)
3331         goto loop_exit;
3332       var = var + 1;
3333       goto loop_entry;
3334     loop_exit:
3335
3336    We increment var _after_ the loop exit check because we might otherwise
3337    fail if upper == TYPE_MAX_VALUE (type for upper).
3338
3339    Note that we never have to deal with SAVE_EXPRs here, because this has
3340    already been taken care of for us, in gimplify_init_ctor_preeval().  */
3341
3342 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
3343                                      gimple_seq *, bool);
3344
3345 static void
3346 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3347                                tree value, tree array_elt_type,
3348                                gimple_seq *pre_p, bool cleared)
3349 {
3350   tree loop_entry_label, loop_exit_label, fall_thru_label;
3351   tree var, var_type, cref, tmp;
3352
3353   loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
3354   loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
3355   fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
3356
3357   /* Create and initialize the index variable.  */
3358   var_type = TREE_TYPE (upper);
3359   var = create_tmp_var (var_type, NULL);
3360   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3361
3362   /* Add the loop entry label.  */
3363   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3364
3365   /* Build the reference.  */
3366   cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3367                  var, NULL_TREE, NULL_TREE);
3368
3369   /* If we are a constructor, just call gimplify_init_ctor_eval to do
3370      the store.  Otherwise just assign value to the reference.  */
3371
3372   if (TREE_CODE (value) == CONSTRUCTOR)
3373     /* NB we might have to call ourself recursively through
3374        gimplify_init_ctor_eval if the value is a constructor.  */
3375     gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3376                              pre_p, cleared);
3377   else
3378     gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3379
3380   /* We exit the loop when the index var is equal to the upper bound.  */
3381   gimplify_seq_add_stmt (pre_p,
3382                          gimple_build_cond (EQ_EXPR, var, upper,
3383                                             loop_exit_label, fall_thru_label));
3384
3385   gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3386
3387   /* Otherwise, increment the index var...  */
3388   tmp = build2 (PLUS_EXPR, var_type, var,
3389                 fold_convert (var_type, integer_one_node));
3390   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3391
3392   /* ...and jump back to the loop entry.  */
3393   gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3394
3395   /* Add the loop exit label.  */
3396   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3397 }
3398
3399 /* Return true if FDECL is accessing a field that is zero sized.  */
3400
3401 static bool
3402 zero_sized_field_decl (const_tree fdecl)
3403 {
3404   if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3405       && integer_zerop (DECL_SIZE (fdecl)))
3406     return true;
3407   return false;
3408 }
3409
3410 /* Return true if TYPE is zero sized.  */
3411
3412 static bool
3413 zero_sized_type (const_tree type)
3414 {
3415   if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3416       && integer_zerop (TYPE_SIZE (type)))
3417     return true;
3418   return false;
3419 }
3420
3421 /* A subroutine of gimplify_init_constructor.  Generate individual
3422    MODIFY_EXPRs for a CONSTRUCTOR.  OBJECT is the LHS against which the
3423    assignments should happen.  ELTS is the CONSTRUCTOR_ELTS of the
3424    CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
3425    zeroed first.  */
3426
3427 static void
3428 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3429                          gimple_seq *pre_p, bool cleared)
3430 {
3431   tree array_elt_type = NULL;
3432   unsigned HOST_WIDE_INT ix;
3433   tree purpose, value;
3434
3435   if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3436     array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3437
3438   FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3439     {
3440       tree cref;
3441
3442       /* NULL values are created above for gimplification errors.  */
3443       if (value == NULL)
3444         continue;
3445
3446       if (cleared && initializer_zerop (value))
3447         continue;
3448
3449       /* ??? Here's to hoping the front end fills in all of the indices,
3450          so we don't have to figure out what's missing ourselves.  */
3451       gcc_assert (purpose);
3452
3453       /* Skip zero-sized fields, unless value has side-effects.  This can
3454          happen with calls to functions returning a zero-sized type, which
3455          we shouldn't discard.  As a number of downstream passes don't
3456          expect sets of zero-sized fields, we rely on the gimplification of
3457          the MODIFY_EXPR we make below to drop the assignment statement.  */
3458       if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3459         continue;
3460
3461       /* If we have a RANGE_EXPR, we have to build a loop to assign the
3462          whole range.  */
3463       if (TREE_CODE (purpose) == RANGE_EXPR)
3464         {
3465           tree lower = TREE_OPERAND (purpose, 0);
3466           tree upper = TREE_OPERAND (purpose, 1);
3467
3468           /* If the lower bound is equal to upper, just treat it as if
3469              upper was the index.  */
3470           if (simple_cst_equal (lower, upper))
3471             purpose = upper;
3472           else
3473             {
3474               gimplify_init_ctor_eval_range (object, lower, upper, value,
3475                                              array_elt_type, pre_p, cleared);
3476               continue;
3477             }
3478         }
3479
3480       if (array_elt_type)
3481         {
3482           /* Do not use bitsizetype for ARRAY_REF indices.  */
3483           if (TYPE_DOMAIN (TREE_TYPE (object)))
3484             purpose = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3485                                     purpose);
3486           cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3487                          purpose, NULL_TREE, NULL_TREE);
3488         }
3489       else
3490         {
3491           gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3492           cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3493                          unshare_expr (object), purpose, NULL_TREE);
3494         }
3495
3496       if (TREE_CODE (value) == CONSTRUCTOR
3497           && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3498         gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3499                                  pre_p, cleared);
3500       else
3501         {
3502           tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3503           gimplify_and_add (init, pre_p);
3504           ggc_free (init);
3505         }
3506     }
3507 }
3508
3509
3510 /* Returns the appropriate RHS predicate for this LHS.  */
3511
3512 gimple_predicate
3513 rhs_predicate_for (tree lhs)
3514 {
3515   if (is_gimple_reg (lhs))
3516     return is_gimple_reg_rhs_or_call;
3517   else
3518     return is_gimple_mem_rhs_or_call;
3519 }
3520
3521 /* Gimplify a C99 compound literal expression.  This just means adding
3522    the DECL_EXPR before the current statement and using its anonymous
3523    decl instead.  */
3524
3525 static enum gimplify_status
3526 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p)
3527 {
3528   tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
3529   tree decl = DECL_EXPR_DECL (decl_s);
3530   /* Mark the decl as addressable if the compound literal
3531      expression is addressable now, otherwise it is marked too late
3532      after we gimplify the initialization expression.  */
3533   if (TREE_ADDRESSABLE (*expr_p))
3534     TREE_ADDRESSABLE (decl) = 1;
3535
3536   /* Preliminarily mark non-addressed complex variables as eligible
3537      for promotion to gimple registers.  We'll transform their uses
3538      as we find them.  */
3539   if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
3540        || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
3541       && !TREE_THIS_VOLATILE (decl)
3542       && !needs_to_live_in_memory (decl))
3543     DECL_GIMPLE_REG_P (decl) = 1;
3544
3545   /* This decl isn't mentioned in the enclosing block, so add it to the
3546      list of temps.  FIXME it seems a bit of a kludge to say that
3547      anonymous artificial vars aren't pushed, but everything else is.  */
3548   if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
3549     gimple_add_tmp_var (decl);
3550
3551   gimplify_and_add (decl_s, pre_p);
3552   *expr_p = decl;
3553   return GS_OK;
3554 }
3555
3556 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3557    return a new CONSTRUCTOR if something changed.  */
3558
3559 static tree
3560 optimize_compound_literals_in_ctor (tree orig_ctor)
3561 {
3562   tree ctor = orig_ctor;
3563   VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
3564   unsigned int idx, num = VEC_length (constructor_elt, elts);
3565
3566   for (idx = 0; idx < num; idx++)
3567     {
3568       tree value = VEC_index (constructor_elt, elts, idx)->value;
3569       tree newval = value;
3570       if (TREE_CODE (value) == CONSTRUCTOR)
3571         newval = optimize_compound_literals_in_ctor (value);
3572       else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
3573         {
3574           tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
3575           tree decl = DECL_EXPR_DECL (decl_s);
3576           tree init = DECL_INITIAL (decl);
3577
3578           if (!TREE_ADDRESSABLE (value)
3579               && !TREE_ADDRESSABLE (decl)
3580               && init)
3581             newval = optimize_compound_literals_in_ctor (init);
3582         }
3583       if (newval == value)
3584         continue;
3585
3586       if (ctor == orig_ctor)
3587         {
3588           ctor = copy_node (orig_ctor);
3589           CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
3590           elts = CONSTRUCTOR_ELTS (ctor);
3591         }
3592       VEC_index (constructor_elt, elts, idx)->value = newval;
3593     }
3594   return ctor;
3595 }
3596
3597
3598
3599 /* A subroutine of gimplify_modify_expr.  Break out elements of a
3600    CONSTRUCTOR used as an initializer into separate&n