Merge branch 'vendor/GCC47'
[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 /* The VAR_DECLs created for nonlocal VLAs for debug info purposes.  */
1926 static tree nonlocal_vla_vars;
1927
1928 /* Gimplify a VAR_DECL or PARM_DECL.  Return GS_OK if we expanded a
1929    DECL_VALUE_EXPR, and it's worth re-examining things.  */
1930
1931 static enum gimplify_status
1932 gimplify_var_or_parm_decl (tree *expr_p)
1933 {
1934   tree decl = *expr_p;
1935
1936   /* ??? If this is a local variable, and it has not been seen in any
1937      outer BIND_EXPR, then it's probably the result of a duplicate
1938      declaration, for which we've already issued an error.  It would
1939      be really nice if the front end wouldn't leak these at all.
1940      Currently the only known culprit is C++ destructors, as seen
1941      in g++.old-deja/g++.jason/binding.C.  */
1942   if (TREE_CODE (decl) == VAR_DECL
1943       && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1944       && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1945       && decl_function_context (decl) == current_function_decl)
1946     {
1947       gcc_assert (seen_error ());
1948       return GS_ERROR;
1949     }
1950
1951   /* When within an OpenMP context, notice uses of variables.  */
1952   if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1953     return GS_ALL_DONE;
1954
1955   /* If the decl is an alias for another expression, substitute it now.  */
1956   if (DECL_HAS_VALUE_EXPR_P (decl))
1957     {
1958       tree value_expr = DECL_VALUE_EXPR (decl);
1959
1960       /* For referenced nonlocal VLAs add a decl for debugging purposes
1961          to the current function.  */
1962       if (TREE_CODE (decl) == VAR_DECL
1963           && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1964           && nonlocal_vlas != NULL
1965           && TREE_CODE (value_expr) == INDIRECT_REF
1966           && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
1967           && decl_function_context (decl) != current_function_decl)
1968         {
1969           struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1970           while (ctx && ctx->region_type == ORT_WORKSHARE)
1971             ctx = ctx->outer_context;
1972           if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
1973             {
1974               tree copy = copy_node (decl);
1975
1976               lang_hooks.dup_lang_specific_decl (copy);
1977               SET_DECL_RTL (copy, 0);
1978               TREE_USED (copy) = 1;
1979               DECL_CHAIN (copy) = nonlocal_vla_vars;
1980               nonlocal_vla_vars = copy;
1981               SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
1982               DECL_HAS_VALUE_EXPR_P (copy) = 1;
1983             }
1984         }
1985
1986       *expr_p = unshare_expr (value_expr);
1987       return GS_OK;
1988     }
1989
1990   return GS_ALL_DONE;
1991 }
1992
1993 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1994    node *EXPR_P.
1995
1996       compound_lval
1997               : min_lval '[' val ']'
1998               | min_lval '.' ID
1999               | compound_lval '[' val ']'
2000               | compound_lval '.' ID
2001
2002    This is not part of the original SIMPLE definition, which separates
2003    array and member references, but it seems reasonable to handle them
2004    together.  Also, this way we don't run into problems with union
2005    aliasing; gcc requires that for accesses through a union to alias, the
2006    union reference must be explicit, which was not always the case when we
2007    were splitting up array and member refs.
2008
2009    PRE_P points to the sequence where side effects that must happen before
2010      *EXPR_P should be stored.
2011
2012    POST_P points to the sequence where side effects that must happen after
2013      *EXPR_P should be stored.  */
2014
2015 static enum gimplify_status
2016 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2017                         fallback_t fallback)
2018 {
2019   tree *p;
2020   VEC(tree,heap) *stack;
2021   enum gimplify_status ret = GS_ALL_DONE, tret;
2022   int i;
2023   location_t loc = EXPR_LOCATION (*expr_p);
2024   tree expr = *expr_p;
2025
2026   /* Create a stack of the subexpressions so later we can walk them in
2027      order from inner to outer.  */
2028   stack = VEC_alloc (tree, heap, 10);
2029
2030   /* We can handle anything that get_inner_reference can deal with.  */
2031   for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
2032     {
2033     restart:
2034       /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs.  */
2035       if (TREE_CODE (*p) == INDIRECT_REF)
2036         *p = fold_indirect_ref_loc (loc, *p);
2037
2038       if (handled_component_p (*p))
2039         ;
2040       /* Expand DECL_VALUE_EXPR now.  In some cases that may expose
2041          additional COMPONENT_REFs.  */
2042       else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
2043                && gimplify_var_or_parm_decl (p) == GS_OK)
2044         goto restart;
2045       else
2046         break;
2047
2048       VEC_safe_push (tree, heap, stack, *p);
2049     }
2050
2051   gcc_assert (VEC_length (tree, stack));
2052
2053   /* Now STACK is a stack of pointers to all the refs we've walked through
2054      and P points to the innermost expression.
2055
2056      Java requires that we elaborated nodes in source order.  That
2057      means we must gimplify the inner expression followed by each of
2058      the indices, in order.  But we can't gimplify the inner
2059      expression until we deal with any variable bounds, sizes, or
2060      positions in order to deal with PLACEHOLDER_EXPRs.
2061
2062      So we do this in three steps.  First we deal with the annotations
2063      for any variables in the components, then we gimplify the base,
2064      then we gimplify any indices, from left to right.  */
2065   for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
2066     {
2067       tree t = VEC_index (tree, stack, i);
2068
2069       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2070         {
2071           /* Gimplify the low bound and element type size and put them into
2072              the ARRAY_REF.  If these values are set, they have already been
2073              gimplified.  */
2074           if (TREE_OPERAND (t, 2) == NULL_TREE)
2075             {
2076               tree low = unshare_expr (array_ref_low_bound (t));
2077               if (!is_gimple_min_invariant (low))
2078                 {
2079                   TREE_OPERAND (t, 2) = low;
2080                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2081                                         post_p, is_gimple_reg,
2082                                         fb_rvalue);
2083                   ret = MIN (ret, tret);
2084                 }
2085             }
2086           else
2087             {
2088               tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2089                                     is_gimple_reg, fb_rvalue);
2090               ret = MIN (ret, tret);
2091             }
2092
2093           if (TREE_OPERAND (t, 3) == NULL_TREE)
2094             {
2095               tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
2096               tree elmt_size = unshare_expr (array_ref_element_size (t));
2097               tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
2098
2099               /* Divide the element size by the alignment of the element
2100                  type (above).  */
2101               elmt_size
2102                 = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
2103
2104               if (!is_gimple_min_invariant (elmt_size))
2105                 {
2106                   TREE_OPERAND (t, 3) = elmt_size;
2107                   tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
2108                                         post_p, is_gimple_reg,
2109                                         fb_rvalue);
2110                   ret = MIN (ret, tret);
2111                 }
2112             }
2113           else
2114             {
2115               tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
2116                                     is_gimple_reg, fb_rvalue);
2117               ret = MIN (ret, tret);
2118             }
2119         }
2120       else if (TREE_CODE (t) == COMPONENT_REF)
2121         {
2122           /* Set the field offset into T and gimplify it.  */
2123           if (TREE_OPERAND (t, 2) == NULL_TREE)
2124             {
2125               tree offset = unshare_expr (component_ref_field_offset (t));
2126               tree field = TREE_OPERAND (t, 1);
2127               tree factor
2128                 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
2129
2130               /* Divide the offset by its alignment.  */
2131               offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2132
2133               if (!is_gimple_min_invariant (offset))
2134                 {
2135                   TREE_OPERAND (t, 2) = offset;
2136                   tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2137                                         post_p, is_gimple_reg,
2138                                         fb_rvalue);
2139                   ret = MIN (ret, tret);
2140                 }
2141             }
2142           else
2143             {
2144               tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2145                                     is_gimple_reg, fb_rvalue);
2146               ret = MIN (ret, tret);
2147             }
2148         }
2149     }
2150
2151   /* Step 2 is to gimplify the base expression.  Make sure lvalue is set
2152      so as to match the min_lval predicate.  Failure to do so may result
2153      in the creation of large aggregate temporaries.  */
2154   tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2155                         fallback | fb_lvalue);
2156   ret = MIN (ret, tret);
2157
2158   /* And finally, the indices and operands to BIT_FIELD_REF.  During this
2159      loop we also remove any useless conversions.  */
2160   for (; VEC_length (tree, stack) > 0; )
2161     {
2162       tree t = VEC_pop (tree, stack);
2163
2164       if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2165         {
2166           /* Gimplify the dimension.  */
2167           if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2168             {
2169               tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2170                                     is_gimple_val, fb_rvalue);
2171               ret = MIN (ret, tret);
2172             }
2173         }
2174       else if (TREE_CODE (t) == BIT_FIELD_REF)
2175         {
2176           tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2177                                 is_gimple_val, fb_rvalue);
2178           ret = MIN (ret, tret);
2179           tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2180                                 is_gimple_val, fb_rvalue);
2181           ret = MIN (ret, tret);
2182         }
2183
2184       STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2185
2186       /* The innermost expression P may have originally had
2187          TREE_SIDE_EFFECTS set which would have caused all the outer
2188          expressions in *EXPR_P leading to P to also have had
2189          TREE_SIDE_EFFECTS set.  */
2190       recalculate_side_effects (t);
2191     }
2192
2193   /* If the outermost expression is a COMPONENT_REF, canonicalize its type.  */
2194   if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2195     {
2196       canonicalize_component_ref (expr_p);
2197     }
2198
2199   VEC_free (tree, heap, stack);
2200
2201   gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
2202
2203   return ret;
2204 }
2205
2206 /*  Gimplify the self modifying expression pointed to by EXPR_P
2207     (++, --, +=, -=).
2208
2209     PRE_P points to the list where side effects that must happen before
2210         *EXPR_P should be stored.
2211
2212     POST_P points to the list where side effects that must happen after
2213         *EXPR_P should be stored.
2214
2215     WANT_VALUE is nonzero iff we want to use the value of this expression
2216         in another expression.  */
2217
2218 static enum gimplify_status
2219 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2220                         bool want_value)
2221 {
2222   enum tree_code code;
2223   tree lhs, lvalue, rhs, t1;
2224   gimple_seq post = NULL, *orig_post_p = post_p;
2225   bool postfix;
2226   enum tree_code arith_code;
2227   enum gimplify_status ret;
2228   location_t loc = EXPR_LOCATION (*expr_p);
2229
2230   code = TREE_CODE (*expr_p);
2231
2232   gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2233               || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2234
2235   /* Prefix or postfix?  */
2236   if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2237     /* Faster to treat as prefix if result is not used.  */
2238     postfix = want_value;
2239   else
2240     postfix = false;
2241
2242   /* For postfix, make sure the inner expression's post side effects
2243      are executed after side effects from this expression.  */
2244   if (postfix)
2245     post_p = &post;
2246
2247   /* Add or subtract?  */
2248   if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2249     arith_code = PLUS_EXPR;
2250   else
2251     arith_code = MINUS_EXPR;
2252
2253   /* Gimplify the LHS into a GIMPLE lvalue.  */
2254   lvalue = TREE_OPERAND (*expr_p, 0);
2255   ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2256   if (ret == GS_ERROR)
2257     return ret;
2258
2259   /* Extract the operands to the arithmetic operation.  */
2260   lhs = lvalue;
2261   rhs = TREE_OPERAND (*expr_p, 1);
2262
2263   /* For postfix operator, we evaluate the LHS to an rvalue and then use
2264      that as the result value and in the postqueue operation.  We also
2265      make sure to make lvalue a minimal lval, see
2266      gcc.c-torture/execute/20040313-1.c for an example where this matters.  */
2267   if (postfix)
2268     {
2269       if (!is_gimple_min_lval (lvalue))
2270         {
2271           mark_addressable (lvalue);
2272           lvalue = build_fold_addr_expr_loc (input_location, lvalue);
2273           gimplify_expr (&lvalue, pre_p, post_p, is_gimple_val, fb_rvalue);
2274           lvalue = build_fold_indirect_ref_loc (input_location, lvalue);
2275         }
2276       ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2277       if (ret == GS_ERROR)
2278         return ret;
2279     }
2280
2281   /* For POINTERs increment, use POINTER_PLUS_EXPR.  */
2282   if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2283     {
2284       rhs = convert_to_ptrofftype_loc (loc, rhs);
2285       if (arith_code == MINUS_EXPR)
2286         rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2287       arith_code = POINTER_PLUS_EXPR;
2288     }
2289
2290   t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
2291
2292   if (postfix)
2293     {
2294       gimplify_assign (lvalue, t1, orig_post_p);
2295       gimplify_seq_add_seq (orig_post_p, post);
2296       *expr_p = lhs;
2297       return GS_ALL_DONE;
2298     }
2299   else
2300     {
2301       *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2302       return GS_OK;
2303     }
2304 }
2305
2306 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR.  */
2307
2308 static void
2309 maybe_with_size_expr (tree *expr_p)
2310 {
2311   tree expr = *expr_p;
2312   tree type = TREE_TYPE (expr);
2313   tree size;
2314
2315   /* If we've already wrapped this or the type is error_mark_node, we can't do
2316      anything.  */
2317   if (TREE_CODE (expr) == WITH_SIZE_EXPR
2318       || type == error_mark_node)
2319     return;
2320
2321   /* If the size isn't known or is a constant, we have nothing to do.  */
2322   size = TYPE_SIZE_UNIT (type);
2323   if (!size || TREE_CODE (size) == INTEGER_CST)
2324     return;
2325
2326   /* Otherwise, make a WITH_SIZE_EXPR.  */
2327   size = unshare_expr (size);
2328   size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2329   *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2330 }
2331
2332 /* Helper for gimplify_call_expr.  Gimplify a single argument *ARG_P
2333    Store any side-effects in PRE_P.  CALL_LOCATION is the location of
2334    the CALL_EXPR.  */
2335
2336 static enum gimplify_status
2337 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location)
2338 {
2339   bool (*test) (tree);
2340   fallback_t fb;
2341
2342   /* In general, we allow lvalues for function arguments to avoid
2343      extra overhead of copying large aggregates out of even larger
2344      aggregates into temporaries only to copy the temporaries to
2345      the argument list.  Make optimizers happy by pulling out to
2346      temporaries those types that fit in registers.  */
2347   if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2348     test = is_gimple_val, fb = fb_rvalue;
2349   else
2350     {
2351       test = is_gimple_lvalue, fb = fb_either;
2352       /* Also strip a TARGET_EXPR that would force an extra copy.  */
2353       if (TREE_CODE (*arg_p) == TARGET_EXPR)
2354         {
2355           tree init = TARGET_EXPR_INITIAL (*arg_p);
2356           if (init
2357               && !VOID_TYPE_P (TREE_TYPE (init)))
2358             *arg_p = init;
2359         }
2360     }
2361
2362   /* If this is a variable sized type, we must remember the size.  */
2363   maybe_with_size_expr (arg_p);
2364
2365   /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c.  */
2366   /* Make sure arguments have the same location as the function call
2367      itself.  */
2368   protected_set_expr_location (*arg_p, call_location);
2369
2370   /* There is a sequence point before a function call.  Side effects in
2371      the argument list must occur before the actual call. So, when
2372      gimplifying arguments, force gimplify_expr to use an internal
2373      post queue which is then appended to the end of PRE_P.  */
2374   return gimplify_expr (arg_p, pre_p, NULL, test, fb);
2375 }
2376
2377 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2378    WANT_VALUE is true if the result of the call is desired.  */
2379
2380 static enum gimplify_status
2381 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2382 {
2383   tree fndecl, parms, p, fnptrtype;
2384   enum gimplify_status ret;
2385   int i, nargs;
2386   gimple call;
2387   bool builtin_va_start_p = FALSE;
2388   location_t loc = EXPR_LOCATION (*expr_p);
2389
2390   gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2391
2392   /* For reliable diagnostics during inlining, it is necessary that
2393      every call_expr be annotated with file and line.  */
2394   if (! EXPR_HAS_LOCATION (*expr_p))
2395     SET_EXPR_LOCATION (*expr_p, input_location);
2396
2397   /* This may be a call to a builtin function.
2398
2399      Builtin function calls may be transformed into different
2400      (and more efficient) builtin function calls under certain
2401      circumstances.  Unfortunately, gimplification can muck things
2402      up enough that the builtin expanders are not aware that certain
2403      transformations are still valid.
2404
2405      So we attempt transformation/gimplification of the call before
2406      we gimplify the CALL_EXPR.  At this time we do not manage to
2407      transform all calls in the same manner as the expanders do, but
2408      we do transform most of them.  */
2409   fndecl = get_callee_fndecl (*expr_p);
2410   if (fndecl && DECL_BUILT_IN (fndecl))
2411     {
2412       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2413
2414       if (new_tree && new_tree != *expr_p)
2415         {
2416           /* There was a transformation of this call which computes the
2417              same value, but in a more efficient way.  Return and try
2418              again.  */
2419           *expr_p = new_tree;
2420           return GS_OK;
2421         }
2422
2423       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2424           && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
2425         {
2426           builtin_va_start_p = TRUE;
2427           if (call_expr_nargs (*expr_p) < 2)
2428             {
2429               error ("too few arguments to function %<va_start%>");
2430               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2431               return GS_OK;
2432             }
2433
2434           if (fold_builtin_next_arg (*expr_p, true))
2435             {
2436               *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2437               return GS_OK;
2438             }
2439         }
2440     }
2441
2442   /* Remember the original function pointer type.  */
2443   fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
2444
2445   /* There is a sequence point before the call, so any side effects in
2446      the calling expression must occur before the actual call.  Force
2447      gimplify_expr to use an internal post queue.  */
2448   ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2449                        is_gimple_call_addr, fb_rvalue);
2450
2451   nargs = call_expr_nargs (*expr_p);
2452
2453   /* Get argument types for verification.  */
2454   fndecl = get_callee_fndecl (*expr_p);
2455   parms = NULL_TREE;
2456   if (fndecl)
2457     parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2458   else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2459     parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2460
2461   if (fndecl && DECL_ARGUMENTS (fndecl))
2462     p = DECL_ARGUMENTS (fndecl);
2463   else if (parms)
2464     p = parms;
2465   else
2466     p = NULL_TREE;
2467   for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2468     ;
2469
2470   /* If the last argument is __builtin_va_arg_pack () and it is not
2471      passed as a named argument, decrease the number of CALL_EXPR
2472      arguments and set instead the CALL_EXPR_VA_ARG_PACK flag.  */
2473   if (!p
2474       && i < nargs
2475       && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2476     {
2477       tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2478       tree last_arg_fndecl = get_callee_fndecl (last_arg);
2479
2480       if (last_arg_fndecl
2481           && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2482           && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2483           && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2484         {
2485           tree call = *expr_p;
2486
2487           --nargs;
2488           *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
2489                                           CALL_EXPR_FN (call),
2490                                           nargs, CALL_EXPR_ARGP (call));
2491
2492           /* Copy all CALL_EXPR flags, location and block, except
2493              CALL_EXPR_VA_ARG_PACK flag.  */
2494           CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2495           CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2496           CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2497             = CALL_EXPR_RETURN_SLOT_OPT (call);
2498           CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2499           SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
2500           TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2501
2502           /* Set CALL_EXPR_VA_ARG_PACK.  */
2503           CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2504         }
2505     }
2506
2507   /* Finally, gimplify the function arguments.  */
2508   if (nargs > 0)
2509     {
2510       for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2511            PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2512            PUSH_ARGS_REVERSED ? i-- : i++)
2513         {
2514           enum gimplify_status t;
2515
2516           /* Avoid gimplifying the second argument to va_start, which needs to
2517              be the plain PARM_DECL.  */
2518           if ((i != 1) || !builtin_va_start_p)
2519             {
2520               t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2521                                 EXPR_LOCATION (*expr_p));
2522
2523               if (t == GS_ERROR)
2524                 ret = GS_ERROR;
2525             }
2526         }
2527     }
2528
2529   /* Verify the function result.  */
2530   if (want_value && fndecl
2531       && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype))))
2532     {
2533       error_at (loc, "using result of function returning %<void%>");
2534       ret = GS_ERROR;
2535     }
2536
2537   /* Try this again in case gimplification exposed something.  */
2538   if (ret != GS_ERROR)
2539     {
2540       tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2541
2542       if (new_tree && new_tree != *expr_p)
2543         {
2544           /* There was a transformation of this call which computes the
2545              same value, but in a more efficient way.  Return and try
2546              again.  */
2547           *expr_p = new_tree;
2548           return GS_OK;
2549         }
2550     }
2551   else
2552     {
2553       *expr_p = error_mark_node;
2554       return GS_ERROR;
2555     }
2556
2557   /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2558      decl.  This allows us to eliminate redundant or useless
2559      calls to "const" functions.  */
2560   if (TREE_CODE (*expr_p) == CALL_EXPR)
2561     {
2562       int flags = call_expr_flags (*expr_p);
2563       if (flags & (ECF_CONST | ECF_PURE)
2564           /* An infinite loop is considered a side effect.  */
2565           && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2566         TREE_SIDE_EFFECTS (*expr_p) = 0;
2567     }
2568
2569   /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2570      and clear *EXPR_P.  Otherwise, leave *EXPR_P in its gimplified
2571      form and delegate the creation of a GIMPLE_CALL to
2572      gimplify_modify_expr.  This is always possible because when
2573      WANT_VALUE is true, the caller wants the result of this call into
2574      a temporary, which means that we will emit an INIT_EXPR in
2575      internal_get_tmp_var which will then be handled by
2576      gimplify_modify_expr.  */
2577   if (!want_value)
2578     {
2579       /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2580          have to do is replicate it as a GIMPLE_CALL tuple.  */
2581       gimple_stmt_iterator gsi;
2582       call = gimple_build_call_from_tree (*expr_p);
2583       gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
2584       gimplify_seq_add_stmt (pre_p, call);
2585       gsi = gsi_last (*pre_p);
2586       fold_stmt (&gsi);
2587       *expr_p = NULL_TREE;
2588     }
2589   else
2590     /* Remember the original function type.  */
2591     CALL_EXPR_FN (*expr_p) = build1 (NOP_EXPR, fnptrtype,
2592                                      CALL_EXPR_FN (*expr_p));
2593
2594   return ret;
2595 }
2596
2597 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2598    rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2599
2600    TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2601    condition is true or false, respectively.  If null, we should generate
2602    our own to skip over the evaluation of this specific expression.
2603
2604    LOCUS is the source location of the COND_EXPR.
2605
2606    This function is the tree equivalent of do_jump.
2607
2608    shortcut_cond_r should only be called by shortcut_cond_expr.  */
2609
2610 static tree
2611 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
2612                  location_t locus)
2613 {
2614   tree local_label = NULL_TREE;
2615   tree t, expr = NULL;
2616
2617   /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2618      retain the shortcut semantics.  Just insert the gotos here;
2619      shortcut_cond_expr will append the real blocks later.  */
2620   if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2621     {
2622       location_t new_locus;
2623
2624       /* Turn if (a && b) into
2625
2626          if (a); else goto no;
2627          if (b) goto yes; else goto no;
2628          (no:) */
2629
2630       if (false_label_p == NULL)
2631         false_label_p = &local_label;
2632
2633       /* Keep the original source location on the first 'if'.  */
2634       t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
2635       append_to_statement_list (t, &expr);
2636
2637       /* Set the source location of the && on the second 'if'.  */
2638       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2639       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2640                            new_locus);
2641       append_to_statement_list (t, &expr);
2642     }
2643   else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2644     {
2645       location_t new_locus;
2646
2647       /* Turn if (a || b) into
2648
2649          if (a) goto yes;
2650          if (b) goto yes; else goto no;
2651          (yes:) */
2652
2653       if (true_label_p == NULL)
2654         true_label_p = &local_label;
2655
2656       /* Keep the original source location on the first 'if'.  */
2657       t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
2658       append_to_statement_list (t, &expr);
2659
2660       /* Set the source location of the || on the second 'if'.  */
2661       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2662       t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2663                            new_locus);
2664       append_to_statement_list (t, &expr);
2665     }
2666   else if (TREE_CODE (pred) == COND_EXPR
2667            && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 1)))
2668            && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 2))))
2669     {
2670       location_t new_locus;
2671
2672       /* As long as we're messing with gotos, turn if (a ? b : c) into
2673          if (a)
2674            if (b) goto yes; else goto no;
2675          else
2676            if (c) goto yes; else goto no;
2677
2678          Don't do this if one of the arms has void type, which can happen
2679          in C++ when the arm is throw.  */
2680
2681       /* Keep the original source location on the first 'if'.  Set the source
2682          location of the ? on the second 'if'.  */
2683       new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2684       expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2685                      shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2686                                       false_label_p, locus),
2687                      shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2688                                       false_label_p, new_locus));
2689     }
2690   else
2691     {
2692       expr = build3 (COND_EXPR, void_type_node, pred,
2693                      build_and_jump (true_label_p),
2694                      build_and_jump (false_label_p));
2695       SET_EXPR_LOCATION (expr, locus);
2696     }
2697
2698   if (local_label)
2699     {
2700       t = build1 (LABEL_EXPR, void_type_node, local_label);
2701       append_to_statement_list (t, &expr);
2702     }
2703
2704   return expr;
2705 }
2706
2707 /* Given a conditional expression EXPR with short-circuit boolean
2708    predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2709    predicate appart into the equivalent sequence of conditionals.  */
2710
2711 static tree
2712 shortcut_cond_expr (tree expr)
2713 {
2714   tree pred = TREE_OPERAND (expr, 0);
2715   tree then_ = TREE_OPERAND (expr, 1);
2716   tree else_ = TREE_OPERAND (expr, 2);
2717   tree true_label, false_label, end_label, t;
2718   tree *true_label_p;
2719   tree *false_label_p;
2720   bool emit_end, emit_false, jump_over_else;
2721   bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2722   bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2723
2724   /* First do simple transformations.  */
2725   if (!else_se)
2726     {
2727       /* If there is no 'else', turn
2728            if (a && b) then c
2729          into
2730            if (a) if (b) then c.  */
2731       while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2732         {
2733           /* Keep the original source location on the first 'if'.  */
2734           location_t locus = EXPR_LOC_OR_HERE (expr);
2735           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2736           /* Set the source location of the && on the second 'if'.  */
2737           if (EXPR_HAS_LOCATION (pred))
2738             SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2739           then_ = shortcut_cond_expr (expr);
2740           then_se = then_ && TREE_SIDE_EFFECTS (then_);
2741           pred = TREE_OPERAND (pred, 0);
2742           expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2743           SET_EXPR_LOCATION (expr, locus);
2744         }
2745     }
2746
2747   if (!then_se)
2748     {
2749       /* If there is no 'then', turn
2750            if (a || b); else d
2751          into
2752            if (a); else if (b); else d.  */
2753       while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2754         {
2755           /* Keep the original source location on the first 'if'.  */
2756           location_t locus = EXPR_LOC_OR_HERE (expr);
2757           TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2758           /* Set the source location of the || on the second 'if'.  */
2759           if (EXPR_HAS_LOCATION (pred))
2760             SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2761           else_ = shortcut_cond_expr (expr);
2762           else_se = else_ && TREE_SIDE_EFFECTS (else_);
2763           pred = TREE_OPERAND (pred, 0);
2764           expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2765           SET_EXPR_LOCATION (expr, locus);
2766         }
2767     }
2768
2769   /* If we're done, great.  */
2770   if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2771       && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2772     return expr;
2773
2774   /* Otherwise we need to mess with gotos.  Change
2775        if (a) c; else d;
2776      to
2777        if (a); else goto no;
2778        c; goto end;
2779        no: d; end:
2780      and recursively gimplify the condition.  */
2781
2782   true_label = false_label = end_label = NULL_TREE;
2783
2784   /* If our arms just jump somewhere, hijack those labels so we don't
2785      generate jumps to jumps.  */
2786
2787   if (then_
2788       && TREE_CODE (then_) == GOTO_EXPR
2789       && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2790     {
2791       true_label = GOTO_DESTINATION (then_);
2792       then_ = NULL;
2793       then_se = false;
2794     }
2795
2796   if (else_
2797       && TREE_CODE (else_) == GOTO_EXPR
2798       && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2799     {
2800       false_label = GOTO_DESTINATION (else_);
2801       else_ = NULL;
2802       else_se = false;
2803     }
2804
2805   /* If we aren't hijacking a label for the 'then' branch, it falls through.  */
2806   if (true_label)
2807     true_label_p = &true_label;
2808   else
2809     true_label_p = NULL;
2810
2811   /* The 'else' branch also needs a label if it contains interesting code.  */
2812   if (false_label || else_se)
2813     false_label_p = &false_label;
2814   else
2815     false_label_p = NULL;
2816
2817   /* If there was nothing else in our arms, just forward the label(s).  */
2818   if (!then_se && !else_se)
2819     return shortcut_cond_r (pred, true_label_p, false_label_p,
2820                             EXPR_LOC_OR_HERE (expr));
2821
2822   /* If our last subexpression already has a terminal label, reuse it.  */
2823   if (else_se)
2824     t = expr_last (else_);
2825   else if (then_se)
2826     t = expr_last (then_);
2827   else
2828     t = NULL;
2829   if (t && TREE_CODE (t) == LABEL_EXPR)
2830     end_label = LABEL_EXPR_LABEL (t);
2831
2832   /* If we don't care about jumping to the 'else' branch, jump to the end
2833      if the condition is false.  */
2834   if (!false_label_p)
2835     false_label_p = &end_label;
2836
2837   /* We only want to emit these labels if we aren't hijacking them.  */
2838   emit_end = (end_label == NULL_TREE);
2839   emit_false = (false_label == NULL_TREE);
2840
2841   /* We only emit the jump over the else clause if we have to--if the
2842      then clause may fall through.  Otherwise we can wind up with a
2843      useless jump and a useless label at the end of gimplified code,
2844      which will cause us to think that this conditional as a whole
2845      falls through even if it doesn't.  If we then inline a function
2846      which ends with such a condition, that can cause us to issue an
2847      inappropriate warning about control reaching the end of a
2848      non-void function.  */
2849   jump_over_else = block_may_fallthru (then_);
2850
2851   pred = shortcut_cond_r (pred, true_label_p, false_label_p,
2852                           EXPR_LOC_OR_HERE (expr));
2853
2854   expr = NULL;
2855   append_to_statement_list (pred, &expr);
2856
2857   append_to_statement_list (then_, &expr);
2858   if (else_se)
2859     {
2860       if (jump_over_else)
2861         {
2862           tree last = expr_last (expr);
2863           t = build_and_jump (&end_label);
2864           if (EXPR_HAS_LOCATION (last))
2865             SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
2866           append_to_statement_list (t, &expr);
2867         }
2868       if (emit_false)
2869         {
2870           t = build1 (LABEL_EXPR, void_type_node, false_label);
2871           append_to_statement_list (t, &expr);
2872         }
2873       append_to_statement_list (else_, &expr);
2874     }
2875   if (emit_end && end_label)
2876     {
2877       t = build1 (LABEL_EXPR, void_type_node, end_label);
2878       append_to_statement_list (t, &expr);
2879     }
2880
2881   return expr;
2882 }
2883
2884 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE.  */
2885
2886 tree
2887 gimple_boolify (tree expr)
2888 {
2889   tree type = TREE_TYPE (expr);
2890   location_t loc = EXPR_LOCATION (expr);
2891
2892   if (TREE_CODE (expr) == NE_EXPR
2893       && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
2894       && integer_zerop (TREE_OPERAND (expr, 1)))
2895     {
2896       tree call = TREE_OPERAND (expr, 0);
2897       tree fn = get_callee_fndecl (call);
2898
2899       /* For __builtin_expect ((long) (x), y) recurse into x as well
2900          if x is truth_value_p.  */
2901       if (fn
2902           && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2903           && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
2904           && call_expr_nargs (call) == 2)
2905         {
2906           tree arg = CALL_EXPR_ARG (call, 0);
2907           if (arg)
2908             {
2909               if (TREE_CODE (arg) == NOP_EXPR
2910                   && TREE_TYPE (arg) == TREE_TYPE (call))
2911                 arg = TREE_OPERAND (arg, 0);
2912               if (truth_value_p (TREE_CODE (arg)))
2913                 {
2914                   arg = gimple_boolify (arg);
2915                   CALL_EXPR_ARG (call, 0)
2916                     = fold_convert_loc (loc, TREE_TYPE (call), arg);
2917                 }
2918             }
2919         }
2920     }
2921
2922   switch (TREE_CODE (expr))
2923     {
2924     case TRUTH_AND_EXPR:
2925     case TRUTH_OR_EXPR:
2926     case TRUTH_XOR_EXPR:
2927     case TRUTH_ANDIF_EXPR:
2928     case TRUTH_ORIF_EXPR:
2929       /* Also boolify the arguments of truth exprs.  */
2930       TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2931       /* FALLTHRU */
2932
2933     case TRUTH_NOT_EXPR:
2934       TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2935
2936       /* These expressions always produce boolean results.  */
2937       if (TREE_CODE (type) != BOOLEAN_TYPE)
2938         TREE_TYPE (expr) = boolean_type_node;
2939       return expr;
2940
2941     default:
2942       if (COMPARISON_CLASS_P (expr))
2943         {
2944           /* There expressions always prduce boolean results.  */
2945           if (TREE_CODE (type) != BOOLEAN_TYPE)
2946             TREE_TYPE (expr) = boolean_type_node;
2947           return expr;
2948         }
2949       /* Other expressions that get here must have boolean values, but
2950          might need to be converted to the appropriate mode.  */
2951       if (TREE_CODE (type) == BOOLEAN_TYPE)
2952         return expr;
2953       return fold_convert_loc (loc, boolean_type_node, expr);
2954     }
2955 }
2956
2957 /* Given a conditional expression *EXPR_P without side effects, gimplify
2958    its operands.  New statements are inserted to PRE_P.  */
2959
2960 static enum gimplify_status
2961 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
2962 {
2963   tree expr = *expr_p, cond;
2964   enum gimplify_status ret, tret;
2965   enum tree_code code;
2966
2967   cond = gimple_boolify (COND_EXPR_COND (expr));
2968
2969   /* We need to handle && and || specially, as their gimplification
2970      creates pure cond_expr, thus leading to an infinite cycle otherwise.  */
2971   code = TREE_CODE (cond);
2972   if (code == TRUTH_ANDIF_EXPR)
2973     TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2974   else if (code == TRUTH_ORIF_EXPR)
2975     TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2976   ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
2977   COND_EXPR_COND (*expr_p) = cond;
2978
2979   tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2980                                    is_gimple_val, fb_rvalue);
2981   ret = MIN (ret, tret);
2982   tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2983                                    is_gimple_val, fb_rvalue);
2984
2985   return MIN (ret, tret);
2986 }
2987
2988 /* Return true if evaluating EXPR could trap.
2989    EXPR is GENERIC, while tree_could_trap_p can be called
2990    only on GIMPLE.  */
2991
2992 static bool
2993 generic_expr_could_trap_p (tree expr)
2994 {
2995   unsigned i, n;
2996
2997   if (!expr || is_gimple_val (expr))
2998     return false;
2999
3000   if (!EXPR_P (expr) || tree_could_trap_p (expr))
3001     return true;
3002
3003   n = TREE_OPERAND_LENGTH (expr);
3004   for (i = 0; i < n; i++)
3005     if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
3006       return true;
3007
3008   return false;
3009 }
3010
3011 /*  Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3012     into
3013
3014     if (p)                      if (p)
3015       t1 = a;                     a;
3016     else                or      else
3017       t1 = b;                     b;
3018     t1;
3019
3020     The second form is used when *EXPR_P is of type void.
3021
3022     PRE_P points to the list where side effects that must happen before
3023       *EXPR_P should be stored.  */
3024
3025 static enum gimplify_status
3026 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
3027 {
3028   tree expr = *expr_p;
3029   tree type = TREE_TYPE (expr);
3030   location_t loc = EXPR_LOCATION (expr);
3031   tree tmp, arm1, arm2;
3032   enum gimplify_status ret;
3033   tree label_true, label_false, label_cont;
3034   bool have_then_clause_p, have_else_clause_p;
3035   gimple gimple_cond;
3036   enum tree_code pred_code;
3037   gimple_seq seq = NULL;
3038
3039   /* If this COND_EXPR has a value, copy the values into a temporary within
3040      the arms.  */
3041   if (!VOID_TYPE_P (type))
3042     {
3043       tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
3044       tree result;
3045
3046       /* If either an rvalue is ok or we do not require an lvalue, create the
3047          temporary.  But we cannot do that if the type is addressable.  */
3048       if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
3049           && !TREE_ADDRESSABLE (type))
3050         {
3051           if (gimplify_ctxp->allow_rhs_cond_expr
3052               /* If either branch has side effects or could trap, it can't be
3053                  evaluated unconditionally.  */
3054               && !TREE_SIDE_EFFECTS (then_)
3055               && !generic_expr_could_trap_p (then_)
3056               && !TREE_SIDE_EFFECTS (else_)
3057               && !generic_expr_could_trap_p (else_))
3058             return gimplify_pure_cond_expr (expr_p, pre_p);
3059
3060           tmp = create_tmp_var (type, "iftmp");
3061           result = tmp;
3062         }
3063
3064       /* Otherwise, only create and copy references to the values.  */
3065       else
3066         {
3067           type = build_pointer_type (type);
3068
3069           if (!VOID_TYPE_P (TREE_TYPE (then_)))
3070             then_ = build_fold_addr_expr_loc (loc, then_);
3071
3072           if (!VOID_TYPE_P (TREE_TYPE (else_)))
3073             else_ = build_fold_addr_expr_loc (loc, else_);
3074  
3075           expr
3076             = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
3077
3078           tmp = create_tmp_var (type, "iftmp");
3079           result = build_simple_mem_ref_loc (loc, tmp);
3080         }
3081
3082       /* Build the new then clause, `tmp = then_;'.  But don't build the
3083          assignment if the value is void; in C++ it can be if it's a throw.  */
3084       if (!VOID_TYPE_P (TREE_TYPE (then_)))
3085         TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
3086
3087       /* Similarly, build the new else clause, `tmp = else_;'.  */
3088       if (!VOID_TYPE_P (TREE_TYPE (else_)))
3089         TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
3090
3091       TREE_TYPE (expr) = void_type_node;
3092       recalculate_side_effects (expr);
3093
3094       /* Move the COND_EXPR to the prequeue.  */
3095       gimplify_stmt (&expr, pre_p);
3096
3097       *expr_p = result;
3098       return GS_ALL_DONE;
3099     }
3100
3101   /* Remove any COMPOUND_EXPR so the following cases will be caught.  */
3102   STRIP_TYPE_NOPS (TREE_OPERAND (expr, 0));
3103   if (TREE_CODE (TREE_OPERAND (expr, 0)) == COMPOUND_EXPR)
3104     gimplify_compound_expr (&TREE_OPERAND (expr, 0), pre_p, true);
3105
3106   /* Make sure the condition has BOOLEAN_TYPE.  */
3107   TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3108
3109   /* Break apart && and || conditions.  */
3110   if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
3111       || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
3112     {
3113       expr = shortcut_cond_expr (expr);
3114
3115       if (expr != *expr_p)
3116         {
3117           *expr_p = expr;
3118
3119           /* We can't rely on gimplify_expr to re-gimplify the expanded
3120              form properly, as cleanups might cause the target labels to be
3121              wrapped in a TRY_FINALLY_EXPR.  To prevent that, we need to
3122              set up a conditional context.  */
3123           gimple_push_condition ();
3124           gimplify_stmt (expr_p, &seq);
3125           gimple_pop_condition (pre_p);
3126           gimple_seq_add_seq (pre_p, seq);
3127
3128           return GS_ALL_DONE;
3129         }
3130     }
3131
3132   /* Now do the normal gimplification.  */
3133
3134   /* Gimplify condition.  */
3135   ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
3136                        fb_rvalue);
3137   if (ret == GS_ERROR)
3138     return GS_ERROR;
3139   gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
3140
3141   gimple_push_condition ();
3142
3143   have_then_clause_p = have_else_clause_p = false;
3144   if (TREE_OPERAND (expr, 1) != NULL
3145       && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
3146       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
3147       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
3148           == current_function_decl)
3149       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3150          have different locations, otherwise we end up with incorrect
3151          location information on the branches.  */
3152       && (optimize
3153           || !EXPR_HAS_LOCATION (expr)
3154           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
3155           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
3156     {
3157       label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
3158       have_then_clause_p = true;
3159     }
3160   else
3161     label_true = create_artificial_label (UNKNOWN_LOCATION);
3162   if (TREE_OPERAND (expr, 2) != NULL
3163       && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
3164       && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3165       && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3166           == current_function_decl)
3167       /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3168          have different locations, otherwise we end up with incorrect
3169          location information on the branches.  */
3170       && (optimize
3171           || !EXPR_HAS_LOCATION (expr)
3172           || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3173           || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3174     {
3175       label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3176       have_else_clause_p = true;
3177     }
3178   else
3179     label_false = create_artificial_label (UNKNOWN_LOCATION);
3180
3181   gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3182                                  &arm2);
3183
3184   gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
3185                                    label_false);
3186
3187   gimplify_seq_add_stmt (&seq, gimple_cond);
3188   label_cont = NULL_TREE;
3189   if (!have_then_clause_p)
3190     {
3191       /* For if (...) {} else { code; } put label_true after
3192          the else block.  */
3193       if (TREE_OPERAND (expr, 1) == NULL_TREE
3194           && !have_else_clause_p
3195           && TREE_OPERAND (expr, 2) != NULL_TREE)
3196         label_cont = label_true;
3197       else
3198         {
3199           gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3200           have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3201           /* For if (...) { code; } else {} or
3202              if (...) { code; } else goto label; or
3203              if (...) { code; return; } else { ... }
3204              label_cont isn't needed.  */
3205           if (!have_else_clause_p
3206               && TREE_OPERAND (expr, 2) != NULL_TREE
3207               && gimple_seq_may_fallthru (seq))
3208             {
3209               gimple g;
3210               label_cont = create_artificial_label (UNKNOWN_LOCATION);
3211
3212               g = gimple_build_goto (label_cont);
3213
3214               /* GIMPLE_COND's are very low level; they have embedded
3215                  gotos.  This particular embedded goto should not be marked
3216                  with the location of the original COND_EXPR, as it would
3217                  correspond to the COND_EXPR's condition, not the ELSE or the
3218                  THEN arms.  To avoid marking it with the wrong location, flag
3219                  it as "no location".  */
3220               gimple_set_do_not_emit_location (g);
3221
3222               gimplify_seq_add_stmt (&seq, g);
3223             }
3224         }
3225     }
3226   if (!have_else_clause_p)
3227     {
3228       gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3229       have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3230     }
3231   if (label_cont)
3232     gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3233
3234   gimple_pop_condition (pre_p);
3235   gimple_seq_add_seq (pre_p, seq);
3236
3237   if (ret == GS_ERROR)
3238     ; /* Do nothing.  */
3239   else if (have_then_clause_p || have_else_clause_p)
3240     ret = GS_ALL_DONE;
3241   else
3242     {
3243       /* Both arms are empty; replace the COND_EXPR with its predicate.  */
3244       expr = TREE_OPERAND (expr, 0);
3245       gimplify_stmt (&expr, pre_p);
3246     }
3247
3248   *expr_p = NULL;
3249   return ret;
3250 }
3251
3252 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3253    to be marked addressable.
3254
3255    We cannot rely on such an expression being directly markable if a temporary
3256    has been created by the gimplification.  In this case, we create another
3257    temporary and initialize it with a copy, which will become a store after we
3258    mark it addressable.  This can happen if the front-end passed us something
3259    that it could not mark addressable yet, like a Fortran pass-by-reference
3260    parameter (int) floatvar.  */
3261
3262 static void
3263 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
3264 {
3265   while (handled_component_p (*expr_p))
3266     expr_p = &TREE_OPERAND (*expr_p, 0);
3267   if (is_gimple_reg (*expr_p))
3268     *expr_p = get_initialized_tmp_var (*expr_p, seq_p, NULL);
3269 }
3270
3271 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3272    a call to __builtin_memcpy.  */
3273
3274 static enum gimplify_status
3275 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3276                                 gimple_seq *seq_p)
3277 {
3278   tree t, to, to_ptr, from, from_ptr;
3279   gimple gs;
3280   location_t loc = EXPR_LOCATION (*expr_p);
3281
3282   to = TREE_OPERAND (*expr_p, 0);
3283   from = TREE_OPERAND (*expr_p, 1);
3284
3285   /* Mark the RHS addressable.  Beware that it may not be possible to do so
3286      directly if a temporary has been created by the gimplification.  */
3287   prepare_gimple_addressable (&from, seq_p);
3288
3289   mark_addressable (from);
3290   from_ptr = build_fold_addr_expr_loc (loc, from);
3291   gimplify_arg (&from_ptr, seq_p, loc);
3292
3293   mark_addressable (to);
3294   to_ptr = build_fold_addr_expr_loc (loc, to);
3295   gimplify_arg (&to_ptr, seq_p, loc);
3296
3297   t = builtin_decl_implicit (BUILT_IN_MEMCPY);
3298
3299   gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3300
3301   if (want_value)
3302     {
3303       /* tmp = memcpy() */
3304       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3305       gimple_call_set_lhs (gs, t);
3306       gimplify_seq_add_stmt (seq_p, gs);
3307
3308       *expr_p = build_simple_mem_ref (t);
3309       return GS_ALL_DONE;
3310     }
3311
3312   gimplify_seq_add_stmt (seq_p, gs);
3313   *expr_p = NULL;
3314   return GS_ALL_DONE;
3315 }
3316
3317 /* A subroutine of gimplify_modify_expr.  Replace a MODIFY_EXPR with
3318    a call to __builtin_memset.  In this case we know that the RHS is
3319    a CONSTRUCTOR with an empty element list.  */
3320
3321 static enum gimplify_status
3322 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3323                                 gimple_seq *seq_p)
3324 {
3325   tree t, from, to, to_ptr;
3326   gimple gs;
3327   location_t loc = EXPR_LOCATION (*expr_p);
3328
3329   /* Assert our assumptions, to abort instead of producing wrong code
3330      silently if they are not met.  Beware that the RHS CONSTRUCTOR might
3331      not be immediately exposed.  */
3332   from = TREE_OPERAND (*expr_p, 1);
3333   if (TREE_CODE (from) == WITH_SIZE_EXPR)
3334     from = TREE_OPERAND (from, 0);
3335
3336   gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3337               && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
3338
3339   /* Now proceed.  */
3340   to = TREE_OPERAND (*expr_p, 0);
3341
3342   to_ptr = build_fold_addr_expr_loc (loc, to);
3343   gimplify_arg (&to_ptr, seq_p, loc);
3344   t = builtin_decl_implicit (BUILT_IN_MEMSET);
3345
3346   gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3347
3348   if (want_value)
3349     {
3350       /* tmp = memset() */
3351       t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3352       gimple_call_set_lhs (gs, t);
3353       gimplify_seq_add_stmt (seq_p, gs);
3354
3355       *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3356       return GS_ALL_DONE;
3357     }
3358
3359   gimplify_seq_add_stmt (seq_p, gs);
3360   *expr_p = NULL;
3361   return GS_ALL_DONE;
3362 }
3363
3364 /* A subroutine of gimplify_init_ctor_preeval.  Called via walk_tree,
3365    determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3366    assignment.  Return non-null if we detect a potential overlap.  */
3367
3368 struct gimplify_init_ctor_preeval_data
3369 {
3370   /* The base decl of the lhs object.  May be NULL, in which case we
3371      have to assume the lhs is indirect.  */
3372   tree lhs_base_decl;
3373
3374   /* The alias set of the lhs object.  */
3375   alias_set_type lhs_alias_set;
3376 };
3377
3378 static tree
3379 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3380 {
3381   struct gimplify_init_ctor_preeval_data *data
3382     = (struct gimplify_init_ctor_preeval_data *) xdata;
3383   tree t = *tp;
3384
3385   /* If we find the base object, obviously we have overlap.  */
3386   if (data->lhs_base_decl == t)
3387     return t;
3388
3389   /* If the constructor component is indirect, determine if we have a
3390      potential overlap with the lhs.  The only bits of information we
3391      have to go on at this point are addressability and alias sets.  */
3392   if ((INDIRECT_REF_P (t)
3393        || TREE_CODE (t) == MEM_REF)
3394       && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3395       && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3396     return t;
3397
3398   /* If the constructor component is a call, determine if it can hide a
3399      potential overlap with the lhs through an INDIRECT_REF like above.
3400      ??? Ugh - this is completely broken.  In fact this whole analysis
3401      doesn't look conservative.  */
3402   if (TREE_CODE (t) == CALL_EXPR)
3403     {
3404       tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3405
3406       for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3407         if (POINTER_TYPE_P (TREE_VALUE (type))
3408             && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3409             && alias_sets_conflict_p (data->lhs_alias_set,
3410                                       get_alias_set
3411                                         (TREE_TYPE (TREE_VALUE (type)))))
3412           return t;
3413     }
3414
3415   if (IS_TYPE_OR_DECL_P (t))
3416     *walk_subtrees = 0;
3417   return NULL;
3418 }
3419
3420 /* A subroutine of gimplify_init_constructor.  Pre-evaluate EXPR,
3421    force values that overlap with the lhs (as described by *DATA)
3422    into temporaries.  */
3423
3424 static void
3425 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3426                             struct gimplify_init_ctor_preeval_data *data)
3427 {
3428   enum gimplify_status one;
3429
3430   /* If the value is constant, then there's nothing to pre-evaluate.  */
3431   if (TREE_CONSTANT (*expr_p))
3432     {
3433       /* Ensure it does not have side effects, it might contain a reference to
3434          the object we're initializing.  */
3435       gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3436       return;
3437     }
3438
3439   /* If the type has non-trivial constructors, we can't pre-evaluate.  */
3440   if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3441     return;
3442
3443   /* Recurse for nested constructors.  */
3444   if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3445     {
3446       unsigned HOST_WIDE_INT ix;
3447       constructor_elt *ce;
3448       VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
3449
3450       FOR_EACH_VEC_ELT (constructor_elt, v, ix, ce)
3451         gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3452
3453       return;
3454     }
3455
3456   /* If this is a variable sized type, we must remember the size.  */
3457   maybe_with_size_expr (expr_p);
3458
3459   /* Gimplify the constructor element to something appropriate for the rhs
3460      of a MODIFY_EXPR.  Given that we know the LHS is an aggregate, we know
3461      the gimplifier will consider this a store to memory.  Doing this
3462      gimplification now means that we won't have to deal with complicated
3463      language-specific trees, nor trees like SAVE_EXPR that can induce
3464      exponential search behavior.  */
3465   one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3466   if (one == GS_ERROR)
3467     {
3468       *expr_p = NULL;
3469       return;
3470     }
3471
3472   /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3473      with the lhs, since "a = { .x=a }" doesn't make sense.  This will
3474      always be true for all scalars, since is_gimple_mem_rhs insists on a
3475      temporary variable for them.  */
3476   if (DECL_P (*expr_p))
3477     return;
3478
3479   /* If this is of variable size, we have no choice but to assume it doesn't
3480      overlap since we can't make a temporary for it.  */
3481   if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3482     return;
3483
3484   /* Otherwise, we must search for overlap ...  */
3485   if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3486     return;
3487
3488   /* ... and if found, force the value into a temporary.  */
3489   *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3490 }
3491
3492 /* A subroutine of gimplify_init_ctor_eval.  Create a loop for
3493    a RANGE_EXPR in a CONSTRUCTOR for an array.
3494
3495       var = lower;
3496     loop_entry:
3497       object[var] = value;
3498       if (var == upper)
3499         goto loop_exit;
3500       var = var + 1;
3501       goto loop_entry;
3502     loop_exit:
3503
3504    We increment var _after_ the loop exit check because we might otherwise
3505    fail if upper == TYPE_MAX_VALUE (type for upper).
3506
3507    Note that we never have to deal with SAVE_EXPRs here, because this has
3508    already been taken care of for us, in gimplify_init_ctor_preeval().  */
3509
3510 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
3511                                      gimple_seq *, bool);
3512
3513 static void
3514 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3515                                tree value, tree array_elt_type,
3516                                gimple_seq *pre_p, bool cleared)
3517 {
3518   tree loop_entry_label, loop_exit_label, fall_thru_label;
3519   tree var, var_type, cref, tmp;
3520
3521   loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
3522   loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
3523   fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
3524
3525   /* Create and initialize the index variable.  */
3526   var_type = TREE_TYPE (upper);
3527   var = create_tmp_var (var_type, NULL);
3528   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3529
3530   /* Add the loop entry label.  */
3531   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3532
3533   /* Build the reference.  */
3534   cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3535                  var, NULL_TREE, NULL_TREE);
3536
3537   /* If we are a constructor, just call gimplify_init_ctor_eval to do
3538      the store.  Otherwise just assign value to the reference.  */
3539
3540   if (TREE_CODE (value) == CONSTRUCTOR)
3541     /* NB we might have to call ourself recursively through
3542        gimplify_init_ctor_eval if the value is a constructor.  */
3543     gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3544                              pre_p, cleared);
3545   else
3546     gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3547
3548   /* We exit the loop when the index var is equal to the upper bound.  */
3549   gimplify_seq_add_stmt (pre_p,
3550                          gimple_build_cond (EQ_EXPR, var, upper,
3551                                             loop_exit_label, fall_thru_label));
3552
3553   gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3554
3555   /* Otherwise, increment the index var...  */
3556   tmp = build2 (PLUS_EXPR, var_type, var,
3557                 fold_convert (var_type, integer_one_node));
3558   gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3559
3560   /* ...and jump back to the loop entry.  */
3561   gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3562
3563   /* Add the loop exit label.  */
3564   gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3565 }
3566
3567 /* Return true if FDECL is accessing a field that is zero sized.  */
3568
3569 static bool
3570 zero_sized_field_decl (const_tree fdecl)
3571 {
3572   if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3573       && integer_zerop (DECL_SIZE (fdecl)))
3574     return true;
3575   return false;
3576 }
3577
3578 /* Return true if TYPE is zero sized.  */
3579
3580 static bool
3581 zero_sized_type (const_tree type)
3582 {
3583   if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3584       && integer_zerop (TYPE_SIZE (type)))
3585     return true;
3586   return false;
3587 }
3588
3589 /* A subroutine of gimplify_init_constructor.  Generate individual
3590    MODIFY_EXPRs for a CONSTRUCTOR.  OBJECT is the LHS against which the
3591    assignments should happen.  ELTS is the CONSTRUCTOR_ELTS of the
3592    CONSTRUCTOR.  CLEARED is true if the entire LHS object has been
3593    zeroed first.  */
3594
3595 static void
3596 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3597                          gimple_seq *pre_p, bool cleared)
3598 {
3599   tree array_elt_type = NULL;
3600   unsigned HOST_WIDE_INT ix;
3601   tree purpose, value;
3602
3603   if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3604     array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3605
3606   FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3607     {
3608       tree cref;
3609
3610       /* NULL values are created above for gimplification errors.  */
3611       if (value == NULL)
3612         continue;
3613
3614       if (cleared && initializer_zerop (value))
3615         continue;
3616
3617       /* ??? Here's to hoping the front end fills in all of the indices,
3618          so we don't have to figure out what's missing ourselves.  */
3619       gcc_assert (purpose);
3620
3621       /* Skip zero-sized fields, unless value has side-effects.  This can
3622          happen with calls to functions returning a zero-sized type, which
3623          we shouldn't discard.  As a number of downstream passes don't
3624          expect sets of zero-sized fields, we rely on the gimplification of
3625          the MODIFY_EXPR we make below to drop the assignment statement.  */
3626       if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3627         continue;
3628
3629       /* If we have a RANGE_EXPR, we have to build a loop to assign the
3630          whole range.  */
3631       if (TREE_CODE (purpose) == RANGE_EXPR)
3632         {
3633           tree lower = TREE_OPERAND (purpose, 0);
3634           tree upper = TREE_OPERAND (purpose, 1);
3635
3636           /* If the lower bound is equal to upper, just treat it as if
3637              upper was the index.  */
3638           if (simple_cst_equal (lower, upper))
3639             purpose = upper;
3640           else
3641             {
3642               gimplify_init_ctor_eval_range (object, lower, upper, value,
3643                                              array_elt_type, pre_p, cleared);
3644               continue;
3645             }
3646         }
3647
3648       if (array_elt_type)
3649         {
3650           /* Do not use bitsizetype for ARRAY_REF indices.  */
3651           if (TYPE_DOMAIN (TREE_TYPE (object)))
3652             purpose
3653               = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3654                               purpose);
3655           cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3656                          purpose, NULL_TREE, NULL_TREE);
3657         }
3658       else
3659         {
3660           gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3661           cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3662                          unshare_expr (object), purpose, NULL_TREE);
3663         }
3664
3665       if (TREE_CODE (value) == CONSTRUCTOR
3666           && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3667         gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3668                                  pre_p, cleared);
3669       else
3670         {
3671           tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3672           gimplify_and_add (init, pre_p);
3673           ggc_free (init);
3674         }
3675     }
3676 }
3677
3678 /* Return the appropriate RHS predicate for this LHS.  */
3679
3680 gimple_predicate
3681 rhs_predicate_for (tree lhs)
3682 {
3683   if (is_gimple_reg (lhs))
3684     return is_gimple_reg_rhs_or_call;
3685   else
3686     return is_gimple_mem_rhs_or_call;
3687 }
3688
3689 /* Gimplify a C99 compound literal expression.  This just means adding
3690    the DECL_EXPR before the current statement and using its anonymous
3691    decl instead.  */
3692
3693 static enum gimplify_status
3694 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p)
3695 {
3696   tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
3697   tree decl = DECL_EXPR_DECL (decl_s);
3698   /* Mark the decl as addressable if the compound literal
3699      expression is addressable now, otherwise it is marked too late
3700      after we gimplify the initialization expression.  */
3701   if (TREE_ADDRESSABLE (*expr_p))
3702     TREE_ADDRESSABLE (decl) = 1;
3703
3704   /* Preliminarily mark non-addressed complex variables as eligible
3705      for promotion to gimple registers.  We'll transform their uses
3706      as we find them.  */
3707   if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
3708        || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
3709       && !TREE_THIS_VOLATILE (decl)
3710       && !needs_to_live_in_memory (decl))
3711     DECL_GIMPLE_REG_P (decl) = 1;
3712
3713   /* This decl isn't mentioned in the enclosing block, so add it to the
3714      list of temps.  FIXME it seems a bit of a kludge to say that
3715      anonymous artificial vars aren't pushed, but everything else is.  */
3716   if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
3717     gimple_add_tmp_var (decl);
3718
3719   gimplify_and_add (decl_s, pre_p);
3720   *expr_p = decl;
3721   return GS_OK;
3722 }
3723
3724 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3725    return a new CONSTRUCTOR if something changed.  */
3726
3727 static tree
3728 optimize_compound_literals_in_ctor (tree orig_ctor)
3729 {
3730   tree ctor = orig_ctor;
3731   VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
3732   unsigned int idx, num = VEC_length (constructor_elt, elts);
3733
3734   for (idx = 0; idx < num; idx++)
3735     {
3736       tree value = VEC_index (constructor_elt, elts, idx)->value;
3737       tree newval = value;
3738       if (TREE_CODE (value) == CONSTRUCTOR)
3739         newval = optimize_compound_literals_in_ctor (value);
3740       else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
3741         {
3742           tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
3743           tree decl = DECL_EXPR_DECL (decl_s);
3744           tree init = DECL_INITIAL (decl);
3745
3746           if (!TREE_ADDRESSABLE (value)
3747               && !TREE_ADDRESSABLE (decl)
3748               && init
3749               && TREE_CODE (init) == CONSTRUCTOR)
3750             newval = optimize_compound_literals_in_ctor (init);
3751         }
3752       if (newval == value)
3753         continue;
3754
3755       if (ctor == orig_ctor)
3756         {
3757           ctor = copy_node (orig_ctor);
3758           CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
3759           elts = CONSTRUCTOR_ELTS (ctor);
3760         }
3761       VEC_index (constructor_elt, elts, idx)->value = newval;
3762     }
3763   return ctor;
3764 }
3765
3766 /* A subroutine of gimplify_modify_expr.  Break out elements of a
3767    CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3768
3769    Note that we still need to clear any elements that don't have explicit
3770    initializers, so if not all elements are initialized we keep the
3771    original MODIFY_EXPR, we just remove all of the constructor elements.
3772
3773    If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3774    GS_ERROR if we would have to create a temporary when gimplifying
3775    this constructor.  Otherwise, return GS_OK.
3776
3777    If NOTIFY_TEMP_CREATION is false, just do the gimplification.  */
3778
3779 static enum gimplify_status
3780 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3781                            bool want_value, bool notify_temp_creation)
3782 {
3783   tree object, ctor, type;
3784   enum gimplify_status ret;
3785   VEC(constructor_elt,gc) *elts;
3786
3787   gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
3788
3789   if (!notify_temp_creation)
3790     {
3791       ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3792                            is_gimple_lvalue, fb_lvalue);
3793       if (ret == GS_ERROR)
3794         return ret;
3795     }
3796
3797   object = TREE_OPERAND (*expr_p, 0);
3798   ctor = TREE_OPERAND (*expr_p, 1) =
3799     optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
3800   type = TREE_TYPE (ctor);
3801   elts = CONSTRUCTOR_ELTS (ctor);
3802   ret = GS_ALL_DONE;
3803
3804   switch (TREE_CODE (type))
3805     {
3806     case RECORD_TYPE:
3807     case UNION_TYPE:
3808     case QUAL_UNION_TYPE:
3809     case ARRAY_TYPE:
3810       {
3811         struct gimplify_init_ctor_preeval_data preeval_data;
3812         HOST_WIDE_INT num_ctor_elements, num_nonzero_elements;
3813         bool cleared, complete_p, valid_const_initializer;
3814
3815         /* Aggregate types must lower constructors to initialization of
3816            individual elements.  The exception is that a CONSTRUCTOR node
3817            with no elements indicates zero-initialization of the whole.  */
3818         if (VEC_empty (constructor_elt, elts))
3819           {
3820             if (notify_temp_creation)
3821               return GS_OK;
3822             break;
3823           }
3824
3825         /* Fetch information about the constructor to direct later processing.
3826            We might want to make static versions of it in various cases, and
3827            can only do so if it known to be a valid constant initializer.  */
3828         valid_const_initializer
3829           = categorize_ctor_elements (ctor, &num_nonzero_elements,
3830                                       &num_ctor_elements, &complete_p);
3831
3832         /* If a const aggregate variable is being initialized, then it
3833            should never be a lose to promote the variable to be static.  */
3834         if (valid_const_initializer
3835             && num_nonzero_elements > 1
3836             && TREE_READONLY (object)
3837             && TREE_CODE (object) == VAR_DECL
3838             && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
3839           {
3840             if (notify_temp_creation)
3841               return GS_ERROR;
3842             DECL_INITIAL (object) = ctor;
3843             TREE_STATIC (object) = 1;
3844             if (!DECL_NAME (object))
3845               DECL_NAME (object) = create_tmp_var_name ("C");
3846             walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
3847
3848             /* ??? C++ doesn't automatically append a .<number> to the
3849                assembler name, and even when it does, it looks a FE private
3850                data structures to figure out what that number should be,
3851                which are not set for this variable.  I suppose this is
3852                important for local statics for inline functions, which aren't
3853                "local" in the object file sense.  So in order to get a unique
3854                TU-local symbol, we must invoke the lhd version now.  */
3855             lhd_set_decl_assembler_name (object);
3856
3857             *expr_p = NULL_TREE;
3858             break;
3859           }
3860
3861         /* If there are "lots" of initialized elements, even discounting
3862            those that are not address constants (and thus *must* be
3863            computed at runtime), then partition the constructor into
3864            constant and non-constant parts.  Block copy the constant
3865            parts in, then generate code for the non-constant parts.  */
3866         /* TODO.  There's code in cp/typeck.c to do this.  */
3867
3868         if (int_size_in_bytes (TREE_TYPE (ctor)) < 0)
3869           /* store_constructor will ignore the clearing of variable-sized
3870              objects.  Initializers for such objects must explicitly set
3871              every field that needs to be set.  */
3872           cleared = false;
3873         else if (!complete_p)
3874           /* If the constructor isn't complete, clear the whole object
3875              beforehand.
3876
3877              ??? This ought not to be needed.  For any element not present
3878              in the initializer, we should simply set them to zero.  Except
3879              we'd need to *find* the elements that are not present, and that
3880              requires trickery to avoid quadratic compile-time behavior in
3881              large cases or excessive memory use in small cases.  */
3882           cleared = true;
3883         else if (num_ctor_elements - num_nonzero_elements
3884                  > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
3885                  && num_nonzero_elements < num_ctor_elements / 4)
3886           /* If there are "lots" of zeros, it's more efficient to clear
3887              the memory and then set the nonzero elements.  */
3888           cleared = true;
3889         else
3890           cleared = false;
3891
3892         /* If there are "lots" of initialized elements, and all of them
3893            are valid address constants, then the entire initializer can
3894            be dropped to memory, and then memcpy'd out.  Don't do this
3895            for sparse arrays, though, as it's more efficient to follow
3896            the standard CONSTRUCTOR behavior of memset followed by
3897            individual element initialization.  Also don't do this for small
3898            all-zero initializers (which aren't big enough to merit
3899            clearing), and don't try to make bitwise copies of
3900            TREE_ADDRESSABLE types.  */
3901         if (valid_const_initializer
3902             && !(cleared || num_nonzero_elements == 0)
3903             && !TREE_ADDRESSABLE (type))
3904           {
3905             HOST_WIDE_INT size = int_size_in_bytes (type);
3906             unsigned int align;
3907
3908             /* ??? We can still get unbounded array types, at least
3909                from the C++ front end.  This seems wrong, but attempt
3910                to work around it for now.  */
3911             if (size < 0)
3912               {
3913                 size = int_size_in_bytes (TREE_TYPE (object));
3914                 if (size >= 0)
3915                   TREE_TYPE (ctor) = type = TREE_TYPE (object);
3916               }
3917
3918             /* Find the maximum alignment we can assume for the object.  */
3919             /* ??? Make use of DECL_OFFSET_ALIGN.  */
3920             if (DECL_P (object))
3921               align = DECL_ALIGN (object);
3922             else
3923               align = TYPE_ALIGN (type);
3924
3925             if (size > 0
3926                 && num_nonzero_elements > 1
3927                 && !can_move_by_pieces (size, align))
3928               {
3929                 if (notify_temp_creation)
3930                   return GS_ERROR;
3931
3932                 walk_tree (&ctor, force_labels_r, NULL, NULL);
3933                 ctor = tree_output_constant_def (ctor);
3934                 if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
3935                   ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
3936                 TREE_OPERAND (*expr_p, 1) = ctor;
3937
3938                 /* This is no longer an assignment of a CONSTRUCTOR, but
3939                    we still may have processing to do on the LHS.  So
3940                    pretend we didn't do anything here to let that happen.  */
3941                 return GS_UNHANDLED;
3942               }
3943           }
3944
3945         /* If the target is volatile, we have non-zero elements and more than
3946            one field to assign, initialize the target from a temporary.  */
3947         if (TREE_THIS_VOLATILE (object)
3948             && !TREE_ADDRESSABLE (type)
3949             && num_nonzero_elements > 0
3950             && VEC_length (constructor_elt, elts) > 1)
3951           {
3952             tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type), NULL);
3953             TREE_OPERAND (*expr_p, 0) = temp;
3954             *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
3955                               *expr_p,
3956                               build2 (MODIFY_EXPR, void_type_node,
3957                                       object, temp));
3958             return GS_OK;
3959           }
3960
3961         if (notify_temp_creation)
3962           return GS_OK;
3963
3964         /* If there are nonzero elements and if needed, pre-evaluate to capture
3965            elements overlapping with the lhs into temporaries.  We must do this
3966            before clearing to fetch the values before they are zeroed-out.  */
3967         if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
3968           {
3969             preeval_data.lhs_base_decl = get_base_address (object);
3970             if (!DECL_P (preeval_data.lhs_base_decl))
3971               preeval_data.lhs_base_decl = NULL;
3972             preeval_data.lhs_alias_set = get_alias_set (object);
3973
3974             gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
3975                                         pre_p, post_p, &preeval_data);
3976           }
3977
3978         if (cleared)
3979           {
3980             /* Zap the CONSTRUCTOR element list, which simplifies this case.
3981                Note that we still have to gimplify, in order to handle the
3982                case of variable sized types.  Avoid shared tree structures.  */
3983             CONSTRUCTOR_ELTS (ctor) = NULL;
3984             TREE_SIDE_EFFECTS (ctor) = 0;
3985             object = unshare_expr (object);
3986             gimplify_stmt (expr_p, pre_p);
3987           }
3988
3989         /* If we have not block cleared the object, or if there are nonzero
3990            elements in the constructor, add assignments to the individual
3991            scalar fields of the object.  */
3992         if (!cleared || num_nonzero_elements > 0)
3993           gimplify_init_ctor_eval (object, elts, pre_p, cleared);
3994
3995         *expr_p = NULL_TREE;
3996       }
3997       break;
3998
3999     case COMPLEX_TYPE:
4000       {
4001         tree r, i;
4002
4003         if (notify_temp_creation)
4004           return GS_OK;
4005
4006         /* Extract the real and imaginary parts out of the ctor.  */
4007         gcc_assert (VEC_length (constructor_elt, elts) == 2);
4008         r = VEC_index (constructor_elt, elts, 0)->value;
4009         i = VEC_index (constructor_elt, elts, 1)->value;
4010         if (r == NULL || i == NULL)
4011           {
4012             tree zero = build_zero_cst (TREE_TYPE (type));
4013             if (r == NULL)
4014               r = zero;
4015             if (i == NULL)
4016               i = zero;
4017           }
4018
4019         /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4020            represent creation of a complex value.  */
4021         if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
4022           {
4023             ctor = build_complex (type, r, i);
4024             TREE_OPERAND (*expr_p, 1) = ctor;
4025           }
4026         else
4027           {
4028             ctor = build2 (COMPLEX_EXPR, type, r, i);
4029             TREE_OPERAND (*expr_p, 1) = ctor;
4030             ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
4031                                  pre_p,
4032                                  post_p,
4033                                  rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
4034                                  fb_rvalue);
4035           }
4036       }
4037       break;
4038
4039     case VECTOR_TYPE:
4040       {
4041         unsigned HOST_WIDE_INT ix;
4042         constructor_elt *ce;
4043
4044         if (notify_temp_creation)
4045           return GS_OK;
4046
4047         /* Go ahead and simplify constant constructors to VECTOR_CST.  */
4048         if (TREE_CONSTANT (ctor))
4049           {
4050             bool constant_p = true;
4051             tree value;
4052
4053             /* Even when ctor is constant, it might contain non-*_CST
4054                elements, such as addresses or trapping values like
4055                1.0/0.0 - 1.0/0.0.  Such expressions don't belong
4056                in VECTOR_CST nodes.  */
4057             FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
4058               if (!CONSTANT_CLASS_P (value))
4059                 {
4060                   constant_p = false;
4061                   break;
4062                 }
4063
4064             if (constant_p)
4065               {
4066                 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
4067                 break;
4068               }
4069
4070             /* Don't reduce an initializer constant even if we can't
4071                make a VECTOR_CST.  It won't do anything for us, and it'll
4072                prevent us from representing it as a single constant.  */
4073             if (initializer_constant_valid_p (ctor, type))
4074               break;
4075
4076             TREE_CONSTANT (ctor) = 0;
4077           }
4078
4079         /* Vector types use CONSTRUCTOR all the way through gimple
4080           compilation as a general initializer.  */
4081         FOR_EACH_VEC_ELT (constructor_elt, elts, ix, ce)
4082           {
4083             enum gimplify_status tret;
4084             tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
4085                                   fb_rvalue);
4086             if (tret == GS_ERROR)
4087               ret = GS_ERROR;
4088           }
4089         if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
4090           TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
4091       }
4092       break;
4093
4094     default:
4095       /* So how did we get a CONSTRUCTOR for a scalar type?  */
4096       gcc_unreachable ();
4097     }
4098
4099   if (ret == GS_ERROR)
4100     return GS_ERROR;
4101   else if (want_value)
4102     {
4103       *expr_p = object;
4104       return GS_OK;
4105     }
4106   else
4107     {
4108       /* If we have gimplified both sides of the initializer but have
4109          not emitted an assignment, do so now.  */
4110       if (*expr_p)
4111         {
4112           tree lhs = TREE_OPERAND (*expr_p, 0);
4113           tree rhs = TREE_OPERAND (*expr_p, 1);
4114           gimple init = gimple_build_assign (lhs, rhs);
4115           gimplify_seq_add_stmt (pre_p, init);
4116           *expr_p = NULL;
4117         }
4118
4119       return GS_ALL_DONE;
4120     }
4121 }
4122
4123 /* Given a pointer value OP0, return a simplified version of an
4124    indirection through OP0, or NULL_TREE if no simplification is
4125    possible.  Note that the resulting type may be different from
4126    the type pointed to in the sense that it is still compatible
4127    from the langhooks point of view. */
4128
4129 tree
4130 gimple_fold_indirect_ref (tree t)
4131 {
4132   tree ptype = TREE_TYPE (t), type = TREE_TYPE (ptype);
4133   tree sub = t;
4134   tree subtype;
4135
4136   STRIP_NOPS (sub);
4137   subtype = TREE_TYPE (sub);
4138   if (!POINTER_TYPE_P (subtype))
4139     return NULL_TREE;
4140
4141   if (TREE_CODE (sub) == ADDR_EXPR)
4142     {
4143       tree op = TREE_OPERAND (sub, 0);
4144       tree optype = TREE_TYPE (op);
4145       /* *&p => p */
4146       if (useless_type_conversion_p (type, optype))
4147         return op;
4148
4149       /* *(foo *)&fooarray => fooarray[0] */
4150       if (TREE_CODE (optype) == ARRAY_TYPE
4151           && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype))) == INTEGER_CST
4152           && useless_type_conversion_p (type, TREE_TYPE (optype)))
4153        {
4154          tree type_domain = TYPE_DOMAIN (optype);
4155          tree min_val = size_zero_node;
4156          if (type_domain && TYPE_MIN_VALUE (type_domain))
4157            min_val = TYPE_MIN_VALUE (type_domain);