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