OSDN Git Service

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