re PR preprocessor/36674 (#include location is offset by one row in errors from prepr...
[gcc.git] / gcc / gimplify.c
1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
5 Major work done by Sebastian Pop <s.pop@laposte.net>,
6 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
13 version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "tree.h"
29 #include "rtl.h"
30 #include "varray.h"
31 #include "gimple.h"
32 #include "tree-iterator.h"
33 #include "tree-inline.h"
34 #include "diagnostic.h"
35 #include "langhooks.h"
36 #include "langhooks-def.h"
37 #include "tree-flow.h"
38 #include "cgraph.h"
39 #include "timevar.h"
40 #include "except.h"
41 #include "hashtab.h"
42 #include "flags.h"
43 #include "real.h"
44 #include "function.h"
45 #include "output.h"
46 #include "expr.h"
47 #include "ggc.h"
48 #include "toplev.h"
49 #include "target.h"
50 #include "optabs.h"
51 #include "pointer-set.h"
52 #include "splay-tree.h"
53 #include "vec.h"
54 #include "gimple.h"
55
56
57 enum gimplify_omp_var_data
58 {
59 GOVD_SEEN = 1,
60 GOVD_EXPLICIT = 2,
61 GOVD_SHARED = 4,
62 GOVD_PRIVATE = 8,
63 GOVD_FIRSTPRIVATE = 16,
64 GOVD_LASTPRIVATE = 32,
65 GOVD_REDUCTION = 64,
66 GOVD_LOCAL = 128,
67 GOVD_DEBUG_PRIVATE = 256,
68 GOVD_PRIVATE_OUTER_REF = 512,
69 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
70 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
71 };
72
73
74 enum omp_region_type
75 {
76 ORT_WORKSHARE = 0,
77 ORT_TASK = 1,
78 ORT_PARALLEL = 2,
79 ORT_COMBINED_PARALLEL = 3
80 };
81
82 struct gimplify_omp_ctx
83 {
84 struct gimplify_omp_ctx *outer_context;
85 splay_tree variables;
86 struct pointer_set_t *privatized_types;
87 location_t location;
88 enum omp_clause_default_kind default_kind;
89 enum omp_region_type region_type;
90 };
91
92 static struct gimplify_ctx *gimplify_ctxp;
93 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
94
95
96 /* Formal (expression) temporary table handling: Multiple occurrences of
97 the same scalar expression are evaluated into the same temporary. */
98
99 typedef struct gimple_temp_hash_elt
100 {
101 tree val; /* Key */
102 tree temp; /* Value */
103 } elt_t;
104
105 /* Forward declarations. */
106 static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
107
108 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
109 form and we don't do any syntax checking. */
110 void
111 mark_addressable (tree x)
112 {
113 while (handled_component_p (x))
114 x = TREE_OPERAND (x, 0);
115 if (TREE_CODE (x) != VAR_DECL
116 && TREE_CODE (x) != PARM_DECL
117 && TREE_CODE (x) != RESULT_DECL)
118 return ;
119 TREE_ADDRESSABLE (x) = 1;
120 }
121
122 /* Return a hash value for a formal temporary table entry. */
123
124 static hashval_t
125 gimple_tree_hash (const void *p)
126 {
127 tree t = ((const elt_t *) p)->val;
128 return iterative_hash_expr (t, 0);
129 }
130
131 /* Compare two formal temporary table entries. */
132
133 static int
134 gimple_tree_eq (const void *p1, const void *p2)
135 {
136 tree t1 = ((const elt_t *) p1)->val;
137 tree t2 = ((const elt_t *) p2)->val;
138 enum tree_code code = TREE_CODE (t1);
139
140 if (TREE_CODE (t2) != code
141 || TREE_TYPE (t1) != TREE_TYPE (t2))
142 return 0;
143
144 if (!operand_equal_p (t1, t2, 0))
145 return 0;
146
147 /* Only allow them to compare equal if they also hash equal; otherwise
148 results are nondeterminate, and we fail bootstrap comparison. */
149 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
150
151 return 1;
152 }
153
154 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
155 *SEQ_P is NULL, a new sequence is allocated. This function is
156 similar to gimple_seq_add_stmt, but does not scan the operands.
157 During gimplification, we need to manipulate statement sequences
158 before the def/use vectors have been constructed. */
159
160 static void
161 gimplify_seq_add_stmt (gimple_seq *seq_p, gimple gs)
162 {
163 gimple_stmt_iterator si;
164
165 if (gs == NULL)
166 return;
167
168 if (*seq_p == NULL)
169 *seq_p = gimple_seq_alloc ();
170
171 si = gsi_last (*seq_p);
172
173 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
174 }
175
176 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
177 NULL, a new sequence is allocated. This function is
178 similar to gimple_seq_add_seq, but does not scan the operands.
179 During gimplification, we need to manipulate statement sequences
180 before the def/use vectors have been constructed. */
181
182 static void
183 gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
184 {
185 gimple_stmt_iterator si;
186
187 if (src == NULL)
188 return;
189
190 if (*dst_p == NULL)
191 *dst_p = gimple_seq_alloc ();
192
193 si = gsi_last (*dst_p);
194 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
195 }
196
197 /* Set up a context for the gimplifier. */
198
199 void
200 push_gimplify_context (struct gimplify_ctx *c)
201 {
202 memset (c, '\0', sizeof (*c));
203 c->prev_context = gimplify_ctxp;
204 gimplify_ctxp = c;
205 }
206
207 /* Tear down a context for the gimplifier. If BODY is non-null, then
208 put the temporaries into the outer BIND_EXPR. Otherwise, put them
209 in the local_decls.
210
211 BODY is not a sequence, but the first tuple in a sequence. */
212
213 void
214 pop_gimplify_context (gimple body)
215 {
216 struct gimplify_ctx *c = gimplify_ctxp;
217
218 gcc_assert (c && (c->bind_expr_stack == NULL
219 || VEC_empty (gimple, c->bind_expr_stack)));
220 VEC_free (gimple, heap, c->bind_expr_stack);
221 gimplify_ctxp = c->prev_context;
222
223 if (body)
224 declare_vars (c->temps, body, false);
225 else
226 record_vars (c->temps);
227
228 if (c->temp_htab)
229 htab_delete (c->temp_htab);
230 }
231
232 static void
233 gimple_push_bind_expr (gimple gimple_bind)
234 {
235 if (gimplify_ctxp->bind_expr_stack == NULL)
236 gimplify_ctxp->bind_expr_stack = VEC_alloc (gimple, heap, 8);
237 VEC_safe_push (gimple, heap, gimplify_ctxp->bind_expr_stack, gimple_bind);
238 }
239
240 static void
241 gimple_pop_bind_expr (void)
242 {
243 VEC_pop (gimple, gimplify_ctxp->bind_expr_stack);
244 }
245
246 gimple
247 gimple_current_bind_expr (void)
248 {
249 return VEC_last (gimple, gimplify_ctxp->bind_expr_stack);
250 }
251
252 /* Return the stack GIMPLE_BINDs created during gimplification. */
253
254 VEC(gimple, heap) *
255 gimple_bind_expr_stack (void)
256 {
257 return gimplify_ctxp->bind_expr_stack;
258 }
259
260 /* Returns true iff there is a COND_EXPR between us and the innermost
261 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
262
263 static bool
264 gimple_conditional_context (void)
265 {
266 return gimplify_ctxp->conditions > 0;
267 }
268
269 /* Note that we've entered a COND_EXPR. */
270
271 static void
272 gimple_push_condition (void)
273 {
274 #ifdef ENABLE_GIMPLE_CHECKING
275 if (gimplify_ctxp->conditions == 0)
276 gcc_assert (gimple_seq_empty_p (gimplify_ctxp->conditional_cleanups));
277 #endif
278 ++(gimplify_ctxp->conditions);
279 }
280
281 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
282 now, add any conditional cleanups we've seen to the prequeue. */
283
284 static void
285 gimple_pop_condition (gimple_seq *pre_p)
286 {
287 int conds = --(gimplify_ctxp->conditions);
288
289 gcc_assert (conds >= 0);
290 if (conds == 0)
291 {
292 gimplify_seq_add_seq (pre_p, gimplify_ctxp->conditional_cleanups);
293 gimplify_ctxp->conditional_cleanups = NULL;
294 }
295 }
296
297 /* A stable comparison routine for use with splay trees and DECLs. */
298
299 static int
300 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
301 {
302 tree a = (tree) xa;
303 tree b = (tree) xb;
304
305 return DECL_UID (a) - DECL_UID (b);
306 }
307
308 /* Create a new omp construct that deals with variable remapping. */
309
310 static struct gimplify_omp_ctx *
311 new_omp_context (enum omp_region_type region_type)
312 {
313 struct gimplify_omp_ctx *c;
314
315 c = XCNEW (struct gimplify_omp_ctx);
316 c->outer_context = gimplify_omp_ctxp;
317 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
318 c->privatized_types = pointer_set_create ();
319 c->location = input_location;
320 c->region_type = region_type;
321 if (region_type != ORT_TASK)
322 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
323 else
324 c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
325
326 return c;
327 }
328
329 /* Destroy an omp construct that deals with variable remapping. */
330
331 static void
332 delete_omp_context (struct gimplify_omp_ctx *c)
333 {
334 splay_tree_delete (c->variables);
335 pointer_set_destroy (c->privatized_types);
336 XDELETE (c);
337 }
338
339 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
340 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
341
342 /* A subroutine of append_to_statement_list{,_force}. T is not NULL. */
343
344 static void
345 append_to_statement_list_1 (tree t, tree *list_p)
346 {
347 tree list = *list_p;
348 tree_stmt_iterator i;
349
350 if (!list)
351 {
352 if (t && TREE_CODE (t) == STATEMENT_LIST)
353 {
354 *list_p = t;
355 return;
356 }
357 *list_p = list = alloc_stmt_list ();
358 }
359
360 i = tsi_last (list);
361 tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
362 }
363
364 /* Add T to the end of the list container pointed to by LIST_P.
365 If T is an expression with no effects, it is ignored. */
366
367 void
368 append_to_statement_list (tree t, tree *list_p)
369 {
370 if (t && TREE_SIDE_EFFECTS (t))
371 append_to_statement_list_1 (t, list_p);
372 }
373
374 /* Similar, but the statement is always added, regardless of side effects. */
375
376 void
377 append_to_statement_list_force (tree t, tree *list_p)
378 {
379 if (t != NULL_TREE)
380 append_to_statement_list_1 (t, list_p);
381 }
382
383 /* Both gimplify the statement T and append it to *SEQ_P. This function
384 behaves exactly as gimplify_stmt, but you don't have to pass T as a
385 reference. */
386
387 void
388 gimplify_and_add (tree t, gimple_seq *seq_p)
389 {
390 gimplify_stmt (&t, seq_p);
391 }
392
393 /* Gimplify statement T into sequence *SEQ_P, and return the first
394 tuple in the sequence of generated tuples for this statement.
395 Return NULL if gimplifying T produced no tuples. */
396
397 static gimple
398 gimplify_and_return_first (tree t, gimple_seq *seq_p)
399 {
400 gimple_stmt_iterator last = gsi_last (*seq_p);
401
402 gimplify_and_add (t, seq_p);
403
404 if (!gsi_end_p (last))
405 {
406 gsi_next (&last);
407 return gsi_stmt (last);
408 }
409 else
410 return gimple_seq_first_stmt (*seq_p);
411 }
412
413 /* Strip off a legitimate source ending from the input string NAME of
414 length LEN. Rather than having to know the names used by all of
415 our front ends, we strip off an ending of a period followed by
416 up to five characters. (Java uses ".class".) */
417
418 static inline void
419 remove_suffix (char *name, int len)
420 {
421 int i;
422
423 for (i = 2; i < 8 && len > i; i++)
424 {
425 if (name[len - i] == '.')
426 {
427 name[len - i] = '\0';
428 break;
429 }
430 }
431 }
432
433 /* Subroutine for find_single_pointer_decl. */
434
435 static tree
436 find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
437 void *data)
438 {
439 tree *pdecl = (tree *) data;
440
441 /* We are only looking for pointers at the same level as the
442 original tree; we must not look through any indirections.
443 Returning anything other than NULL_TREE will cause the caller to
444 not find a base. */
445 if (REFERENCE_CLASS_P (*tp))
446 return *tp;
447
448 if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp)))
449 {
450 if (*pdecl)
451 {
452 /* We already found a pointer decl; return anything other
453 than NULL_TREE to unwind from walk_tree signalling that
454 we have a duplicate. */
455 return *tp;
456 }
457 *pdecl = *tp;
458 }
459
460 return NULL_TREE;
461 }
462
463 /* Find the single DECL of pointer type in the tree T, used directly
464 rather than via an indirection, and return it. If there are zero
465 or more than one such DECLs, return NULL. */
466
467 static tree
468 find_single_pointer_decl (tree t)
469 {
470 tree decl = NULL_TREE;
471
472 if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL))
473 {
474 /* find_single_pointer_decl_1 returns a nonzero value, causing
475 walk_tree to return a nonzero value, to indicate that it
476 found more than one pointer DECL or that it found an
477 indirection. */
478 return NULL_TREE;
479 }
480
481 return decl;
482 }
483
484 /* Create a new temporary name with PREFIX. Returns an identifier. */
485
486 static GTY(()) unsigned int tmp_var_id_num;
487
488 tree
489 create_tmp_var_name (const char *prefix)
490 {
491 char *tmp_name;
492
493 if (prefix)
494 {
495 char *preftmp = ASTRDUP (prefix);
496
497 remove_suffix (preftmp, strlen (preftmp));
498 prefix = preftmp;
499 }
500
501 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
502 return get_identifier (tmp_name);
503 }
504
505
506 /* Create a new temporary variable declaration of type TYPE.
507 Does NOT push it into the current binding. */
508
509 tree
510 create_tmp_var_raw (tree type, const char *prefix)
511 {
512 tree tmp_var;
513 tree new_type;
514
515 /* Make the type of the variable writable. */
516 new_type = build_type_variant (type, 0, 0);
517 TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
518
519 tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
520 type);
521
522 /* The variable was declared by the compiler. */
523 DECL_ARTIFICIAL (tmp_var) = 1;
524 /* And we don't want debug info for it. */
525 DECL_IGNORED_P (tmp_var) = 1;
526
527 /* Make the variable writable. */
528 TREE_READONLY (tmp_var) = 0;
529
530 DECL_EXTERNAL (tmp_var) = 0;
531 TREE_STATIC (tmp_var) = 0;
532 TREE_USED (tmp_var) = 1;
533
534 return tmp_var;
535 }
536
537 /* Create a new temporary variable declaration of type TYPE. DOES push the
538 variable into the current binding. Further, assume that this is called
539 only from gimplification or optimization, at which point the creation of
540 certain types are bugs. */
541
542 tree
543 create_tmp_var (tree type, const char *prefix)
544 {
545 tree tmp_var;
546
547 /* We don't allow types that are addressable (meaning we can't make copies),
548 or incomplete. We also used to reject every variable size objects here,
549 but now support those for which a constant upper bound can be obtained.
550 The processing for variable sizes is performed in gimple_add_tmp_var,
551 point at which it really matters and possibly reached via paths not going
552 through this function, e.g. after direct calls to create_tmp_var_raw. */
553 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
554
555 tmp_var = create_tmp_var_raw (type, prefix);
556 gimple_add_tmp_var (tmp_var);
557 return tmp_var;
558 }
559
560 /* Create a temporary with a name derived from VAL. Subroutine of
561 lookup_tmp_var; nobody else should call this function. */
562
563 static inline tree
564 create_tmp_from_val (tree val)
565 {
566 return create_tmp_var (TREE_TYPE (val), get_name (val));
567 }
568
569 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
570 an existing expression temporary. */
571
572 static tree
573 lookup_tmp_var (tree val, bool is_formal)
574 {
575 tree ret;
576
577 /* If not optimizing, never really reuse a temporary. local-alloc
578 won't allocate any variable that is used in more than one basic
579 block, which means it will go into memory, causing much extra
580 work in reload and final and poorer code generation, outweighing
581 the extra memory allocation here. */
582 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
583 ret = create_tmp_from_val (val);
584 else
585 {
586 elt_t elt, *elt_p;
587 void **slot;
588
589 elt.val = val;
590 if (gimplify_ctxp->temp_htab == NULL)
591 gimplify_ctxp->temp_htab
592 = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
593 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
594 if (*slot == NULL)
595 {
596 elt_p = XNEW (elt_t);
597 elt_p->val = val;
598 elt_p->temp = ret = create_tmp_from_val (val);
599 *slot = (void *) elt_p;
600 }
601 else
602 {
603 elt_p = (elt_t *) *slot;
604 ret = elt_p->temp;
605 }
606 }
607
608 return ret;
609 }
610
611
612 /* Return true if T is a CALL_EXPR or an expression that can be
613 assignmed to a temporary. Note that this predicate should only be
614 used during gimplification. See the rationale for this in
615 gimplify_modify_expr. */
616
617 static bool
618 is_gimple_reg_rhs_or_call (tree t)
619 {
620 return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
621 || TREE_CODE (t) == CALL_EXPR);
622 }
623
624 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
625 this predicate should only be used during gimplification. See the
626 rationale for this in gimplify_modify_expr. */
627
628 static bool
629 is_gimple_mem_rhs_or_call (tree t)
630 {
631 /* If we're dealing with a renamable type, either source or dest must be
632 a renamed variable. */
633 if (is_gimple_reg_type (TREE_TYPE (t)))
634 return is_gimple_val (t);
635 else
636 return (is_gimple_val (t) || is_gimple_lvalue (t)
637 || TREE_CODE (t) == CALL_EXPR);
638 }
639
640 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
641
642 static tree
643 internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
644 bool is_formal)
645 {
646 tree t, mod;
647
648 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
649 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
650 gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
651 fb_rvalue);
652
653 t = lookup_tmp_var (val, is_formal);
654
655 if (is_formal)
656 {
657 tree u = find_single_pointer_decl (val);
658
659 if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u))
660 u = DECL_GET_RESTRICT_BASE (u);
661 if (u && TYPE_RESTRICT (TREE_TYPE (u)))
662 {
663 if (DECL_BASED_ON_RESTRICT_P (t))
664 gcc_assert (u == DECL_GET_RESTRICT_BASE (t));
665 else
666 {
667 DECL_BASED_ON_RESTRICT_P (t) = 1;
668 SET_DECL_RESTRICT_BASE (t, u);
669 }
670 }
671
672 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
673 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
674 DECL_GIMPLE_REG_P (t) = 1;
675 }
676
677 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
678
679 if (EXPR_HAS_LOCATION (val))
680 SET_EXPR_LOCUS (mod, EXPR_LOCUS (val));
681 else
682 SET_EXPR_LOCATION (mod, input_location);
683
684 /* gimplify_modify_expr might want to reduce this further. */
685 gimplify_and_add (mod, pre_p);
686 ggc_free (mod);
687
688 /* If we're gimplifying into ssa, gimplify_modify_expr will have
689 given our temporary an SSA name. Find and return it. */
690 if (gimplify_ctxp->into_ssa)
691 {
692 gimple last = gimple_seq_last_stmt (*pre_p);
693 t = gimple_get_lhs (last);
694 }
695
696 return t;
697 }
698
699 /* Returns a formal temporary variable initialized with VAL. PRE_P is as
700 in gimplify_expr. Only use this function if:
701
702 1) The value of the unfactored expression represented by VAL will not
703 change between the initialization and use of the temporary, and
704 2) The temporary will not be otherwise modified.
705
706 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
707 and #2 means it is inappropriate for && temps.
708
709 For other cases, use get_initialized_tmp_var instead. */
710
711 tree
712 get_formal_tmp_var (tree val, gimple_seq *pre_p)
713 {
714 return internal_get_tmp_var (val, pre_p, NULL, true);
715 }
716
717 /* Returns a temporary variable initialized with VAL. PRE_P and POST_P
718 are as in gimplify_expr. */
719
720 tree
721 get_initialized_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p)
722 {
723 return internal_get_tmp_var (val, pre_p, post_p, false);
724 }
725
726 /* Declares all the variables in VARS in SCOPE. If DEBUG_INFO is
727 true, generate debug info for them; otherwise don't. */
728
729 void
730 declare_vars (tree vars, gimple scope, bool debug_info)
731 {
732 tree last = vars;
733 if (last)
734 {
735 tree temps, block;
736
737 gcc_assert (gimple_code (scope) == GIMPLE_BIND);
738
739 temps = nreverse (last);
740
741 block = gimple_bind_block (scope);
742 gcc_assert (!block || TREE_CODE (block) == BLOCK);
743 if (!block || !debug_info)
744 {
745 TREE_CHAIN (last) = gimple_bind_vars (scope);
746 gimple_bind_set_vars (scope, temps);
747 }
748 else
749 {
750 /* We need to attach the nodes both to the BIND_EXPR and to its
751 associated BLOCK for debugging purposes. The key point here
752 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
753 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
754 if (BLOCK_VARS (block))
755 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
756 else
757 {
758 gimple_bind_set_vars (scope,
759 chainon (gimple_bind_vars (scope), temps));
760 BLOCK_VARS (block) = temps;
761 }
762 }
763 }
764 }
765
766 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
767 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
768 no such upper bound can be obtained. */
769
770 static void
771 force_constant_size (tree var)
772 {
773 /* The only attempt we make is by querying the maximum size of objects
774 of the variable's type. */
775
776 HOST_WIDE_INT max_size;
777
778 gcc_assert (TREE_CODE (var) == VAR_DECL);
779
780 max_size = max_int_size_in_bytes (TREE_TYPE (var));
781
782 gcc_assert (max_size >= 0);
783
784 DECL_SIZE_UNIT (var)
785 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
786 DECL_SIZE (var)
787 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
788 }
789
790 void
791 gimple_add_tmp_var (tree tmp)
792 {
793 gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
794
795 /* Later processing assumes that the object size is constant, which might
796 not be true at this point. Force the use of a constant upper bound in
797 this case. */
798 if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
799 force_constant_size (tmp);
800
801 DECL_CONTEXT (tmp) = current_function_decl;
802 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
803
804 if (gimplify_ctxp)
805 {
806 TREE_CHAIN (tmp) = gimplify_ctxp->temps;
807 gimplify_ctxp->temps = tmp;
808
809 /* Mark temporaries local within the nearest enclosing parallel. */
810 if (gimplify_omp_ctxp)
811 {
812 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
813 while (ctx && ctx->region_type == ORT_WORKSHARE)
814 ctx = ctx->outer_context;
815 if (ctx)
816 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
817 }
818 }
819 else if (cfun)
820 record_vars (tmp);
821 else
822 {
823 gimple_seq body_seq;
824
825 /* This case is for nested functions. We need to expose the locals
826 they create. */
827 body_seq = gimple_body (current_function_decl);
828 declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
829 }
830 }
831
832 /* Determines whether to assign a location to the statement GS. */
833
834 static bool
835 should_carry_location_p (gimple gs)
836 {
837 /* Don't emit a line note for a label. We particularly don't want to
838 emit one for the break label, since it doesn't actually correspond
839 to the beginning of the loop/switch. */
840 if (gimple_code (gs) == GIMPLE_LABEL)
841 return false;
842
843 return true;
844 }
845
846 /* Same, but for a tree. */
847
848 static bool
849 tree_should_carry_location_p (const_tree stmt)
850 {
851 /* Don't emit a line note for a label. We particularly don't want to
852 emit one for the break label, since it doesn't actually correspond
853 to the beginning of the loop/switch. */
854 if (TREE_CODE (stmt) == LABEL_EXPR)
855 return false;
856
857 /* Do not annotate empty statements, since it confuses gcov. */
858 if (!TREE_SIDE_EFFECTS (stmt))
859 return false;
860
861 return true;
862 }
863
864 /* Return true if a location should not be emitted for this statement
865 by annotate_one_with_location. */
866
867 static inline bool
868 gimple_do_not_emit_location_p (gimple g)
869 {
870 return gimple_plf (g, GF_PLF_1);
871 }
872
873 /* Mark statement G so a location will not be emitted by
874 annotate_one_with_location. */
875
876 static inline void
877 gimple_set_do_not_emit_location (gimple g)
878 {
879 /* The PLF flags are initialized to 0 when a new tuple is created,
880 so no need to initialize it anywhere. */
881 gimple_set_plf (g, GF_PLF_1, true);
882 }
883
884 /* Set the location for gimple statement GS to LOCUS. */
885
886 static void
887 annotate_one_with_location (gimple gs, location_t location)
888 {
889 if (!gimple_has_location (gs)
890 && !gimple_do_not_emit_location_p (gs)
891 && should_carry_location_p (gs))
892 gimple_set_location (gs, location);
893 }
894
895 /* Same, but for tree T. */
896
897 static void
898 tree_annotate_one_with_location (tree t, location_t location)
899 {
900 if (CAN_HAVE_LOCATION_P (t)
901 && ! EXPR_HAS_LOCATION (t) && tree_should_carry_location_p (t))
902 SET_EXPR_LOCATION (t, location);
903 }
904
905
906 /* Set LOCATION for all the statements after iterator GSI in sequence
907 SEQ. If GSI is pointing to the end of the sequence, start with the
908 first statement in SEQ. */
909
910 static void
911 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
912 location_t location)
913 {
914 if (gsi_end_p (gsi))
915 gsi = gsi_start (seq);
916 else
917 gsi_next (&gsi);
918
919 for (; !gsi_end_p (gsi); gsi_next (&gsi))
920 annotate_one_with_location (gsi_stmt (gsi), location);
921 }
922
923
924 /* Set the location for all the statements in a sequence STMT_P to LOCUS. */
925
926 void
927 annotate_all_with_location (gimple_seq stmt_p, location_t location)
928 {
929 gimple_stmt_iterator i;
930
931 if (gimple_seq_empty_p (stmt_p))
932 return;
933
934 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
935 {
936 gimple gs = gsi_stmt (i);
937 annotate_one_with_location (gs, location);
938 }
939 }
940
941 /* Same, but for statement or statement list in *STMT_P. */
942
943 void
944 tree_annotate_all_with_location (tree *stmt_p, location_t location)
945 {
946 tree_stmt_iterator i;
947
948 if (!*stmt_p)
949 return;
950
951 for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i))
952 {
953 tree t = tsi_stmt (i);
954
955 /* Assuming we've already been gimplified, we shouldn't
956 see nested chaining constructs anymore. */
957 gcc_assert (TREE_CODE (t) != STATEMENT_LIST
958 && TREE_CODE (t) != COMPOUND_EXPR);
959
960 tree_annotate_one_with_location (t, location);
961 }
962 }
963
964
965 /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
966 These nodes model computations that should only be done once. If we
967 were to unshare something like SAVE_EXPR(i++), the gimplification
968 process would create wrong code. */
969
970 static tree
971 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
972 {
973 enum tree_code code = TREE_CODE (*tp);
974 /* Don't unshare types, decls, constants and SAVE_EXPR nodes. */
975 if (TREE_CODE_CLASS (code) == tcc_type
976 || TREE_CODE_CLASS (code) == tcc_declaration
977 || TREE_CODE_CLASS (code) == tcc_constant
978 || code == SAVE_EXPR || code == TARGET_EXPR
979 /* We can't do anything sensible with a BLOCK used as an expression,
980 but we also can't just die when we see it because of non-expression
981 uses. So just avert our eyes and cross our fingers. Silly Java. */
982 || code == BLOCK)
983 *walk_subtrees = 0;
984 else
985 {
986 gcc_assert (code != BIND_EXPR);
987 copy_tree_r (tp, walk_subtrees, data);
988 }
989
990 return NULL_TREE;
991 }
992
993 /* Callback for walk_tree to unshare most of the shared trees rooted at
994 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
995 then *TP is deep copied by calling copy_tree_r.
996
997 This unshares the same trees as copy_tree_r with the exception of
998 SAVE_EXPR nodes. These nodes model computations that should only be
999 done once. If we were to unshare something like SAVE_EXPR(i++), the
1000 gimplification process would create wrong code. */
1001
1002 static tree
1003 copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
1004 void *data ATTRIBUTE_UNUSED)
1005 {
1006 tree t = *tp;
1007 enum tree_code code = TREE_CODE (t);
1008
1009 /* Skip types, decls, and constants. But we do want to look at their
1010 types and the bounds of types. Mark them as visited so we properly
1011 unmark their subtrees on the unmark pass. If we've already seen them,
1012 don't look down further. */
1013 if (TREE_CODE_CLASS (code) == tcc_type
1014 || TREE_CODE_CLASS (code) == tcc_declaration
1015 || TREE_CODE_CLASS (code) == tcc_constant)
1016 {
1017 if (TREE_VISITED (t))
1018 *walk_subtrees = 0;
1019 else
1020 TREE_VISITED (t) = 1;
1021 }
1022
1023 /* If this node has been visited already, unshare it and don't look
1024 any deeper. */
1025 else if (TREE_VISITED (t))
1026 {
1027 walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
1028 *walk_subtrees = 0;
1029 }
1030
1031 /* Otherwise, mark the tree as visited and keep looking. */
1032 else
1033 TREE_VISITED (t) = 1;
1034
1035 return NULL_TREE;
1036 }
1037
1038 static tree
1039 unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
1040 void *data ATTRIBUTE_UNUSED)
1041 {
1042 if (TREE_VISITED (*tp))
1043 TREE_VISITED (*tp) = 0;
1044 else
1045 *walk_subtrees = 0;
1046
1047 return NULL_TREE;
1048 }
1049
1050 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
1051 bodies of any nested functions if we are unsharing the entire body of
1052 FNDECL. */
1053
1054 static void
1055 unshare_body (tree *body_p, tree fndecl)
1056 {
1057 struct cgraph_node *cgn = cgraph_node (fndecl);
1058
1059 walk_tree (body_p, copy_if_shared_r, NULL, NULL);
1060 if (body_p == &DECL_SAVED_TREE (fndecl))
1061 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
1062 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
1063 }
1064
1065 /* Likewise, but mark all trees as not visited. */
1066
1067 static void
1068 unvisit_body (tree *body_p, tree fndecl)
1069 {
1070 struct cgraph_node *cgn = cgraph_node (fndecl);
1071
1072 walk_tree (body_p, unmark_visited_r, NULL, NULL);
1073 if (body_p == &DECL_SAVED_TREE (fndecl))
1074 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
1075 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
1076 }
1077
1078 /* Unconditionally make an unshared copy of EXPR. This is used when using
1079 stored expressions which span multiple functions, such as BINFO_VTABLE,
1080 as the normal unsharing process can't tell that they're shared. */
1081
1082 tree
1083 unshare_expr (tree expr)
1084 {
1085 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
1086 return expr;
1087 }
1088 \f
1089 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1090 contain statements and have a value. Assign its value to a temporary
1091 and give it void_type_node. Returns the temporary, or NULL_TREE if
1092 WRAPPER was already void. */
1093
1094 tree
1095 voidify_wrapper_expr (tree wrapper, tree temp)
1096 {
1097 tree type = TREE_TYPE (wrapper);
1098 if (type && !VOID_TYPE_P (type))
1099 {
1100 tree *p;
1101
1102 /* Set p to point to the body of the wrapper. Loop until we find
1103 something that isn't a wrapper. */
1104 for (p = &wrapper; p && *p; )
1105 {
1106 switch (TREE_CODE (*p))
1107 {
1108 case BIND_EXPR:
1109 TREE_SIDE_EFFECTS (*p) = 1;
1110 TREE_TYPE (*p) = void_type_node;
1111 /* For a BIND_EXPR, the body is operand 1. */
1112 p = &BIND_EXPR_BODY (*p);
1113 break;
1114
1115 case CLEANUP_POINT_EXPR:
1116 case TRY_FINALLY_EXPR:
1117 case TRY_CATCH_EXPR:
1118 TREE_SIDE_EFFECTS (*p) = 1;
1119 TREE_TYPE (*p) = void_type_node;
1120 p = &TREE_OPERAND (*p, 0);
1121 break;
1122
1123 case STATEMENT_LIST:
1124 {
1125 tree_stmt_iterator i = tsi_last (*p);
1126 TREE_SIDE_EFFECTS (*p) = 1;
1127 TREE_TYPE (*p) = void_type_node;
1128 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1129 }
1130 break;
1131
1132 case COMPOUND_EXPR:
1133 /* Advance to the last statement. Set all container types to void. */
1134 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1135 {
1136 TREE_SIDE_EFFECTS (*p) = 1;
1137 TREE_TYPE (*p) = void_type_node;
1138 }
1139 break;
1140
1141 default:
1142 goto out;
1143 }
1144 }
1145
1146 out:
1147 if (p == NULL || IS_EMPTY_STMT (*p))
1148 temp = NULL_TREE;
1149 else if (temp)
1150 {
1151 /* The wrapper is on the RHS of an assignment that we're pushing
1152 down. */
1153 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1154 || TREE_CODE (temp) == MODIFY_EXPR);
1155 TREE_OPERAND (temp, 1) = *p;
1156 *p = temp;
1157 }
1158 else
1159 {
1160 temp = create_tmp_var (type, "retval");
1161 *p = build2 (INIT_EXPR, type, temp, *p);
1162 }
1163
1164 return temp;
1165 }
1166
1167 return NULL_TREE;
1168 }
1169
1170 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1171 a temporary through which they communicate. */
1172
1173 static void
1174 build_stack_save_restore (gimple *save, gimple *restore)
1175 {
1176 tree tmp_var;
1177
1178 *save = gimple_build_call (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 0);
1179 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1180 gimple_call_set_lhs (*save, tmp_var);
1181
1182 *restore = gimple_build_call (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
1183 1, tmp_var);
1184 }
1185
1186 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1187
1188 static enum gimplify_status
1189 gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
1190 {
1191 tree bind_expr = *expr_p;
1192 bool old_save_stack = gimplify_ctxp->save_stack;
1193 tree t;
1194 gimple gimple_bind;
1195 gimple_seq body;
1196
1197 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1198
1199 /* Mark variables seen in this bind expr. */
1200 for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
1201 {
1202 if (TREE_CODE (t) == VAR_DECL)
1203 {
1204 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1205
1206 /* Mark variable as local. */
1207 if (ctx && !is_global_var (t)
1208 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1209 || splay_tree_lookup (ctx->variables,
1210 (splay_tree_key) t) == NULL))
1211 omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1212
1213 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1214
1215 if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
1216 cfun->has_local_explicit_reg_vars = true;
1217 }
1218
1219 /* Preliminarily mark non-addressed complex variables as eligible
1220 for promotion to gimple registers. We'll transform their uses
1221 as we find them.
1222 We exclude complex types if not optimizing because they can be
1223 subject to partial stores in GNU C by means of the __real__ and
1224 __imag__ operators and we cannot promote them to total stores
1225 (see gimplify_modify_expr_complex_part). */
1226 if (optimize
1227 && (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1228 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1229 && !TREE_THIS_VOLATILE (t)
1230 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1231 && !needs_to_live_in_memory (t))
1232 DECL_GIMPLE_REG_P (t) = 1;
1233 }
1234
1235 gimple_bind = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
1236 BIND_EXPR_BLOCK (bind_expr));
1237 gimple_push_bind_expr (gimple_bind);
1238
1239 gimplify_ctxp->save_stack = false;
1240
1241 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1242 body = NULL;
1243 gimplify_stmt (&BIND_EXPR_BODY (bind_expr), &body);
1244 gimple_bind_set_body (gimple_bind, body);
1245
1246 if (gimplify_ctxp->save_stack)
1247 {
1248 gimple stack_save, stack_restore, gs;
1249 gimple_seq cleanup, new_body;
1250
1251 /* Save stack on entry and restore it on exit. Add a try_finally
1252 block to achieve this. Note that mudflap depends on the
1253 format of the emitted code: see mx_register_decls(). */
1254 build_stack_save_restore (&stack_save, &stack_restore);
1255
1256 cleanup = new_body = NULL;
1257 gimplify_seq_add_stmt (&cleanup, stack_restore);
1258 gs = gimple_build_try (gimple_bind_body (gimple_bind), cleanup,
1259 GIMPLE_TRY_FINALLY);
1260
1261 gimplify_seq_add_stmt (&new_body, stack_save);
1262 gimplify_seq_add_stmt (&new_body, gs);
1263 gimple_bind_set_body (gimple_bind, new_body);
1264 }
1265
1266 gimplify_ctxp->save_stack = old_save_stack;
1267 gimple_pop_bind_expr ();
1268
1269 gimplify_seq_add_stmt (pre_p, gimple_bind);
1270
1271 if (temp)
1272 {
1273 *expr_p = temp;
1274 return GS_OK;
1275 }
1276
1277 *expr_p = NULL_TREE;
1278 return GS_ALL_DONE;
1279 }
1280
1281 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1282 GIMPLE value, it is assigned to a new temporary and the statement is
1283 re-written to return the temporary.
1284
1285 PRE_P points to the sequence where side effects that must happen before
1286 STMT should be stored. */
1287
1288 static enum gimplify_status
1289 gimplify_return_expr (tree stmt, gimple_seq *pre_p)
1290 {
1291 gimple ret;
1292 tree ret_expr = TREE_OPERAND (stmt, 0);
1293 tree result_decl, result;
1294
1295 if (ret_expr == error_mark_node)
1296 return GS_ERROR;
1297
1298 if (!ret_expr
1299 || TREE_CODE (ret_expr) == RESULT_DECL
1300 || ret_expr == error_mark_node)
1301 {
1302 gimple ret = gimple_build_return (ret_expr);
1303 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1304 gimplify_seq_add_stmt (pre_p, ret);
1305 return GS_ALL_DONE;
1306 }
1307
1308 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1309 result_decl = NULL_TREE;
1310 else
1311 {
1312 result_decl = TREE_OPERAND (ret_expr, 0);
1313
1314 /* See through a return by reference. */
1315 if (TREE_CODE (result_decl) == INDIRECT_REF)
1316 result_decl = TREE_OPERAND (result_decl, 0);
1317
1318 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1319 || TREE_CODE (ret_expr) == INIT_EXPR)
1320 && TREE_CODE (result_decl) == RESULT_DECL);
1321 }
1322
1323 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1324 Recall that aggregate_value_p is FALSE for any aggregate type that is
1325 returned in registers. If we're returning values in registers, then
1326 we don't want to extend the lifetime of the RESULT_DECL, particularly
1327 across another call. In addition, for those aggregates for which
1328 hard_function_value generates a PARALLEL, we'll die during normal
1329 expansion of structure assignments; there's special code in expand_return
1330 to handle this case that does not exist in expand_expr. */
1331 if (!result_decl
1332 || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1333 result = result_decl;
1334 else if (gimplify_ctxp->return_temp)
1335 result = gimplify_ctxp->return_temp;
1336 else
1337 {
1338 result = create_tmp_var (TREE_TYPE (result_decl), NULL);
1339 if (TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1340 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1341 DECL_GIMPLE_REG_P (result) = 1;
1342
1343 /* ??? With complex control flow (usually involving abnormal edges),
1344 we can wind up warning about an uninitialized value for this. Due
1345 to how this variable is constructed and initialized, this is never
1346 true. Give up and never warn. */
1347 TREE_NO_WARNING (result) = 1;
1348
1349 gimplify_ctxp->return_temp = result;
1350 }
1351
1352 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1353 Then gimplify the whole thing. */
1354 if (result != result_decl)
1355 TREE_OPERAND (ret_expr, 0) = result;
1356
1357 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1358
1359 ret = gimple_build_return (result);
1360 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1361 gimplify_seq_add_stmt (pre_p, ret);
1362
1363 return GS_ALL_DONE;
1364 }
1365
1366 static void
1367 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1368 {
1369 /* This is a variable-sized decl. Simplify its size and mark it
1370 for deferred expansion. Note that mudflap depends on the format
1371 of the emitted code: see mx_register_decls(). */
1372 tree t, addr, ptr_type;
1373
1374 gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1375 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1376
1377 /* All occurrences of this decl in final gimplified code will be
1378 replaced by indirection. Setting DECL_VALUE_EXPR does two
1379 things: First, it lets the rest of the gimplifier know what
1380 replacement to use. Second, it lets the debug info know
1381 where to find the value. */
1382 ptr_type = build_pointer_type (TREE_TYPE (decl));
1383 addr = create_tmp_var (ptr_type, get_name (decl));
1384 DECL_IGNORED_P (addr) = 0;
1385 t = build_fold_indirect_ref (addr);
1386 SET_DECL_VALUE_EXPR (decl, t);
1387 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1388
1389 t = built_in_decls[BUILT_IN_ALLOCA];
1390 t = build_call_expr (t, 1, DECL_SIZE_UNIT (decl));
1391 t = fold_convert (ptr_type, t);
1392 t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1393
1394 gimplify_and_add (t, seq_p);
1395
1396 /* Indicate that we need to restore the stack level when the
1397 enclosing BIND_EXPR is exited. */
1398 gimplify_ctxp->save_stack = true;
1399 }
1400
1401
1402 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1403 and initialization explicit. */
1404
1405 static enum gimplify_status
1406 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1407 {
1408 tree stmt = *stmt_p;
1409 tree decl = DECL_EXPR_DECL (stmt);
1410
1411 *stmt_p = NULL_TREE;
1412
1413 if (TREE_TYPE (decl) == error_mark_node)
1414 return GS_ERROR;
1415
1416 if ((TREE_CODE (decl) == TYPE_DECL
1417 || TREE_CODE (decl) == VAR_DECL)
1418 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1419 gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1420
1421 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1422 {
1423 tree init = DECL_INITIAL (decl);
1424
1425 if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1426 || (!TREE_STATIC (decl)
1427 && flag_stack_check == GENERIC_STACK_CHECK
1428 && compare_tree_int (DECL_SIZE_UNIT (decl),
1429 STACK_CHECK_MAX_VAR_SIZE) > 0))
1430 gimplify_vla_decl (decl, seq_p);
1431
1432 if (init && init != error_mark_node)
1433 {
1434 if (!TREE_STATIC (decl))
1435 {
1436 DECL_INITIAL (decl) = NULL_TREE;
1437 init = build2 (INIT_EXPR, void_type_node, decl, init);
1438 gimplify_and_add (init, seq_p);
1439 ggc_free (init);
1440 }
1441 else
1442 /* We must still examine initializers for static variables
1443 as they may contain a label address. */
1444 walk_tree (&init, force_labels_r, NULL, NULL);
1445 }
1446
1447 /* Some front ends do not explicitly declare all anonymous
1448 artificial variables. We compensate here by declaring the
1449 variables, though it would be better if the front ends would
1450 explicitly declare them. */
1451 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1452 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1453 gimple_add_tmp_var (decl);
1454 }
1455
1456 return GS_ALL_DONE;
1457 }
1458
1459 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1460 and replacing the LOOP_EXPR with goto, but if the loop contains an
1461 EXIT_EXPR, we need to append a label for it to jump to. */
1462
1463 static enum gimplify_status
1464 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1465 {
1466 tree saved_label = gimplify_ctxp->exit_label;
1467 tree start_label = create_artificial_label ();
1468
1469 gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1470
1471 gimplify_ctxp->exit_label = NULL_TREE;
1472
1473 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1474
1475 gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1476
1477 if (gimplify_ctxp->exit_label)
1478 gimplify_seq_add_stmt (pre_p, gimple_build_label (gimplify_ctxp->exit_label));
1479
1480 gimplify_ctxp->exit_label = saved_label;
1481
1482 *expr_p = NULL;
1483 return GS_ALL_DONE;
1484 }
1485
1486 /* Gimplifies a statement list onto a sequence. These may be created either
1487 by an enlightened front-end, or by shortcut_cond_expr. */
1488
1489 static enum gimplify_status
1490 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1491 {
1492 tree temp = voidify_wrapper_expr (*expr_p, NULL);
1493
1494 tree_stmt_iterator i = tsi_start (*expr_p);
1495
1496 while (!tsi_end_p (i))
1497 {
1498 gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1499 tsi_delink (&i);
1500 }
1501
1502 if (temp)
1503 {
1504 *expr_p = temp;
1505 return GS_OK;
1506 }
1507
1508 return GS_ALL_DONE;
1509 }
1510
1511 /* Compare two case labels. Because the front end should already have
1512 made sure that case ranges do not overlap, it is enough to only compare
1513 the CASE_LOW values of each case label. */
1514
1515 static int
1516 compare_case_labels (const void *p1, const void *p2)
1517 {
1518 const_tree const case1 = *(const_tree const*)p1;
1519 const_tree const case2 = *(const_tree const*)p2;
1520
1521 /* The 'default' case label always goes first. */
1522 if (!CASE_LOW (case1))
1523 return -1;
1524 else if (!CASE_LOW (case2))
1525 return 1;
1526 else
1527 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1528 }
1529
1530
1531 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1532
1533 void
1534 sort_case_labels (VEC(tree,heap)* label_vec)
1535 {
1536 size_t len = VEC_length (tree, label_vec);
1537 qsort (VEC_address (tree, label_vec), len, sizeof (tree),
1538 compare_case_labels);
1539 }
1540
1541
1542 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1543 branch to. */
1544
1545 static enum gimplify_status
1546 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
1547 {
1548 tree switch_expr = *expr_p;
1549 gimple_seq switch_body_seq = NULL;
1550 enum gimplify_status ret;
1551
1552 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
1553 fb_rvalue);
1554 if (ret == GS_ERROR || ret == GS_UNHANDLED)
1555 return ret;
1556
1557 if (SWITCH_BODY (switch_expr))
1558 {
1559 VEC (tree,heap) *labels;
1560 VEC (tree,heap) *saved_labels;
1561 tree default_case = NULL_TREE;
1562 size_t i, len;
1563 gimple gimple_switch;
1564
1565 /* If someone can be bothered to fill in the labels, they can
1566 be bothered to null out the body too. */
1567 gcc_assert (!SWITCH_LABELS (switch_expr));
1568
1569 /* save old labels, get new ones from body, then restore the old
1570 labels. Save all the things from the switch body to append after. */
1571 saved_labels = gimplify_ctxp->case_labels;
1572 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1573
1574 gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
1575 labels = gimplify_ctxp->case_labels;
1576 gimplify_ctxp->case_labels = saved_labels;
1577
1578 i = 0;
1579 while (i < VEC_length (tree, labels))
1580 {
1581 tree elt = VEC_index (tree, labels, i);
1582 tree low = CASE_LOW (elt);
1583 bool remove_element = FALSE;
1584
1585 if (low)
1586 {
1587 /* Discard empty ranges. */
1588 tree high = CASE_HIGH (elt);
1589 if (high && tree_int_cst_lt (high, low))
1590 remove_element = TRUE;
1591 }
1592 else
1593 {
1594 /* The default case must be the last label in the list. */
1595 gcc_assert (!default_case);
1596 default_case = elt;
1597 remove_element = TRUE;
1598 }
1599
1600 if (remove_element)
1601 VEC_ordered_remove (tree, labels, i);
1602 else
1603 i++;
1604 }
1605 len = i;
1606
1607 if (!VEC_empty (tree, labels))
1608 sort_case_labels (labels);
1609
1610 if (!default_case)
1611 {
1612 tree type = TREE_TYPE (switch_expr);
1613
1614 /* If the switch has no default label, add one, so that we jump
1615 around the switch body. If the labels already cover the whole
1616 range of type, add the default label pointing to one of the
1617 existing labels. */
1618 if (type == void_type_node)
1619 type = TREE_TYPE (SWITCH_COND (switch_expr));
1620 if (len
1621 && INTEGRAL_TYPE_P (type)
1622 && TYPE_MIN_VALUE (type)
1623 && TYPE_MAX_VALUE (type)
1624 && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
1625 TYPE_MIN_VALUE (type)))
1626 {
1627 tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
1628 if (!high)
1629 high = CASE_LOW (VEC_index (tree, labels, len - 1));
1630 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
1631 {
1632 for (i = 1; i < len; i++)
1633 {
1634 high = CASE_LOW (VEC_index (tree, labels, i));
1635 low = CASE_HIGH (VEC_index (tree, labels, i - 1));
1636 if (!low)
1637 low = CASE_LOW (VEC_index (tree, labels, i - 1));
1638 if ((TREE_INT_CST_LOW (low) + 1
1639 != TREE_INT_CST_LOW (high))
1640 || (TREE_INT_CST_HIGH (low)
1641 + (TREE_INT_CST_LOW (high) == 0)
1642 != TREE_INT_CST_HIGH (high)))
1643 break;
1644 }
1645 if (i == len)
1646 default_case = build3 (CASE_LABEL_EXPR, void_type_node,
1647 NULL_TREE, NULL_TREE,
1648 CASE_LABEL (VEC_index (tree,
1649 labels, 0)));
1650 }
1651 }
1652
1653 if (!default_case)
1654 {
1655 gimple new_default;
1656
1657 default_case = build3 (CASE_LABEL_EXPR, void_type_node,
1658 NULL_TREE, NULL_TREE,
1659 create_artificial_label ());
1660 new_default = gimple_build_label (CASE_LABEL (default_case));
1661 gimplify_seq_add_stmt (&switch_body_seq, new_default);
1662 }
1663 }
1664
1665 gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
1666 default_case, labels);
1667 gimplify_seq_add_stmt (pre_p, gimple_switch);
1668 gimplify_seq_add_seq (pre_p, switch_body_seq);
1669 VEC_free(tree, heap, labels);
1670 }
1671 else
1672 gcc_assert (SWITCH_LABELS (switch_expr));
1673
1674 return GS_ALL_DONE;
1675 }
1676
1677
1678 static enum gimplify_status
1679 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
1680 {
1681 struct gimplify_ctx *ctxp;
1682 gimple gimple_label;
1683
1684 /* Invalid OpenMP programs can play Duff's Device type games with
1685 #pragma omp parallel. At least in the C front end, we don't
1686 detect such invalid branches until after gimplification. */
1687 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1688 if (ctxp->case_labels)
1689 break;
1690
1691 gimple_label = gimple_build_label (CASE_LABEL (*expr_p));
1692 VEC_safe_push (tree, heap, ctxp->case_labels, *expr_p);
1693 gimplify_seq_add_stmt (pre_p, gimple_label);
1694
1695 return GS_ALL_DONE;
1696 }
1697
1698 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1699 if necessary. */
1700
1701 tree
1702 build_and_jump (tree *label_p)
1703 {
1704 if (label_p == NULL)
1705 /* If there's nowhere to jump, just fall through. */
1706 return NULL_TREE;
1707
1708 if (*label_p == NULL_TREE)
1709 {
1710 tree label = create_artificial_label ();
1711 *label_p = label;
1712 }
1713
1714 return build1 (GOTO_EXPR, void_type_node, *label_p);
1715 }
1716
1717 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1718 This also involves building a label to jump to and communicating it to
1719 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1720
1721 static enum gimplify_status
1722 gimplify_exit_expr (tree *expr_p)
1723 {
1724 tree cond = TREE_OPERAND (*expr_p, 0);
1725 tree expr;
1726
1727 expr = build_and_jump (&gimplify_ctxp->exit_label);
1728 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1729 *expr_p = expr;
1730
1731 return GS_OK;
1732 }
1733
1734 /* A helper function to be called via walk_tree. Mark all labels under *TP
1735 as being forced. To be called for DECL_INITIAL of static variables. */
1736
1737 tree
1738 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1739 {
1740 if (TYPE_P (*tp))
1741 *walk_subtrees = 0;
1742 if (TREE_CODE (*tp) == LABEL_DECL)
1743 FORCED_LABEL (*tp) = 1;
1744
1745 return NULL_TREE;
1746 }
1747
1748 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1749 different from its canonical type, wrap the whole thing inside a
1750 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1751 type.
1752
1753 The canonical type of a COMPONENT_REF is the type of the field being
1754 referenced--unless the field is a bit-field which can be read directly
1755 in a smaller mode, in which case the canonical type is the
1756 sign-appropriate type corresponding to that mode. */
1757
1758 static void
1759 canonicalize_component_ref (tree *expr_p)
1760 {
1761 tree expr = *expr_p;
1762 tree type;
1763
1764 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1765
1766 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1767 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1768 else
1769 type = TREE_TYPE (TREE_OPERAND (expr, 1));
1770
1771 /* One could argue that all the stuff below is not necessary for
1772 the non-bitfield case and declare it a FE error if type
1773 adjustment would be needed. */
1774 if (TREE_TYPE (expr) != type)
1775 {
1776 #ifdef ENABLE_TYPES_CHECKING
1777 tree old_type = TREE_TYPE (expr);
1778 #endif
1779 int type_quals;
1780
1781 /* We need to preserve qualifiers and propagate them from
1782 operand 0. */
1783 type_quals = TYPE_QUALS (type)
1784 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1785 if (TYPE_QUALS (type) != type_quals)
1786 type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1787
1788 /* Set the type of the COMPONENT_REF to the underlying type. */
1789 TREE_TYPE (expr) = type;
1790
1791 #ifdef ENABLE_TYPES_CHECKING
1792 /* It is now a FE error, if the conversion from the canonical
1793 type to the original expression type is not useless. */
1794 gcc_assert (useless_type_conversion_p (old_type, type));
1795 #endif
1796 }
1797 }
1798
1799 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1800 to foo, embed that change in the ADDR_EXPR by converting
1801 T array[U];
1802 (T *)&array
1803 ==>
1804 &array[L]
1805 where L is the lower bound. For simplicity, only do this for constant
1806 lower bound.
1807 The constraint is that the type of &array[L] is trivially convertible
1808 to T *. */
1809
1810 static void
1811 canonicalize_addr_expr (tree *expr_p)
1812 {
1813 tree expr = *expr_p;
1814 tree addr_expr = TREE_OPERAND (expr, 0);
1815 tree datype, ddatype, pddatype;
1816
1817 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1818 if (!POINTER_TYPE_P (TREE_TYPE (expr))
1819 || TREE_CODE (addr_expr) != ADDR_EXPR)
1820 return;
1821
1822 /* The addr_expr type should be a pointer to an array. */
1823 datype = TREE_TYPE (TREE_TYPE (addr_expr));
1824 if (TREE_CODE (datype) != ARRAY_TYPE)
1825 return;
1826
1827 /* The pointer to element type shall be trivially convertible to
1828 the expression pointer type. */
1829 ddatype = TREE_TYPE (datype);
1830 pddatype = build_pointer_type (ddatype);
1831 if (!useless_type_conversion_p (pddatype, ddatype))
1832 return;
1833
1834 /* The lower bound and element sizes must be constant. */
1835 if (!TYPE_SIZE_UNIT (ddatype)
1836 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1837 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1838 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1839 return;
1840
1841 /* All checks succeeded. Build a new node to merge the cast. */
1842 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1843 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1844 NULL_TREE, NULL_TREE);
1845 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1846 }
1847
1848 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1849 underneath as appropriate. */
1850
1851 static enum gimplify_status
1852 gimplify_conversion (tree *expr_p)
1853 {
1854 tree tem;
1855 gcc_assert (CONVERT_EXPR_P (*expr_p));
1856
1857 /* Then strip away all but the outermost conversion. */
1858 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1859
1860 /* And remove the outermost conversion if it's useless. */
1861 if (tree_ssa_useless_type_conversion (*expr_p))
1862 *expr_p = TREE_OPERAND (*expr_p, 0);
1863
1864 /* Attempt to avoid NOP_EXPR by producing reference to a subtype.
1865 For example this fold (subclass *)&A into &A->subclass avoiding
1866 a need for statement. */
1867 if (CONVERT_EXPR_P (*expr_p)
1868 && POINTER_TYPE_P (TREE_TYPE (*expr_p))
1869 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0)))
1870 && (tem = maybe_fold_offset_to_address
1871 (TREE_OPERAND (*expr_p, 0),
1872 integer_zero_node, TREE_TYPE (*expr_p))) != NULL_TREE)
1873 *expr_p = tem;
1874
1875 /* If we still have a conversion at the toplevel,
1876 then canonicalize some constructs. */
1877 if (CONVERT_EXPR_P (*expr_p))
1878 {
1879 tree sub = TREE_OPERAND (*expr_p, 0);
1880
1881 /* If a NOP conversion is changing the type of a COMPONENT_REF
1882 expression, then canonicalize its type now in order to expose more
1883 redundant conversions. */
1884 if (TREE_CODE (sub) == COMPONENT_REF)
1885 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1886
1887 /* If a NOP conversion is changing a pointer to array of foo
1888 to a pointer to foo, embed that change in the ADDR_EXPR. */
1889 else if (TREE_CODE (sub) == ADDR_EXPR)
1890 canonicalize_addr_expr (expr_p);
1891 }
1892
1893 /* If we have a conversion to a non-register type force the
1894 use of a VIEW_CONVERT_EXPR instead. */
1895 if (!is_gimple_reg_type (TREE_TYPE (*expr_p)))
1896 *expr_p = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
1897 TREE_OPERAND (*expr_p, 0));
1898
1899 return GS_OK;
1900 }
1901
1902 /* Nonlocal VLAs seen in the current function. */
1903 static struct pointer_set_t *nonlocal_vlas;
1904
1905 /* Gimplify a VAR_DECL or PARM_DECL. Returns GS_OK if we expanded a
1906 DECL_VALUE_EXPR, and it's worth re-examining things. */
1907
1908 static enum gimplify_status
1909 gimplify_var_or_parm_decl (tree *expr_p)
1910 {
1911 tree decl = *expr_p;
1912
1913 /* ??? If this is a local variable, and it has not been seen in any
1914 outer BIND_EXPR, then it's probably the result of a duplicate
1915 declaration, for which we've already issued an error. It would
1916 be really nice if the front end wouldn't leak these at all.
1917 Currently the only known culprit is C++ destructors, as seen
1918 in g++.old-deja/g++.jason/binding.C. */
1919 if (TREE_CODE (decl) == VAR_DECL
1920 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1921 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1922 && decl_function_context (decl) == current_function_decl)
1923 {
1924 gcc_assert (errorcount || sorrycount);
1925 return GS_ERROR;
1926 }
1927
1928 /* When within an OpenMP context, notice uses of variables. */
1929 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1930 return GS_ALL_DONE;
1931
1932 /* If the decl is an alias for another expression, substitute it now. */
1933 if (DECL_HAS_VALUE_EXPR_P (decl))
1934 {
1935 tree value_expr = DECL_VALUE_EXPR (decl);
1936
1937 /* For referenced nonlocal VLAs add a decl for debugging purposes
1938 to the current function. */
1939 if (TREE_CODE (decl) == VAR_DECL
1940 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1941 && nonlocal_vlas != NULL
1942 && TREE_CODE (value_expr) == INDIRECT_REF
1943 && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
1944 && decl_function_context (decl) != current_function_decl)
1945 {
1946 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1947 while (ctx && ctx->region_type == ORT_WORKSHARE)
1948 ctx = ctx->outer_context;
1949 if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
1950 {
1951 tree copy = copy_node (decl), block;
1952
1953 lang_hooks.dup_lang_specific_decl (copy);
1954 SET_DECL_RTL (copy, NULL_RTX);
1955 TREE_USED (copy) = 1;
1956 block = DECL_INITIAL (current_function_decl);
1957 TREE_CHAIN (copy) = BLOCK_VARS (block);
1958 BLOCK_VARS (block) = copy;
1959 SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
1960 DECL_HAS_VALUE_EXPR_P (copy) = 1;
1961 }
1962 }
1963
1964 *expr_p = unshare_expr (value_expr);
1965 return GS_OK;
1966 }
1967
1968 return GS_ALL_DONE;
1969 }
1970
1971
1972 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1973 node *EXPR_P.
1974
1975 compound_lval
1976 : min_lval '[' val ']'
1977 | min_lval '.' ID
1978 | compound_lval '[' val ']'
1979 | compound_lval '.' ID
1980
1981 This is not part of the original SIMPLE definition, which separates
1982 array and member references, but it seems reasonable to handle them
1983 together. Also, this way we don't run into problems with union
1984 aliasing; gcc requires that for accesses through a union to alias, the
1985 union reference must be explicit, which was not always the case when we
1986 were splitting up array and member refs.
1987
1988 PRE_P points to the sequence where side effects that must happen before
1989 *EXPR_P should be stored.
1990
1991 POST_P points to the sequence where side effects that must happen after
1992 *EXPR_P should be stored. */
1993
1994 static enum gimplify_status
1995 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
1996 fallback_t fallback)
1997 {
1998 tree *p;
1999 VEC(tree,heap) *stack;
2000 enum gimplify_status ret = GS_OK, tret;
2001 int i;
2002
2003 /* Create a stack of the subexpressions so later we can walk them in
2004 order from inner to outer. */
2005 stack = VEC_alloc (tree, heap, 10);
2006
2007 /* We can handle anything that get_inner_reference can deal with. */
2008 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
2009 {
2010 restart:
2011 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2012 if (TREE_CODE (*p) == INDIRECT_REF)
2013 *p = fold_indirect_ref (*p);
2014
2015 if (handled_component_p (*p))
2016 ;
2017 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2018 additional COMPONENT_REFs. */
2019 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
2020 && gimplify_var_or_parm_decl (p) == GS_OK)
2021 goto restart;
2022 else
2023 break;
2024
2025 VEC_safe_push (tree, heap, stack, *p);
2026 }
2027
2028 gcc_assert (VEC_length (tree, stack));
2029
2030 /* Now STACK is a stack of pointers to all the refs we've walked through
2031 and P points to the innermost expression.
2032
2033 Java requires that we elaborated nodes in source order. That
2034 means we must gimplify the inner expression followed by each of
2035 the indices, in order. But we can't gimplify the inner
2036 expression until we deal with any variable bounds, sizes, or
2037 positions in order to deal with PLACEHOLDER_EXPRs.
2038
2039 So we do this in three steps. First we deal with the annotations
2040 for any variables in the components, then we gimplify the base,
2041 then we gimplify any indices, from left to right. */
2042 for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
2043 {
2044 tree t = VEC_index (tree, stack, i);
2045
2046 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2047 {
2048 /* Gimplify the low bound and element type size and put them into
2049 the ARRAY_REF. If these values are set, they have already been
2050 gimplified. */
2051 if (TREE_OPERAND (t, 2) == NULL_TREE)
2052 {
2053 tree low = unshare_expr (array_ref_low_bound (t));
2054 if (!is_gimple_min_invariant (low))
2055 {
2056 TREE_OPERAND (t, 2) = low;
2057 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2058 post_p, is_gimple_reg,
2059 fb_rvalue);
2060 ret = MIN (ret, tret);
2061 }
2062 }
2063
2064 if (!TREE_OPERAND (t, 3))
2065 {
2066 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
2067 tree elmt_size = unshare_expr (array_ref_element_size (t));
2068 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
2069
2070 /* Divide the element size by the alignment of the element
2071 type (above). */
2072 elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor);
2073
2074 if (!is_gimple_min_invariant (elmt_size))
2075 {
2076 TREE_OPERAND (t, 3) = elmt_size;
2077 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
2078 post_p, is_gimple_reg,
2079 fb_rvalue);
2080 ret = MIN (ret, tret);
2081 }
2082 }
2083 }
2084 else if (TREE_CODE (t) == COMPONENT_REF)
2085 {
2086 /* Set the field offset into T and gimplify it. */
2087 if (!TREE_OPERAND (t, 2))
2088 {
2089 tree offset = unshare_expr (component_ref_field_offset (t));
2090 tree field = TREE_OPERAND (t, 1);
2091 tree factor
2092 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
2093
2094 /* Divide the offset by its alignment. */
2095 offset = size_binop (EXACT_DIV_EXPR, offset, factor);
2096
2097 if (!is_gimple_min_invariant (offset))
2098 {
2099 TREE_OPERAND (t, 2) = offset;
2100 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2101 post_p, is_gimple_reg,
2102 fb_rvalue);
2103 ret = MIN (ret, tret);
2104 }
2105 }
2106 }
2107 }
2108
2109 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2110 so as to match the min_lval predicate. Failure to do so may result
2111 in the creation of large aggregate temporaries. */
2112 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2113 fallback | fb_lvalue);
2114 ret = MIN (ret, tret);
2115
2116 /* And finally, the indices and operands to BIT_FIELD_REF. During this
2117 loop we also remove any useless conversions. */
2118 for (; VEC_length (tree, stack) > 0; )
2119 {
2120 tree t = VEC_pop (tree, stack);
2121
2122 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2123 {
2124 /* Gimplify the dimension. */
2125 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2126 {
2127 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2128 is_gimple_val, fb_rvalue);
2129 ret = MIN (ret, tret);
2130 }
2131 }
2132 else if (TREE_CODE (t) == BIT_FIELD_REF)
2133 {
2134 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2135 is_gimple_val, fb_rvalue);
2136 ret = MIN (ret, tret);
2137 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2138 is_gimple_val, fb_rvalue);
2139 ret = MIN (ret, tret);
2140 }
2141
2142 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2143
2144 /* The innermost expression P may have originally had
2145 TREE_SIDE_EFFECTS set which would have caused all the outer
2146 expressions in *EXPR_P leading to P to also have had
2147 TREE_SIDE_EFFECTS set. */
2148 recalculate_side_effects (t);
2149 }
2150
2151 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2152 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2153 {
2154 canonicalize_component_ref (expr_p);
2155 ret = MIN (ret, GS_OK);
2156 }
2157
2158 VEC_free (tree, heap, stack);
2159
2160 return ret;
2161 }
2162
2163 /* Gimplify the self modifying expression pointed to by EXPR_P
2164 (++, --, +=, -=).
2165
2166 PRE_P points to the list where side effects that must happen before
2167 *EXPR_P should be stored.
2168
2169 POST_P points to the list where side effects that must happen after
2170 *EXPR_P should be stored.
2171
2172 WANT_VALUE is nonzero iff we want to use the value of this expression
2173 in another expression. */
2174
2175 static enum gimplify_status
2176 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2177 bool want_value)
2178 {
2179 enum tree_code code;
2180 tree lhs, lvalue, rhs, t1;
2181 gimple_seq post = NULL, *orig_post_p = post_p;
2182 bool postfix;
2183 enum tree_code arith_code;
2184 enum gimplify_status ret;
2185
2186 code = TREE_CODE (*expr_p);
2187
2188 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2189 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2190
2191 /* Prefix or postfix? */
2192 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2193 /* Faster to treat as prefix if result is not used. */
2194 postfix = want_value;
2195 else
2196 postfix = false;
2197
2198 /* For postfix, make sure the inner expression's post side effects
2199 are executed after side effects from this expression. */
2200 if (postfix)
2201 post_p = &post;
2202
2203 /* Add or subtract? */
2204 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2205 arith_code = PLUS_EXPR;
2206 else
2207 arith_code = MINUS_EXPR;
2208
2209 /* Gimplify the LHS into a GIMPLE lvalue. */
2210 lvalue = TREE_OPERAND (*expr_p, 0);
2211 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2212 if (ret == GS_ERROR)
2213 return ret;
2214
2215 /* Extract the operands to the arithmetic operation. */
2216 lhs = lvalue;
2217 rhs = TREE_OPERAND (*expr_p, 1);
2218
2219 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2220 that as the result value and in the postqueue operation. We also
2221 make sure to make lvalue a minimal lval, see
2222 gcc.c-torture/execute/20040313-1.c for an example where this matters. */
2223 if (postfix)
2224 {
2225 if (!is_gimple_min_lval (lvalue))
2226 {
2227 mark_addressable (lvalue);
2228 lvalue = build_fold_addr_expr (lvalue);
2229 gimplify_expr (&lvalue, pre_p, post_p, is_gimple_val, fb_rvalue);
2230 lvalue = build_fold_indirect_ref (lvalue);
2231 }
2232 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2233 if (ret == GS_ERROR)
2234 return ret;
2235 }
2236
2237 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2238 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2239 {
2240 rhs = fold_convert (sizetype, rhs);
2241 if (arith_code == MINUS_EXPR)
2242 rhs = fold_build1 (NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2243 arith_code = POINTER_PLUS_EXPR;
2244 }
2245
2246 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
2247
2248 if (postfix)
2249 {
2250 gimplify_assign (lvalue, t1, orig_post_p);
2251 gimplify_seq_add_seq (orig_post_p, post);
2252 *expr_p = lhs;
2253 return GS_ALL_DONE;
2254 }
2255 else
2256 {
2257 *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2258 return GS_OK;
2259 }
2260 }
2261
2262
2263 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2264
2265 static void
2266 maybe_with_size_expr (tree *expr_p)
2267 {
2268 tree expr = *expr_p;
2269 tree type = TREE_TYPE (expr);
2270 tree size;
2271
2272 /* If we've already wrapped this or the type is error_mark_node, we can't do
2273 anything. */
2274 if (TREE_CODE (expr) == WITH_SIZE_EXPR
2275 || type == error_mark_node)
2276 return;
2277
2278 /* If the size isn't known or is a constant, we have nothing to do. */
2279 size = TYPE_SIZE_UNIT (type);
2280 if (!size || TREE_CODE (size) == INTEGER_CST)
2281 return;
2282
2283 /* Otherwise, make a WITH_SIZE_EXPR. */
2284 size = unshare_expr (size);
2285 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2286 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2287 }
2288
2289
2290 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2291 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2292 the CALL_EXPR. */
2293
2294 static enum gimplify_status
2295 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location)
2296 {
2297 bool (*test) (tree);
2298 fallback_t fb;
2299
2300 /* In general, we allow lvalues for function arguments to avoid
2301 extra overhead of copying large aggregates out of even larger
2302 aggregates into temporaries only to copy the temporaries to
2303 the argument list. Make optimizers happy by pulling out to
2304 temporaries those types that fit in registers. */
2305 if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2306 test = is_gimple_val, fb = fb_rvalue;
2307 else
2308 test = is_gimple_lvalue, fb = fb_either;
2309
2310 /* If this is a variable sized type, we must remember the size. */
2311 maybe_with_size_expr (arg_p);
2312
2313 /* Make sure arguments have the same location as the function call
2314 itself. */
2315 protected_set_expr_location (*arg_p, call_location);
2316
2317 /* There is a sequence point before a function call. Side effects in
2318 the argument list must occur before the actual call. So, when
2319 gimplifying arguments, force gimplify_expr to use an internal
2320 post queue which is then appended to the end of PRE_P. */
2321 return gimplify_expr (arg_p, pre_p, NULL, test, fb);
2322 }
2323
2324
2325 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2326 WANT_VALUE is true if the result of the call is desired. */
2327
2328 static enum gimplify_status
2329 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2330 {
2331 tree fndecl, parms, p;
2332 enum gimplify_status ret;
2333 int i, nargs;
2334 gimple call;
2335 bool builtin_va_start_p = FALSE;
2336
2337 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2338
2339 /* For reliable diagnostics during inlining, it is necessary that
2340 every call_expr be annotated with file and line. */
2341 if (! EXPR_HAS_LOCATION (*expr_p))
2342 SET_EXPR_LOCATION (*expr_p, input_location);
2343
2344 /* This may be a call to a builtin function.
2345
2346 Builtin function calls may be transformed into different
2347 (and more efficient) builtin function calls under certain
2348 circumstances. Unfortunately, gimplification can muck things
2349 up enough that the builtin expanders are not aware that certain
2350 transformations are still valid.
2351
2352 So we attempt transformation/gimplification of the call before
2353 we gimplify the CALL_EXPR. At this time we do not manage to
2354 transform all calls in the same manner as the expanders do, but
2355 we do transform most of them. */
2356 fndecl = get_callee_fndecl (*expr_p);
2357 if (fndecl && DECL_BUILT_IN (fndecl))
2358 {
2359 tree new_tree = fold_call_expr (*expr_p, !want_value);
2360
2361 if (new_tree && new_tree != *expr_p)
2362 {
2363 /* There was a transformation of this call which computes the
2364 same value, but in a more efficient way. Return and try
2365 again. */
2366 *expr_p = new_tree;
2367 return GS_OK;
2368 }
2369
2370 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2371 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
2372 {
2373 builtin_va_start_p = TRUE;
2374 if (call_expr_nargs (*expr_p) < 2)
2375 {
2376 error ("too few arguments to function %<va_start%>");
2377 *expr_p = build_empty_stmt ();
2378 return GS_OK;
2379 }
2380
2381 if (fold_builtin_next_arg (*expr_p, true))
2382 {
2383 *expr_p = build_empty_stmt ();
2384 return GS_OK;
2385 }
2386 }
2387 }
2388
2389 /* There is a sequence point before the call, so any side effects in
2390 the calling expression must occur before the actual call. Force
2391 gimplify_expr to use an internal post queue. */
2392 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2393 is_gimple_call_addr, fb_rvalue);
2394
2395 nargs = call_expr_nargs (*expr_p);
2396
2397 /* Get argument types for verification. */
2398 fndecl = get_callee_fndecl (*expr_p);
2399 parms = NULL_TREE;
2400 if (fndecl)
2401 parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2402 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2403 parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2404
2405 if (fndecl && DECL_ARGUMENTS (fndecl))
2406 p = DECL_ARGUMENTS (fndecl);
2407 else if (parms)
2408 p = parms;
2409 else
2410 p = NULL_TREE;
2411 for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2412 ;
2413
2414 /* If the last argument is __builtin_va_arg_pack () and it is not
2415 passed as a named argument, decrease the number of CALL_EXPR
2416 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2417 if (!p
2418 && i < nargs
2419 && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2420 {
2421 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2422 tree last_arg_fndecl = get_callee_fndecl (last_arg);
2423
2424 if (last_arg_fndecl
2425 && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2426 && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2427 && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2428 {
2429 tree call = *expr_p;
2430
2431 --nargs;
2432 *expr_p = build_call_array (TREE_TYPE (call), CALL_EXPR_FN (call),
2433 nargs, CALL_EXPR_ARGP (call));
2434
2435 /* Copy all CALL_EXPR flags, location and block, except
2436 CALL_EXPR_VA_ARG_PACK flag. */
2437 CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2438 CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2439 CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2440 = CALL_EXPR_RETURN_SLOT_OPT (call);
2441 CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2442 CALL_CANNOT_INLINE_P (*expr_p) = CALL_CANNOT_INLINE_P (call);
2443 SET_EXPR_LOCUS (*expr_p, EXPR_LOCUS (call));
2444 TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2445
2446 /* Set CALL_EXPR_VA_ARG_PACK. */
2447 CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2448 }
2449 }
2450
2451 /* Finally, gimplify the function arguments. */
2452 if (nargs > 0)
2453 {
2454 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2455 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2456 PUSH_ARGS_REVERSED ? i-- : i++)
2457 {
2458 enum gimplify_status t;
2459
2460 /* Avoid gimplifying the second argument to va_start, which needs to
2461 be the plain PARM_DECL. */
2462 if ((i != 1) || !builtin_va_start_p)
2463 {
2464 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2465 EXPR_LOCATION (*expr_p));
2466
2467 if (t == GS_ERROR)
2468 ret = GS_ERROR;
2469 }
2470 }
2471 }
2472
2473 /* Try this again in case gimplification exposed something. */
2474 if (ret != GS_ERROR)
2475 {
2476 tree new_tree = fold_call_expr (*expr_p, !want_value);
2477
2478 if (new_tree && new_tree != *expr_p)
2479 {
2480 /* There was a transformation of this call which computes the
2481 same value, but in a more efficient way. Return and try
2482 again. */
2483 *expr_p = new_tree;
2484 return GS_OK;
2485 }
2486 }
2487 else
2488 {
2489 *expr_p = error_mark_node;
2490 return GS_ERROR;
2491 }
2492
2493 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2494 decl. This allows us to eliminate redundant or useless
2495 calls to "const" functions. */
2496 if (TREE_CODE (*expr_p) == CALL_EXPR)
2497 {
2498 int flags = call_expr_flags (*expr_p);
2499 if (flags & (ECF_CONST | ECF_PURE)
2500 /* An infinite loop is considered a side effect. */
2501 && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2502 TREE_SIDE_EFFECTS (*expr_p) = 0;
2503 }
2504
2505 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2506 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2507 form and delegate the creation of a GIMPLE_CALL to
2508 gimplify_modify_expr. This is always possible because when
2509 WANT_VALUE is true, the caller wants the result of this call into
2510 a temporary, which means that we will emit an INIT_EXPR in
2511 internal_get_tmp_var which will then be handled by
2512 gimplify_modify_expr. */
2513 if (!want_value)
2514 {
2515 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2516 have to do is replicate it as a GIMPLE_CALL tuple. */
2517 call = gimple_build_call_from_tree (*expr_p);
2518 gimplify_seq_add_stmt (pre_p, call);
2519 *expr_p = NULL_TREE;
2520 }
2521
2522 return ret;
2523 }
2524
2525 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2526 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2527
2528 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2529 condition is true or false, respectively. If null, we should generate
2530 our own to skip over the evaluation of this specific expression.
2531
2532 LOCUS is the source location of the COND_EXPR.
2533
2534 This function is the tree equivalent of do_jump.
2535
2536 shortcut_cond_r should only be called by shortcut_cond_expr. */
2537
2538 static tree
2539 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
2540 location_t locus)
2541 {
2542 tree local_label = NULL_TREE;
2543 tree t, expr = NULL;
2544
2545 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2546 retain the shortcut semantics. Just insert the gotos here;
2547 shortcut_cond_expr will append the real blocks later. */
2548 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2549 {
2550 location_t new_locus;
2551
2552 /* Turn if (a && b) into
2553
2554 if (a); else goto no;
2555 if (b) goto yes; else goto no;
2556 (no:) */
2557
2558 if (false_label_p == NULL)
2559 false_label_p = &local_label;
2560
2561 /* Keep the original source location on the first 'if'. */
2562 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
2563 append_to_statement_list (t, &expr);
2564
2565 /* Set the source location of the && on the second 'if'. */
2566 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2567 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2568 new_locus);
2569 append_to_statement_list (t, &expr);
2570 }
2571 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2572 {
2573 location_t new_locus;
2574
2575 /* Turn if (a || b) into
2576
2577 if (a) goto yes;
2578 if (b) goto yes; else goto no;
2579 (yes:) */
2580
2581 if (true_label_p == NULL)
2582 true_label_p = &local_label;
2583
2584 /* Keep the original source location on the first 'if'. */
2585 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
2586 append_to_statement_list (t, &expr);
2587
2588 /* Set the source location of the || on the second 'if'. */
2589 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2590 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2591 new_locus);
2592 append_to_statement_list (t, &expr);
2593 }
2594 else if (TREE_CODE (pred) == COND_EXPR)
2595 {
2596 location_t new_locus;
2597
2598 /* As long as we're messing with gotos, turn if (a ? b : c) into
2599 if (a)
2600 if (b) goto yes; else goto no;
2601 else
2602 if (c) goto yes; else goto no; */
2603
2604 /* Keep the original source location on the first 'if'. Set the source
2605 location of the ? on the second 'if'. */
2606 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2607 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2608 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2609 false_label_p, locus),
2610 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2611 false_label_p, new_locus));
2612 }
2613 else
2614 {
2615 expr = build3 (COND_EXPR, void_type_node, pred,
2616 build_and_jump (true_label_p),
2617 build_and_jump (false_label_p));
2618 SET_EXPR_LOCATION (expr, locus);
2619 }
2620
2621 if (local_label)
2622 {
2623 t = build1 (LABEL_EXPR, void_type_node, local_label);
2624 append_to_statement_list (t, &expr);
2625 }
2626
2627 return expr;
2628 }
2629
2630 /* Given a conditional expression EXPR with short-circuit boolean
2631 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2632 predicate appart into the equivalent sequence of conditionals. */
2633
2634 static tree
2635 shortcut_cond_expr (tree expr)
2636 {
2637 tree pred = TREE_OPERAND (expr, 0);
2638 tree then_ = TREE_OPERAND (expr, 1);
2639 tree else_ = TREE_OPERAND (expr, 2);
2640 tree true_label, false_label, end_label, t;
2641 tree *true_label_p;
2642 tree *false_label_p;
2643 bool emit_end, emit_false, jump_over_else;
2644 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2645 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2646
2647 /* First do simple transformations. */
2648 if (!else_se)
2649 {
2650 /* If there is no 'else', turn
2651 if (a && b) then c
2652 into
2653 if (a) if (b) then c. */
2654 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2655 {
2656 /* Keep the original source location on the first 'if'. */
2657 location_t locus = EXPR_HAS_LOCATION (expr)
2658 ? EXPR_LOCATION (expr) : input_location;
2659 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2660 /* Set the source location of the && on the second 'if'. */
2661 if (EXPR_HAS_LOCATION (pred))
2662 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2663 then_ = shortcut_cond_expr (expr);
2664 then_se = then_ && TREE_SIDE_EFFECTS (then_);
2665 pred = TREE_OPERAND (pred, 0);
2666 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2667 SET_EXPR_LOCATION (expr, locus);
2668 }
2669 }
2670
2671 if (!then_se)
2672 {
2673 /* If there is no 'then', turn
2674 if (a || b); else d
2675 into
2676 if (a); else if (b); else d. */
2677 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2678 {
2679 /* Keep the original source location on the first 'if'. */
2680 location_t locus = EXPR_HAS_LOCATION (expr)
2681 ? EXPR_LOCATION (expr) : input_location;
2682 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2683 /* Set the source location of the || on the second 'if'. */
2684 if (EXPR_HAS_LOCATION (pred))
2685 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2686 else_ = shortcut_cond_expr (expr);
2687 else_se = else_ && TREE_SIDE_EFFECTS (else_);
2688 pred = TREE_OPERAND (pred, 0);
2689 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2690 SET_EXPR_LOCATION (expr, locus);
2691 }
2692 }
2693
2694 /* If we're done, great. */
2695 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2696 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2697 return expr;
2698
2699 /* Otherwise we need to mess with gotos. Change
2700 if (a) c; else d;
2701 to
2702 if (a); else goto no;
2703 c; goto end;
2704 no: d; end:
2705 and recursively gimplify the condition. */
2706
2707 true_label = false_label = end_label = NULL_TREE;
2708
2709 /* If our arms just jump somewhere, hijack those labels so we don't
2710 generate jumps to jumps. */
2711
2712 if (then_
2713 && TREE_CODE (then_) == GOTO_EXPR
2714 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2715 {
2716 true_label = GOTO_DESTINATION (then_);
2717 then_ = NULL;
2718 then_se = false;
2719 }
2720
2721 if (else_
2722 && TREE_CODE (else_) == GOTO_EXPR
2723 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2724 {
2725 false_label = GOTO_DESTINATION (else_);
2726 else_ = NULL;
2727 else_se = false;
2728 }
2729
2730 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2731 if (true_label)
2732 true_label_p = &true_label;
2733 else
2734 true_label_p = NULL;
2735
2736 /* The 'else' branch also needs a label if it contains interesting code. */
2737 if (false_label || else_se)
2738 false_label_p = &false_label;
2739 else
2740 false_label_p = NULL;
2741
2742 /* If there was nothing else in our arms, just forward the label(s). */
2743 if (!then_se && !else_se)
2744 return shortcut_cond_r (pred, true_label_p, false_label_p,
2745 EXPR_HAS_LOCATION (expr)
2746 ? EXPR_LOCATION (expr) : input_location);
2747
2748 /* If our last subexpression already has a terminal label, reuse it. */
2749 if (else_se)
2750 t = expr_last (else_);
2751 else if (then_se)
2752 t = expr_last (then_);
2753 else
2754 t = NULL;
2755 if (t && TREE_CODE (t) == LABEL_EXPR)
2756 end_label = LABEL_EXPR_LABEL (t);
2757
2758 /* If we don't care about jumping to the 'else' branch, jump to the end
2759 if the condition is false. */
2760 if (!false_label_p)
2761 false_label_p = &end_label;
2762
2763 /* We only want to emit these labels if we aren't hijacking them. */
2764 emit_end = (end_label == NULL_TREE);
2765 emit_false = (false_label == NULL_TREE);
2766
2767 /* We only emit the jump over the else clause if we have to--if the
2768 then clause may fall through. Otherwise we can wind up with a
2769 useless jump and a useless label at the end of gimplified code,
2770 which will cause us to think that this conditional as a whole
2771 falls through even if it doesn't. If we then inline a function
2772 which ends with such a condition, that can cause us to issue an
2773 inappropriate warning about control reaching the end of a
2774 non-void function. */
2775 jump_over_else = block_may_fallthru (then_);
2776
2777 pred = shortcut_cond_r (pred, true_label_p, false_label_p,
2778 EXPR_HAS_LOCATION (expr)
2779 ? EXPR_LOCATION (expr) : input_location);
2780
2781 expr = NULL;
2782 append_to_statement_list (pred, &expr);
2783
2784 append_to_statement_list (then_, &expr);
2785 if (else_se)
2786 {
2787 if (jump_over_else)
2788 {
2789 tree last = expr_last (expr);
2790 t = build_and_jump (&end_label);
2791 if (EXPR_HAS_LOCATION (last))
2792 SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
2793 append_to_statement_list (t, &expr);
2794 }
2795 if (emit_false)
2796 {
2797 t = build1 (LABEL_EXPR, void_type_node, false_label);
2798 append_to_statement_list (t, &expr);
2799 }
2800 append_to_statement_list (else_, &expr);
2801 }
2802 if (emit_end && end_label)
2803 {
2804 t = build1 (LABEL_EXPR, void_type_node, end_label);
2805 append_to_statement_list (t, &expr);
2806 }
2807
2808 return expr;
2809 }
2810
2811 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2812
2813 tree
2814 gimple_boolify (tree expr)
2815 {
2816 tree type = TREE_TYPE (expr);
2817
2818 if (TREE_CODE (type) == BOOLEAN_TYPE)
2819 return expr;
2820
2821 switch (TREE_CODE (expr))
2822 {
2823 case TRUTH_AND_EXPR:
2824 case TRUTH_OR_EXPR:
2825 case TRUTH_XOR_EXPR:
2826 case TRUTH_ANDIF_EXPR:
2827 case TRUTH_ORIF_EXPR:
2828 /* Also boolify the arguments of truth exprs. */
2829 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2830 /* FALLTHRU */
2831
2832 case TRUTH_NOT_EXPR:
2833 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2834 /* FALLTHRU */
2835
2836 case EQ_EXPR: case NE_EXPR:
2837 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2838 /* These expressions always produce boolean results. */
2839 TREE_TYPE (expr) = boolean_type_node;
2840 return expr;
2841
2842 default:
2843 /* Other expressions that get here must have boolean values, but
2844 might need to be converted to the appropriate mode. */
2845 return fold_convert (boolean_type_node, expr);
2846 }
2847 }
2848
2849 /* Given a conditional expression *EXPR_P without side effects, gimplify
2850 its operands. New statements are inserted to PRE_P. */
2851
2852 static enum gimplify_status
2853 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
2854 {
2855 tree expr = *expr_p, cond;
2856 enum gimplify_status ret, tret;
2857 enum tree_code code;
2858
2859 cond = gimple_boolify (COND_EXPR_COND (expr));
2860
2861 /* We need to handle && and || specially, as their gimplification
2862 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
2863 code = TREE_CODE (cond);
2864 if (code == TRUTH_ANDIF_EXPR)
2865 TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2866 else if (code == TRUTH_ORIF_EXPR)
2867 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2868 ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
2869 COND_EXPR_COND (*expr_p) = cond;
2870
2871 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2872 is_gimple_val, fb_rvalue);
2873 ret = MIN (ret, tret);
2874 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2875 is_gimple_val, fb_rvalue);
2876
2877 return MIN (ret, tret);
2878 }
2879
2880 /* Returns true if evaluating EXPR could trap.
2881 EXPR is GENERIC, while tree_could_trap_p can be called
2882 only on GIMPLE. */
2883
2884 static bool
2885 generic_expr_could_trap_p (tree expr)
2886 {
2887 unsigned i, n;
2888
2889 if (!expr || is_gimple_val (expr))
2890 return false;
2891
2892 if (!EXPR_P (expr) || tree_could_trap_p (expr))
2893 return true;
2894
2895 n = TREE_OPERAND_LENGTH (expr);
2896 for (i = 0; i < n; i++)
2897 if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
2898 return true;
2899
2900 return false;
2901 }
2902
2903 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2904 into
2905
2906 if (p) if (p)
2907 t1 = a; a;
2908 else or else
2909 t1 = b; b;
2910 t1;
2911
2912 The second form is used when *EXPR_P is of type void.
2913
2914 PRE_P points to the list where side effects that must happen before
2915 *EXPR_P should be stored. */
2916
2917 static enum gimplify_status
2918 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
2919 {
2920 tree expr = *expr_p;
2921 tree tmp, type, arm1, arm2;
2922 enum gimplify_status ret;
2923 tree label_true, label_false, label_cont;
2924 bool have_then_clause_p, have_else_clause_p;
2925 gimple gimple_cond;
2926 enum tree_code pred_code;
2927 gimple_seq seq = NULL;
2928
2929 type = TREE_TYPE (expr);
2930
2931 /* If this COND_EXPR has a value, copy the values into a temporary within
2932 the arms. */
2933 if (! VOID_TYPE_P (type))
2934 {
2935 tree result;
2936
2937 /* If an rvalue is ok or we do not require an lvalue, avoid creating
2938 an addressable temporary. */
2939 if (((fallback & fb_rvalue)
2940 || !(fallback & fb_lvalue))
2941 && !TREE_ADDRESSABLE (type))
2942 {
2943 if (gimplify_ctxp->allow_rhs_cond_expr
2944 /* If either branch has side effects or could trap, it can't be
2945 evaluated unconditionally. */
2946 && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
2947 && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
2948 && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
2949 && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 2)))
2950 return gimplify_pure_cond_expr (expr_p, pre_p);
2951
2952 result = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
2953 ret = GS_ALL_DONE;
2954 }
2955 else
2956 {
2957 tree type = build_pointer_type (TREE_TYPE (expr));
2958
2959 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2960 TREE_OPERAND (expr, 1) =
2961 build_fold_addr_expr (TREE_OPERAND (expr, 1));
2962
2963 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2964 TREE_OPERAND (expr, 2) =
2965 build_fold_addr_expr (TREE_OPERAND (expr, 2));
2966
2967 tmp = create_tmp_var (type, "iftmp");
2968
2969 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
2970 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
2971
2972 result = build_fold_indirect_ref (tmp);
2973 }
2974
2975 /* Build the then clause, 't1 = a;'. But don't build an assignment
2976 if this branch is void; in C++ it can be, if it's a throw. */
2977 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2978 TREE_OPERAND (expr, 1)
2979 = build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 1));
2980
2981 /* Build the else clause, 't1 = b;'. */
2982 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2983 TREE_OPERAND (expr, 2)
2984 = build2 (MODIFY_EXPR, TREE_TYPE (tmp), tmp, TREE_OPERAND (expr, 2));
2985
2986 TREE_TYPE (expr) = void_type_node;
2987 recalculate_side_effects (expr);
2988
2989 /* Move the COND_EXPR to the prequeue. */
2990 gimplify_stmt (&expr, pre_p);
2991
2992 *expr_p = result;
2993 return GS_ALL_DONE;
2994 }
2995
2996 /* Make sure the condition has BOOLEAN_TYPE. */
2997 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2998
2999 /* Break apart && and || conditions. */
3000 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
3001 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
3002 {
3003 expr = shortcut_cond_expr (expr);
3004
3005 if (expr != *expr_p)
3006 {
3007 *expr_p = expr;
3008
3009 /* We can't rely on gimplify_expr to re-gimplify the expanded
3010 form properly, as cleanups might cause the target labels to be
3011 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3012 set up a conditional context. */
3013 gimple_push_condition ();
3014 gimplify_stmt (expr_p, &seq);
3015 gimple_pop_condition (pre_p);
3016 gimple_seq_add_seq (pre_p, seq);
3017
3018 return GS_ALL_DONE;
3019 }
3020 }
3021
3022 /* Now do the normal gimplification. */
3023
3024 /* Gimplify condition. */
3025 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
3026 fb_rvalue);
3027 if (ret == GS_ERROR)
3028 return GS_ERROR;
3029 gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
3030
3031 gimple_push_condition ();
3032
3033 have_then_clause_p = have_else_clause_p = false;
3034 if (TREE_OPERAND (expr, 1) != NULL
3035 && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
3036 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
3037 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
3038 == current_function_decl)
3039 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3040 have different locations, otherwise we end up with incorrect
3041 location information on the branches. */
3042 && (optimize
3043 || !EXPR_HAS_LOCATION (expr)
3044 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
3045 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
3046 {
3047 label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
3048 have_then_clause_p = true;
3049 }
3050 else
3051 label_true = create_artificial_label ();
3052 if (TREE_OPERAND (expr, 2) != NULL
3053 && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
3054 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3055 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3056 == current_function_decl)
3057 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3058 have different locations, otherwise we end up with incorrect
3059 location information on the branches. */
3060 && (optimize
3061 || !EXPR_HAS_LOCATION (expr)
3062 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3063 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3064 {
3065 label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3066 have_else_clause_p = true;
3067 }
3068 else
3069 label_false = create_artificial_label ();
3070
3071 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3072 &arm2);
3073
3074 gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
3075 label_false);
3076
3077 gimplify_seq_add_stmt (&seq, gimple_cond);
3078 label_cont = NULL_TREE;
3079 if (!have_then_clause_p)
3080 {
3081 /* For if (...) {} else { code; } put label_true after
3082 the else block. */
3083 if (TREE_OPERAND (expr, 1) == NULL_TREE
3084 && !have_else_clause_p
3085 && TREE_OPERAND (expr, 2) != NULL_TREE)
3086 label_cont = label_true;
3087 else
3088 {
3089 gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3090 have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3091 /* For if (...) { code; } else {} or
3092 if (...) { code; } else goto label; or
3093 if (...) { code; return; } else { ... }
3094 label_cont isn't needed. */
3095 if (!have_else_clause_p
3096 && TREE_OPERAND (expr, 2) != NULL_TREE
3097 && gimple_seq_may_fallthru (seq))
3098 {
3099 gimple g;
3100 label_cont = create_artificial_label ();
3101
3102 g = gimple_build_goto (label_cont);
3103
3104 /* GIMPLE_COND's are very low level; they have embedded
3105 gotos. This particular embedded goto should not be marked
3106 with the location of the original COND_EXPR, as it would
3107 correspond to the COND_EXPR's condition, not the ELSE or the
3108 THEN arms. To avoid marking it with the wrong location, flag
3109 it as "no location". */
3110 gimple_set_do_not_emit_location (g);
3111
3112 gimplify_seq_add_stmt (&seq, g);
3113 }
3114 }
3115 }
3116 if (!have_else_clause_p)
3117 {
3118 gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3119 have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3120 }
3121 if (label_cont)
3122 gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3123
3124 gimple_pop_condition (pre_p);
3125 gimple_seq_add_seq (pre_p, seq);
3126
3127 if (ret == GS_ERROR)
3128 ; /* Do nothing. */
3129 else if (have_then_clause_p || have_else_clause_p)
3130 ret = GS_ALL_DONE;
3131 else
3132 {
3133 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3134 expr = TREE_OPERAND (expr, 0);
3135 gimplify_stmt (&expr, pre_p);
3136 }
3137
3138 *expr_p = NULL;
3139 return ret;
3140 }
3141
3142 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3143 a call to __builtin_memcpy. */
3144
3145 static enum gimplify_status
3146 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3147 gimple_seq *seq_p)
3148 {
3149 tree t, to, to_ptr, from, from_ptr;
3150 gimple gs;
3151
3152 to = TREE_OPERAND (*expr_p, 0);
3153 from = TREE_OPERAND (*expr_p, 1);
3154
3155 mark_addressable (from);
3156 from_ptr = build_fold_addr_expr (from);
3157 gimplify_arg (&from_ptr, seq_p, EXPR_LOCATION (*expr_p));
3158
3159 mark_addressable (to);
3160 to_ptr = build_fold_addr_expr (to);
3161 gimplify_arg (&to_ptr, seq_p, EXPR_LOCATION (*expr_p));
3162
3163 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
3164
3165 gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3166
3167 if (want_value)
3168 {
3169 /* tmp = memcpy() */
3170 t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3171 gimple_call_set_lhs (gs, t);
3172 gimplify_seq_add_stmt (seq_p, gs);
3173
3174 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3175 return GS_ALL_DONE;
3176 }
3177
3178 gimplify_seq_add_stmt (seq_p, gs);
3179 *expr_p = NULL;
3180 return GS_ALL_DONE;
3181 }
3182
3183 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3184 a call to __builtin_memset. In this case we know that the RHS is
3185 a CONSTRUCTOR with an empty element list. */
3186
3187 static enum gimplify_status
3188 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3189 gimple_seq *seq_p)
3190 {
3191 tree t, from, to, to_ptr;
3192 gimple gs;
3193
3194 /* Assert our assumptions, to abort instead of producing wrong code
3195 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3196 not be immediately exposed. */
3197 from = TREE_OPERAND (*expr_p, 1);
3198 if (TREE_CODE (from) == WITH_SIZE_EXPR)
3199 from = TREE_OPERAND (from, 0);
3200
3201 gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3202 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
3203
3204 /* Now proceed. */
3205 to = TREE_OPERAND (*expr_p, 0);
3206
3207 to_ptr = build_fold_addr_expr (to);
3208 gimplify_arg (&to_ptr, seq_p, EXPR_LOCATION (*expr_p));
3209 t = implicit_built_in_decls[BUILT_IN_MEMSET];
3210
3211 gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3212
3213 if (want_value)
3214 {
3215 /* tmp = memset() */
3216 t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3217 gimple_call_set_lhs (gs, t);
3218 gimplify_seq_add_stmt (seq_p, gs);
3219
3220 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3221 return GS_ALL_DONE;
3222 }
3223
3224 gimplify_seq_add_stmt (seq_p, gs);
3225 *expr_p = NULL;
3226 return GS_ALL_DONE;
3227 }
3228
3229 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3230 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3231 assignment. Returns non-null if we detect a potential overlap. */
3232
3233 struct gimplify_init_ctor_preeval_data
3234 {
3235 /* The base decl of the lhs object. May be NULL, in which case we
3236 have to assume the lhs is indirect. */
3237 tree lhs_base_decl;
3238
3239 /* The alias set of the lhs object. */
3240 alias_set_type lhs_alias_set;
3241 };
3242
3243 static tree
3244 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3245 {
3246 struct gimplify_init_ctor_preeval_data *data
3247 = (struct gimplify_init_ctor_preeval_data *) xdata;
3248 tree t = *tp;
3249
3250 /* If we find the base object, obviously we have overlap. */
3251 if (data->lhs_base_decl == t)
3252 return t;
3253
3254 /* If the constructor component is indirect, determine if we have a
3255 potential overlap with the lhs. The only bits of information we
3256 have to go on at this point are addressability and alias sets. */
3257 if (TREE_CODE (t) == INDIRECT_REF
3258 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3259 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3260 return t;
3261
3262 /* If the constructor component is a call, determine if it can hide a
3263 potential overlap with the lhs through an INDIRECT_REF like above. */
3264 if (TREE_CODE (t) == CALL_EXPR)
3265 {
3266 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3267
3268 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3269 if (POINTER_TYPE_P (TREE_VALUE (type))
3270 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3271 && alias_sets_conflict_p (data->lhs_alias_set,
3272 get_alias_set
3273 (TREE_TYPE (TREE_VALUE (type)))))
3274 return t;
3275 }
3276
3277 if (IS_TYPE_OR_DECL_P (t))
3278 *walk_subtrees = 0;
3279 return NULL;
3280 }
3281
3282 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3283 force values that overlap with the lhs (as described by *DATA)
3284 into temporaries. */
3285
3286 static void
3287 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3288 struct gimplify_init_ctor_preeval_data *data)
3289 {
3290 enum gimplify_status one;
3291
3292 /* If the value is constant, then there's nothing to pre-evaluate. */
3293 if (TREE_CONSTANT (*expr_p))
3294 {
3295 /* Ensure it does not have side effects, it might contain a reference to
3296 the object we're initializing. */
3297 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3298 return;
3299 }
3300
3301 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3302 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3303 return;
3304
3305 /* Recurse for nested constructors. */
3306 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3307 {
3308 unsigned HOST_WIDE_INT ix;
3309 constructor_elt *ce;
3310 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
3311
3312 for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
3313 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3314
3315 return;
3316 }
3317
3318 /* If this is a variable sized type, we must remember the size. */
3319 maybe_with_size_expr (expr_p);
3320
3321 /* Gimplify the constructor element to something appropriate for the rhs
3322 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3323 the gimplifier will consider this a store to memory. Doing this
3324 gimplification now means that we won't have to deal with complicated
3325 language-specific trees, nor trees like SAVE_EXPR that can induce
3326 exponential search behavior. */
3327 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3328 if (one == GS_ERROR)
3329 {
3330 *expr_p = NULL;
3331 return;
3332 }
3333
3334 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3335 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3336 always be true for all scalars, since is_gimple_mem_rhs insists on a
3337 temporary variable for them. */
3338 if (DECL_P (*expr_p))
3339 return;
3340
3341 /* If this is of variable size, we have no choice but to assume it doesn't
3342 overlap since we can't make a temporary for it. */
3343 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3344 return;
3345
3346 /* Otherwise, we must search for overlap ... */
3347 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3348 return;
3349
3350 /* ... and if found, force the value into a temporary. */
3351 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3352 }
3353
3354 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3355 a RANGE_EXPR in a CONSTRUCTOR for an array.
3356
3357 var = lower;
3358 loop_entry:
3359 object[var] = value;
3360 if (var == upper)
3361 goto loop_exit;
3362 var = var + 1;
3363 goto loop_entry;
3364 loop_exit:
3365
3366 We increment var _after_ the loop exit check because we might otherwise
3367 fail if upper == TYPE_MAX_VALUE (type for upper).
3368
3369 Note that we never have to deal with SAVE_EXPRs here, because this has
3370 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3371
3372 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
3373 gimple_seq *, bool);
3374
3375 static void
3376 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3377 tree value, tree array_elt_type,
3378 gimple_seq *pre_p, bool cleared)
3379 {
3380 tree loop_entry_label, loop_exit_label, fall_thru_label;
3381 tree var, var_type, cref, tmp;
3382
3383 loop_entry_label = create_artificial_label ();
3384 loop_exit_label = create_artificial_label ();
3385 fall_thru_label = create_artificial_label ();
3386
3387 /* Create and initialize the index variable. */
3388 var_type = TREE_TYPE (upper);
3389 var = create_tmp_var (var_type, NULL);
3390 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3391
3392 /* Add the loop entry label. */
3393 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3394
3395 /* Build the reference. */
3396 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3397 var, NULL_TREE, NULL_TREE);
3398
3399 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3400 the store. Otherwise just assign value to the reference. */
3401
3402 if (TREE_CODE (value) == CONSTRUCTOR)
3403 /* NB we might have to call ourself recursively through
3404 gimplify_init_ctor_eval if the value is a constructor. */
3405 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3406 pre_p, cleared);
3407 else
3408 gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3409
3410 /* We exit the loop when the index var is equal to the upper bound. */
3411 gimplify_seq_add_stmt (pre_p,
3412 gimple_build_cond (EQ_EXPR, var, upper,
3413 loop_exit_label, fall_thru_label));
3414
3415 gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3416
3417 /* Otherwise, increment the index var... */
3418 tmp = build2 (PLUS_EXPR, var_type, var,
3419 fold_convert (var_type, integer_one_node));
3420 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3421
3422 /* ...and jump back to the loop entry. */
3423 gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3424
3425 /* Add the loop exit label. */
3426 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3427 }
3428
3429 /* Return true if FDECL is accessing a field that is zero sized. */
3430
3431 static bool
3432 zero_sized_field_decl (const_tree fdecl)
3433 {
3434 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3435 && integer_zerop (DECL_SIZE (fdecl)))
3436 return true;
3437 return false;
3438 }
3439
3440 /* Return true if TYPE is zero sized. */
3441
3442 static bool
3443 zero_sized_type (const_tree type)
3444 {
3445 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3446 && integer_zerop (TYPE_SIZE (type)))
3447 return true;
3448 return false;
3449 }
3450
3451 /* A subroutine of gimplify_init_constructor. Generate individual
3452 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3453 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3454 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3455 zeroed first. */
3456
3457 static void
3458 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3459 gimple_seq *pre_p, bool cleared)
3460 {
3461 tree array_elt_type = NULL;
3462 unsigned HOST_WIDE_INT ix;
3463 tree purpose, value;
3464
3465 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3466 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3467
3468 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3469 {
3470 tree cref;
3471
3472 /* NULL values are created above for gimplification errors. */
3473 if (value == NULL)
3474 continue;
3475
3476 if (cleared && initializer_zerop (value))
3477 continue;
3478
3479 /* ??? Here's to hoping the front end fills in all of the indices,
3480 so we don't have to figure out what's missing ourselves. */
3481 gcc_assert (purpose);
3482
3483 /* Skip zero-sized fields, unless value has side-effects. This can
3484 happen with calls to functions returning a zero-sized type, which
3485 we shouldn't discard. As a number of downstream passes don't
3486 expect sets of zero-sized fields, we rely on the gimplification of
3487 the MODIFY_EXPR we make below to drop the assignment statement. */
3488 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3489 continue;
3490
3491 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3492 whole range. */
3493 if (TREE_CODE (purpose) == RANGE_EXPR)
3494 {
3495 tree lower = TREE_OPERAND (purpose, 0);
3496 tree upper = TREE_OPERAND (purpose, 1);
3497
3498 /* If the lower bound is equal to upper, just treat it as if
3499 upper was the index. */
3500 if (simple_cst_equal (lower, upper))
3501 purpose = upper;
3502 else
3503 {
3504 gimplify_init_ctor_eval_range (object, lower, upper, value,
3505 array_elt_type, pre_p, cleared);
3506 continue;
3507 }
3508 }
3509
3510 if (array_elt_type)
3511 {
3512 /* Do not use bitsizetype for ARRAY_REF indices. */
3513 if (TYPE_DOMAIN (TREE_TYPE (object)))
3514 purpose = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3515 purpose);
3516 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3517 purpose, NULL_TREE, NULL_TREE);
3518 }
3519 else
3520 {
3521 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3522 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3523 unshare_expr (object), purpose, NULL_TREE);
3524 }
3525
3526 if (TREE_CODE (value) == CONSTRUCTOR
3527 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3528 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3529 pre_p, cleared);
3530 else
3531 {
3532 tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3533 gimplify_and_add (init, pre_p);
3534 ggc_free (init);
3535 }
3536 }
3537 }
3538
3539
3540 /* Returns the appropriate RHS predicate for this LHS. */
3541
3542 gimple_predicate
3543 rhs_predicate_for (tree lhs)
3544 {
3545 if (is_gimple_reg (lhs))
3546 return is_gimple_reg_rhs_or_call;
3547 else
3548 return is_gimple_mem_rhs_or_call;
3549 }
3550
3551 /* Gimplify a C99 compound literal expression. This just means adding
3552 the DECL_EXPR before the current statement and using its anonymous
3553 decl instead. */
3554
3555 static enum gimplify_status
3556 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p)
3557 {
3558 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
3559 tree decl = DECL_EXPR_DECL (decl_s);
3560 /* Mark the decl as addressable if the compound literal
3561 expression is addressable now, otherwise it is marked too late
3562 after we gimplify the initialization expression. */
3563 if (TREE_ADDRESSABLE (*expr_p))
3564 TREE_ADDRESSABLE (decl) = 1;
3565
3566 /* Preliminarily mark non-addressed complex variables as eligible
3567 for promotion to gimple registers. We'll transform their uses
3568 as we find them. */
3569 if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
3570 || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
3571 && !TREE_THIS_VOLATILE (decl)
3572 && !needs_to_live_in_memory (decl))
3573 DECL_GIMPLE_REG_P (decl) = 1;
3574
3575 /* This decl isn't mentioned in the enclosing block, so add it to the
3576 list of temps. FIXME it seems a bit of a kludge to say that
3577 anonymous artificial vars aren't pushed, but everything else is. */
3578 if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
3579 gimple_add_tmp_var (decl);
3580
3581 gimplify_and_add (decl_s, pre_p);
3582 *expr_p = decl;
3583 return GS_OK;
3584 }
3585
3586 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3587 return a new CONSTRUCTOR if something changed. */
3588
3589 static tree
3590 optimize_compound_literals_in_ctor (tree orig_ctor)
3591 {
3592 tree ctor = orig_ctor;
3593 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
3594 unsigned int idx, num = VEC_length (constructor_elt, elts);
3595
3596 for (idx = 0; idx < num; idx++)
3597 {
3598 tree value = VEC_index (constructor_elt, elts, idx)->value;
3599 tree newval = value;
3600 if (TREE_CODE (value) == CONSTRUCTOR)
3601 newval = optimize_compound_literals_in_ctor (value);
3602 else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
3603 {
3604 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
3605 tree decl = DECL_EXPR_DECL (decl_s);
3606 tree init = DECL_INITIAL (decl);
3607
3608 if (!TREE_ADDRESSABLE (value)
3609 && !TREE_ADDRESSABLE (decl)
3610 && init)
3611 newval = optimize_compound_literals_in_ctor (init);
3612 }
3613 if (newval == value)
3614 continue;
3615
3616 if (ctor == orig_ctor)
3617 {
3618 ctor = copy_node (orig_ctor);
3619 CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
3620 elts = CONSTRUCTOR_ELTS (ctor);
3621 }
3622 VEC_index (constructor_elt, elts, idx)->value = newval;
3623 }
3624 return ctor;
3625 }
3626
3627
3628
3629 /* A subroutine of gimplify_modify_expr. Break out elements of a
3630 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3631
3632 Note that we still need to clear any elements that don't have explicit
3633 initializers, so if not all elements are initialized we keep the
3634 original MODIFY_EXPR, we just remove all of the constructor elements.
3635
3636 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3637 GS_ERROR if we would have to create a temporary when gimplifying
3638 this constructor. Otherwise, return GS_OK.
3639
3640 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3641
3642 static enum gimplify_status
3643 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3644 bool want_value, bool notify_temp_creation)
3645 {
3646 tree object, ctor, type;
3647 enum gimplify_status ret;
3648 VEC(constructor_elt,gc) *elts;
3649
3650 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
3651
3652 if (!notify_temp_creation)
3653 {
3654 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3655 is_gimple_lvalue, fb_lvalue);
3656 if (ret == GS_ERROR)
3657 return ret;
3658 }
3659
3660 object = TREE_OPERAND (*expr_p, 0);
3661 ctor = TREE_OPERAND (*expr_p, 1) =
3662 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
3663 type = TREE_TYPE (ctor);
3664 elts = CONSTRUCTOR_ELTS (ctor);
3665 ret = GS_ALL_DONE;
3666
3667 switch (TREE_CODE (type))
3668 {
3669 case RECORD_TYPE:
3670 case UNION_TYPE:
3671 case QUAL_UNION_TYPE:
3672 case ARRAY_TYPE:
3673 {
3674 struct gimplify_init_ctor_preeval_data preeval_data;
3675 HOST_WIDE_INT num_type_elements, num_ctor_elements;
3676 HOST_WIDE_INT num_nonzero_elements;
3677 bool cleared, valid_const_initializer;
3678
3679 /* Aggregate types must lower constructors to initialization of
3680 individual elements. The exception is that a CONSTRUCTOR node
3681 with no elements indicates zero-initialization of the whole. */
3682 if (VEC_empty (constructor_elt, elts))
3683 {
3684 if (notify_temp_creation)
3685 return GS_OK;
3686 break;
3687 }
3688
3689 /* Fetch information about the constructor to direct later processing.
3690 We might want to make static versions of it in various cases, and
3691 can only do so if it known to be a valid constant initializer. */
3692 valid_const_initializer
3693 = categorize_ctor_elements (ctor, &num_nonzero_elements,
3694 &num_ctor_elements, &cleared);
3695
3696 /* If a const aggregate variable is being initialized, then it
3697 should never be a lose to promote the variable to be static. */
3698 if (valid_const_initializer
3699 && num_nonzero_elements > 1
3700 && TREE_READONLY (object)
3701 && TREE_CODE (object) == VAR_DECL
3702 && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
3703 {
3704 if (notify_temp_creation)
3705 return GS_ERROR;
3706 DECL_INITIAL (object) = ctor;
3707 TREE_STATIC (object) = 1;
3708 if (!DECL_NAME (object))
3709 DECL_NAME (object) = create_tmp_var_name ("C");
3710 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
3711
3712 /* ??? C++ doesn't automatically append a .<number> to the
3713 assembler name, and even when it does, it looks a FE private
3714 data structures to figure out what that number should be,
3715 which are not set for this variable. I suppose this is
3716 important for local statics for inline functions, which aren't
3717 "local" in the object file sense. So in order to get a unique
3718 TU-local symbol, we must invoke the lhd version now. */
3719 lhd_set_decl_assembler_name (object);
3720
3721 *expr_p = NULL_TREE;
3722 break;
3723 }
3724
3725 /* If there are "lots" of initialized elements, even discounting
3726 those that are not address constants (and thus *must* be
3727 computed at runtime), then partition the constructor into
3728 constant and non-constant parts. Block copy the constant
3729 parts in, then generate code for the non-constant parts. */
3730 /* TODO. There's code in cp/typeck.c to do this. */
3731
3732 num_type_elements = count_type_elements (type, true);
3733
3734 /* If count_type_elements could not determine number of type elements
3735 for a constant-sized object, assume clearing is needed.
3736 Don't do this for variable-sized objects, as store_constructor
3737 will ignore the clearing of variable-sized objects. */
3738 if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
3739 cleared = true;
3740 /* If there are "lots" of zeros, then block clear the object first. */
3741 else if (num_type_elements - num_nonzero_elements
3742 > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
3743 && num_nonzero_elements < num_type_elements/4)
3744 cleared = true;
3745 /* ??? This bit ought not be needed. For any element not present
3746 in the initializer, we should simply set them to zero. Except
3747 we'd need to *find* the elements that are not present, and that
3748 requires trickery to avoid quadratic compile-time behavior in
3749 large cases or excessive memory use in small cases. */
3750 else if (num_ctor_elements < num_type_elements)
3751 cleared = true;
3752
3753 /* If there are "lots" of initialized elements, and all of them
3754 are valid address constants, then the entire initializer can
3755 be dropped to memory, and then memcpy'd out. Don't do this
3756 for sparse arrays, though, as it's more efficient to follow
3757 the standard CONSTRUCTOR behavior of memset followed by
3758 individual element initialization. Also don't do this for small
3759 all-zero initializers (which aren't big enough to merit
3760 clearing), and don't try to make bitwise copies of
3761 TREE_ADDRESSABLE types. */
3762 if (valid_const_initializer
3763 && !(cleared || num_nonzero_elements == 0)
3764 && !TREE_ADDRESSABLE (type))
3765 {
3766 HOST_WIDE_INT size = int_size_in_bytes (type);
3767 unsigned int align;
3768
3769 /* ??? We can still get unbounded array types, at least
3770 from the C++ front end. This seems wrong, but attempt
3771 to work around it for now. */
3772 if (size < 0)
3773 {
3774 size = int_size_in_bytes (TREE_TYPE (object));
3775 if (size >= 0)
3776 TREE_TYPE (ctor) = type = TREE_TYPE (object);
3777 }
3778
3779 /* Find the maximum alignment we can assume for the object. */
3780 /* ??? Make use of DECL_OFFSET_ALIGN. */
3781 if (DECL_P (object))
3782 align = DECL_ALIGN (object);
3783 else
3784 align = TYPE_ALIGN (type);
3785
3786 if (size > 0
3787 && num_nonzero_elements > 1
3788 && !can_move_by_pieces (size, align))
3789 {
3790 tree new_tree;
3791
3792 if (notify_temp_creation)
3793 return GS_ERROR;
3794
3795 new_tree = create_tmp_var_raw (type, "C");
3796
3797 gimple_add_tmp_var (new_tree);
3798 TREE_STATIC (new_tree) = 1;
3799 TREE_READONLY (new_tree) = 1;
3800 DECL_INITIAL (new_tree) = ctor;
3801 if (align > DECL_ALIGN (new_tree))
3802 {
3803 DECL_ALIGN (new_tree) = align;
3804 DECL_USER_ALIGN (new_tree) = 1;
3805 }
3806 walk_tree (&DECL_INITIAL (new_tree), force_labels_r, NULL, NULL);
3807
3808 TREE_OPERAND (*expr_p, 1) = new_tree;
3809
3810 /* This is no longer an assignment of a CONSTRUCTOR, but
3811 we still may have processing to do on the LHS. So
3812 pretend we didn't do anything here to let that happen. */
3813 return GS_UNHANDLED;
3814 }
3815 }
3816
3817 if (notify_temp_creation)
3818 return GS_OK;
3819
3820 /* If there are nonzero elements, pre-evaluate to capture elements
3821 overlapping with the lhs into temporaries. We must do this before
3822 clearing to fetch the values before they are zeroed-out. */
3823 if (num_nonzero_elements > 0)
3824 {
3825 preeval_data.lhs_base_decl = get_base_address (object);
3826 if (!DECL_P (preeval_data.lhs_base_decl))
3827 preeval_data.lhs_base_decl = NULL;
3828 preeval_data.lhs_alias_set = get_alias_set (object);
3829
3830 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
3831 pre_p, post_p, &preeval_data);
3832 }
3833
3834 if (cleared)
3835 {
3836 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3837 Note that we still have to gimplify, in order to handle the
3838 case of variable sized types. Avoid shared tree structures. */
3839 CONSTRUCTOR_ELTS (ctor) = NULL;
3840 TREE_SIDE_EFFECTS (ctor) = 0;
3841 object = unshare_expr (object);
3842 gimplify_stmt (expr_p, pre_p);
3843 }
3844
3845 /* If we have not block cleared the object, or if there are nonzero
3846 elements in the constructor, add assignments to the individual
3847 scalar fields of the object. */
3848 if (!cleared || num_nonzero_elements > 0)
3849 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
3850
3851 *expr_p = NULL_TREE;
3852 }
3853 break;
3854
3855 case COMPLEX_TYPE:
3856 {
3857 tree r, i;
3858
3859 if (notify_temp_creation)
3860 return GS_OK;
3861
3862 /* Extract the real and imaginary parts out of the ctor. */
3863 gcc_assert (VEC_length (constructor_elt, elts) == 2);
3864 r = VEC_index (constructor_elt, elts, 0)->value;
3865 i = VEC_index (constructor_elt, elts, 1)->value;
3866 if (r == NULL || i == NULL)
3867 {
3868 tree zero = fold_convert (TREE_TYPE (type), integer_zero_node);
3869 if (r == NULL)
3870 r = zero;
3871 if (i == NULL)
3872 i = zero;
3873 }
3874
3875 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
3876 represent creation of a complex value. */
3877 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
3878 {
3879 ctor = build_complex (type, r, i);
3880 TREE_OPERAND (*expr_p, 1) = ctor;
3881 }
3882 else
3883 {
3884 ctor = build2 (COMPLEX_EXPR, type, r, i);
3885 TREE_OPERAND (*expr_p, 1) = ctor;
3886 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
3887 pre_p,
3888 post_p,
3889 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
3890 fb_rvalue);
3891 }
3892 }
3893 break;
3894
3895 case VECTOR_TYPE:
3896 {
3897 unsigned HOST_WIDE_INT ix;
3898 constructor_elt *ce;
3899
3900 if (notify_temp_creation)
3901 return GS_OK;
3902
3903 /* Go ahead and simplify constant constructors to VECTOR_CST. */
3904 if (TREE_CONSTANT (ctor))
3905 {
3906 bool constant_p = true;
3907 tree value;
3908
3909 /* Even when ctor is constant, it might contain non-*_CST
3910 elements, such as addresses or trapping values like
3911 1.0/0.0 - 1.0/0.0. Such expressions don't belong
3912 in VECTOR_CST nodes. */
3913 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
3914 if (!CONSTANT_CLASS_P (value))
3915 {
3916 constant_p = false;
3917 break;
3918 }
3919
3920 if (constant_p)
3921 {
3922 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
3923 break;
3924 }
3925
3926 /* Don't reduce an initializer constant even if we can't
3927 make a VECTOR_CST. It won't do anything for us, and it'll
3928 prevent us from representing it as a single constant. */
3929 if (initializer_constant_valid_p (ctor, type))
3930 break;
3931
3932 TREE_CONSTANT (ctor) = 0;
3933 }
3934
3935 /* Vector types use CONSTRUCTOR all the way through gimple
3936 compilation as a general initializer. */
3937 for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++)
3938 {
3939 enum gimplify_status tret;
3940 tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
3941 fb_rvalue);
3942 if (tret == GS_ERROR)
3943 ret = GS_ERROR;
3944 }
3945 if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
3946 TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
3947 }
3948 break;
3949
3950 default:
3951 /* So how did we get a CONSTRUCTOR for a scalar type? */
3952 gcc_unreachable ();
3953 }
3954
3955 if (ret == GS_ERROR)
3956 return GS_ERROR;
3957 else if (want_value)
3958 {
3959 *expr_p = object;
3960 return GS_OK;
3961 }
3962 else
3963 {
3964 /* If we have gimplified both sides of the initializer but have
3965 not emitted an assignment, do so now. */
3966 if (*expr_p)
3967 {
3968 tree lhs = TREE_OPERAND (*expr_p, 0);
3969 tree rhs = TREE_OPERAND (*expr_p, 1);
3970 gimple init = gimple_build_assign (lhs, rhs);
3971 gimplify_seq_add_stmt (pre_p, init);
3972 *expr_p = NULL;
3973 }
3974
3975 return GS_ALL_DONE;
3976 }
3977 }
3978
3979 /* Given a pointer value OP0, return a simplified version of an
3980 indirection through OP0, or NULL_TREE if no simplification is
3981 possible. Note that the resulting type may be different from
3982 the type pointed to in the sense that it is still compatible
3983 from the langhooks point of view. */
3984
3985 tree
3986 gimple_fold_indirect_ref (tree t)
3987 {
3988 tree type = TREE_TYPE (TREE_TYPE (t));
3989 tree sub = t;
3990 tree subtype;
3991
3992 STRIP_USELESS_TYPE_CONVERSION (sub);
3993 subtype = TREE_TYPE (sub);
3994 if (!POINTER_TYPE_P (subtype))
3995 return NULL_TREE;
3996
3997 if (TREE_CODE (sub) == ADDR_EXPR)
3998 {
3999 tree op = TREE_OPERAND (sub, 0);
4000 tree optype = TREE_TYPE (op);
4001 /* *&p => p */
4002 if (useless_type_conversion_p (type, optype))
4003 return op;
4004
4005 /* *(foo *)&fooarray => fooarray[0] */
4006 if (TREE_CODE (optype) == ARRAY_TYPE
4007 && useless_type_conversion_p (type, TREE_TYPE (optype)))
4008 {
4009 tree type_domain = TYPE_DOMAIN (optype);
4010 tree min_val = size_zero_node;
4011 if (type_domain && TYPE_MIN_VALUE (type_domain))
4012 min_val = TYPE_MIN_VALUE (type_domain);
4013 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
4014 }
4015 }
4016
4017 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
4018 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
4019 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (subtype))))
4020 {
4021 tree type_domain;
4022 tree min_val = size_zero_node;
4023 tree osub = sub;
4024 sub = gimple_fold_indirect_ref (sub);
4025 if (! sub)
4026 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
4027 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
4028 if (type_domain && TYPE_MIN_VALUE (type_domain))
4029 min_val = TYPE_MIN_VALUE (type_domain);
4030 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
4031 }
4032
4033 return NULL_TREE;
4034 }
4035
4036 /* Given a pointer value OP0, return a simplified version of an
4037 indirection through OP0, or NULL_TREE if no simplification is
4038 possible. This may only be applied to a rhs of an expression.
4039 Note that the resulting type may be different from the type pointed
4040 to in the sense that it is still compatible from the langhooks
4041 point of view. */
4042
4043 static tree
4044 gimple_fold_indirect_ref_rhs (tree t)
4045 {
4046 return gimple_fold_indirect_ref (t);
4047 }
4048
4049 /* Subroutine of gimplify_modify_expr to do simplifications of
4050 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4051 something changes. */
4052
4053 static enum gimplify_status
4054 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p,
4055 gimple_seq *pre_p, gimple_seq *post_p,
4056 bool want_value)
4057 {
4058 enum gimplify_status ret = GS_OK;
4059
4060 while (ret != GS_UNHANDLED)
4061 switch (TREE_CODE (*from_p))
4062 {
4063 case VAR_DECL:
4064 /* If we're assigning from a read-only variable initialized with
4065 a constructor, do the direct assignment from the constructor,
4066 but only if neither source nor target are volatile since this
4067 latter assignment might end up being done on a per-field basis. */
4068 if (DECL_INITIAL (*from_p)
4069 && TREE_READONLY (*from_p)
4070 && !TREE_THIS_VOLATILE (*from_p)
4071 && !TREE_THIS_VOLATILE (*to_p)
4072 && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
4073 {
4074 tree old_from = *from_p;
4075
4076 /* Move the constructor into the RHS. */
4077 *from_p = unshare_expr (DECL_INITIAL (*from_p));
4078
4079 /* Let's see if gimplify_init_constructor will need to put
4080 it in memory. If so, revert the change. */
4081 ret = gimplify_init_constructor (expr_p, NULL, NULL, false, true);
4082 if (ret == GS_ERROR)
4083 {
4084 *from_p = old_from;
4085 /* Fall through. */
4086 }
4087 else
4088 {
4089 ret = GS_OK;
4090 break;
4091 }
4092 }
4093 ret = GS_UNHANDLED;
4094 break;
4095 case INDIRECT_REF:
4096 {
4097 /* If we have code like
4098
4099 *(const A*)(A*)&x
4100
4101 where the type of "x" is a (possibly cv-qualified variant
4102 of "A"), treat the entire expression as identical to "x".
4103 This kind of code arises in C++ when an object is bound
4104 to a const reference, and if "x" is a TARGET_EXPR we want
4105 to take advantage of the optimization below. */
4106 tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
4107 if (t)
4108 {
4109 *from_p = t;
4110 ret = GS_OK;
4111 }
4112 else
4113 ret = GS_UNHANDLED;
4114 break;
4115 }
4116
4117 case TARGET_EXPR:
4118 {
4119 /* If we are initializing something from a TARGET_EXPR, strip the
4120 TARGET_EXPR and initialize it directly, if possible. This can't
4121 be done if the initializer is void, since that implies that the
4122 temporary is set in some non-trivial way.
4123
4124 ??? What about code that pulls out the temp and uses it
4125 elsewhere? I think that such code never uses the TARGET_EXPR as
4126 an initializer. If I'm wrong, we'll die because the temp won't
4127 have any RTL. In that case, I guess we'll need to replace
4128 references somehow. */
4129 tree init = TARGET_EXPR_INITIAL (*from_p);
4130
4131 if (init
4132 && !VOID_TYPE_P (TREE_TYPE (init)))
4133 {
4134 *from_p = init;
4135 ret = GS_OK;
4136 }
4137 else
4138 ret = GS_UNHANDLED;
4139 }
4140 break;
4141
4142 case COMPOUND_EXPR:
4143 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4144 caught. */
4145 gimplify_compound_expr (from_p, pre_p, true);
4146 ret = GS_OK;
4147 break;
4148
4149 case CONSTRUCTOR:
4150 /* If we're initializing from a CONSTRUCTOR, break this into
4151 individual MODIFY_EXPRs. */
4152 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
4153 false);
4154
4155 case COND_EXPR:
4156 /* If we're assigning to a non-register type, push the assignment
4157 down into the branches. This is mandatory for ADDRESSABLE types,
4158 since we cannot generate temporaries for such, but it saves a
4159 copy in other cases as well. */
4160 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
4161 {
4162 /* This code should mirror the code in gimplify_cond_expr. */
4163 enum tree_code code = TREE_CODE (*expr_p);
4164 tree cond = *from_p;
4165 tree result = *to_p;
4166
4167 ret = gimplify_expr (&result, pre_p, post_p,
4168 is_gimple_lvalue, fb_lvalue);
4169 if (ret != GS_ERROR)
4170 ret = GS_OK;
4171
4172 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
4173 TREE_OPERAND (cond, 1)
4174 = build2 (code, void_type_node, result,
4175 TREE_OPERAND (cond, 1));
4176 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
4177 TREE_OPERAND (cond, 2)
4178 = build2 (code, void_type_node, unshare_expr (result),
4179 TREE_OPERAND (cond, 2));
4180
4181 TREE_TYPE (cond) = void_type_node;
4182 recalculate_side_effects (cond);
4183
4184 if (want_value)
4185 {
4186 gimplify_and_add (cond, pre_p);
4187 *expr_p = unshare_expr (result);
4188 }
4189 else
4190 *expr_p = cond;
4191 return ret;
4192 }
4193 else
4194 ret = GS_UNHANDLED;
4195 break;
4196
4197 case CALL_EXPR:
4198 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4199 return slot so that we don't generate a temporary. */
4200 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
4201 && aggregate_value_p (*from_p, *from_p))
4202 {
4203 bool use_target;
4204
4205 if (!(rhs_predicate_for (*to_p))(*from_p))
4206 /* If we need a temporary, *to_p isn't accurate. */
4207 use_target = false;
4208 else if (TREE_CODE (*to_p) == RESULT_DECL
4209 && DECL_NAME (*to_p) == NULL_TREE
4210 && needs_to_live_in_memory (*to_p))
4211 /* It's OK to use the return slot directly unless it's an NRV. */
4212 use_target = true;
4213 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
4214 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
4215 /* Don't force regs into memory. */
4216 use_target = false;
4217 else if (TREE_CODE (*expr_p) == INIT_EXPR)
4218 /* It's OK to use the target directly if it's being
4219 initialized. */
4220 use_target = true;
4221 else if (!is_gimple_non_addressable (*to_p))
4222 /* Don't use the original target if it's already addressable;
4223 if its address escapes, and the called function uses the
4224 NRV optimization, a conforming program could see *to_p
4225 change before the called function returns; see c++/19317.
4226 When optimizing, the return_slot pass marks more functions
4227 as safe after we have escape info. */
4228 use_target = false;
4229 else
4230 use_target = true;
4231
4232 if (use_target)
4233 {
4234 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
4235 mark_addressable (*to_p);
4236 }
4237 }
4238
4239 ret = GS_UNHANDLED;
4240 break;
4241
4242 /* If we're initializing from a container, push the initialization
4243 inside it. */
4244 case CLEANUP_POINT_EXPR:
4245 case BIND_EXPR:
4246 case STATEMENT_LIST:
4247 {
4248 tree wrap = *from_p;
4249 tree t;
4250
4251 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
4252 fb_lvalue);
4253 if (ret != GS_ERROR)
4254 ret = GS_OK;
4255
4256 t = voidify_wrapper_expr (wrap, *expr_p);
4257 gcc_assert (t == *expr_p);
4258
4259 if (want_value)
4260 {
4261 gimplify_and_add (wrap, pre_p);
4262 *expr_p = unshare_expr (*to_p);
4263 }
4264 else
4265 *expr_p = wrap;
4266 return GS_OK;
4267 }
4268
4269 case COMPOUND_LITERAL_EXPR:
4270 {
4271 tree complit = TREE_OPERAND (*expr_p, 1);
4272 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
4273 tree decl = DECL_EXPR_DECL (decl_s);
4274 tree init = DECL_INITIAL (decl);
4275
4276 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4277 into struct T x = { 0, 1, 2 } if the address of the
4278 compound literal has never been taken. */
4279 if (!TREE_ADDRESSABLE (complit)
4280 && !TREE_ADDRESSABLE (decl)
4281 && init)
4282 {
4283 *expr_p = copy_node (*expr_p);
4284 TREE_OPERAND (*expr_p, 1) = init;
4285 return GS_OK;
4286 }
4287 }
4288
4289 default:
4290 ret = GS_UNHANDLED;
4291 break;
4292 }
4293
4294 return ret;
4295 }
4296
4297
4298 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4299 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4300 DECL_GIMPLE_REG_P set.
4301
4302 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4303 other, unmodified part of the complex object just before the total store.
4304 As a consequence, if the object is still uninitialized, an undefined value
4305 will be loaded into a register, which may result in a spurious exception
4306 if the register is floating-point and the value happens to be a signaling
4307 NaN for example. Then the fully-fledged complex operations lowering pass
4308 followed by a DCE pass are necessary in order to fix things up. */
4309
4310 static enum gimplify_status
4311 gimplify_modify_expr_complex_part (tree *expr_p, gimple_seq *pre_p,
4312 bool want_value)
4313 {
4314 enum tree_code code, ocode;
4315 tree lhs, rhs, new_rhs, other, realpart, imagpart;
4316
4317 lhs = TREE_OPERAND (*expr_p, 0);
4318 rhs = TREE_OPERAND (*expr_p, 1);
4319 code = TREE_CODE (lhs);
4320 lhs = TREE_OPERAND (lhs, 0);
4321
4322 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
4323 other = build1 (ocode, TREE_TYPE (rhs), lhs);
4324 other = get_formal_tmp_var (other, pre_p);
4325
4326 realpart = code == REALPART_EXPR ? rhs : other;
4327 imagpart = code == REALPART_EXPR ? other : rhs;
4328
4329 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
4330 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
4331 else
4332 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
4333
4334 gimplify_seq_add_stmt (pre_p, gimple_build_assign (lhs, new_rhs));
4335 *expr_p = (want_value) ? rhs : NULL_TREE;
4336
4337 return GS_ALL_DONE;
4338 }
4339
4340
4341 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4342
4343 modify_expr
4344 : varname '=' rhs
4345 | '*' ID '=' rhs
4346
4347 PRE_P points to the list where side effects that must happen before
4348 *EXPR_P should be stored.
4349
4350 POST_P points to the list where side effects that must happen after
4351 *EXPR_P should be stored.
4352
4353 WANT_VALUE is nonzero iff we want to use the value of this expression
4354 in another expression. */
4355
4356 static enum gimplify_status
4357 gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
4358 bool want_value)
4359 {
4360 tree *from_p = &TREE_OPERAND (*expr_p, 1);
4361 tree *to_p = &TREE_OPERAND (*expr_p, 0);
4362 enum gimplify_status ret = GS_UNHANDLED;
4363 gimple assign;
4364
4365 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
4366 || TREE_CODE (*expr_p) == INIT_EXPR);
4367
4368 /* Insert pointer conversions required by the middle-end that are not
4369 required by the frontend. This fixes middle-end type checking for
4370 for example gcc.dg/redecl-6.c. */
4371 if (POINTER_TYPE_P (TREE_TYPE (*to_p))
4372 && lang_hooks.types_compatible_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
4373 {
4374 STRIP_USELESS_TYPE_CONVERSION (*from_p);
4375 if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
4376 *from_p = fold_convert (TREE_TYPE (*to_p), *from_p);
4377 }
4378
4379 /* See if any simplifications can be done based on what the RHS is. */
4380 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
4381 want_value);
4382 if (ret != GS_UNHANDLED)
4383 return ret;
4384
4385 /* For zero sized types only gimplify the left hand side and right hand
4386 side as statements and throw away the assignment. Do this after
4387 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4388 types properly. */
4389 if (zero_sized_type (TREE_TYPE (*from_p)) && !want_value)
4390 {
4391 gimplify_stmt (from_p, pre_p);
4392 gimplify_stmt (to_p, pre_p);
4393 *expr_p = NULL_TREE;
4394 return GS_ALL_DONE;
4395 }
4396
4397 /* If the value being copied is of variable width, compute the length
4398 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4399 before gimplifying any of the operands so that we can resolve any
4400 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4401 the size of the expression to be copied, not of the destination, so
4402 that is what we must do here. */
4403 maybe_with_size_expr (from_p);
4404
4405 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
4406 if (ret == GS_ERROR)
4407 return ret;
4408
4409 /* As a special case, we have to temporarily allow for assignments
4410 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4411 a toplevel statement, when gimplifying the GENERIC expression
4412 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4413 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4414
4415 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4416 prevent gimplify_expr from trying to create a new temporary for
4417 foo's LHS, we tell it that it should only gimplify until it
4418 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4419 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4420 and all we need to do here is set 'a' to be its LHS. */
4421 ret = gimplify_expr (from_p, pre_p, post_p, rhs_predicate_for (*to_p),
4422 fb_rvalue);
4423 if (ret == GS_ERROR)
4424 return ret;
4425
4426 /* Now see if the above changed *from_p to something we handle specially. */
4427 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
4428 want_value);
4429 if (ret != GS_UNHANDLED)
4430 return ret;
4431
4432 /* If we've got a variable sized assignment between two lvalues (i.e. does
4433 not involve a call), then we can make things a bit more straightforward
4434 by converting the assignment to memcpy or memset. */
4435 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
4436 {
4437 tree from = TREE_OPERAND (*from_p, 0);
4438 tree size = TREE_OPERAND (*from_p, 1);
4439
4440 if (TREE_CODE (from) == CONSTRUCTOR)
4441 return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
4442
4443 if (is_gimple_addressable (from))
4444 {
4445 *from_p = from;
4446 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
4447 pre_p);
4448 }
4449 }
4450
4451 /* Transform partial stores to non-addressable complex variables into
4452 total stores. This allows us to use real instead of virtual operands
4453 for these variables, which improves optimization. */
4454 if ((TREE_CODE (*to_p) == REALPART_EXPR
4455 || TREE_CODE (*to_p) == IMAGPART_EXPR)
4456 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
4457 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
4458
4459 /* Try to alleviate the effects of the gimplification creating artificial
4460 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4461 if (!gimplify_ctxp->into_ssa
4462 && DECL_P (*from_p)
4463 && DECL_IGNORED_P (*from_p)
4464 && DECL_P (*to_p)
4465 && !DECL_IGNORED_P (*to_p))
4466 {
4467 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
4468 DECL_NAME (*from_p)
4469 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
4470 DECL_DEBUG_EXPR_IS_FROM (*from_p) = 1;
4471 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
4472 }
4473
4474 if (TREE_CODE (*from_p) == CALL_EXPR)
4475 {
4476 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4477 instead of a GIMPLE_ASSIGN. */
4478 assign = gimple_build_call_from_tree (*from_p);
4479 gimple_call_set_lhs (assign, *to_p);
4480 }
4481 else
4482 assign = gimple_build_assign (*to_p, *from_p);
4483
4484 gimplify_seq_add_stmt (pre_p, assign);
4485
4486 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
4487 {
4488 /* If we've somehow already got an SSA_NAME on the LHS, then
4489 we've probably modified it twice. Not good. */
4490 gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
4491 *to_p = make_ssa_name (*to_p, assign);
4492 gimple_set_lhs (assign, *to_p);
4493 }
4494
4495 if (want_value)
4496 {
4497 *expr_p = unshare_expr (*to_p);
4498 return GS_OK;
4499 }
4500 else
4501 *expr_p = NULL;
4502
4503 return GS_ALL_DONE;
4504 }
4505
4506 /* Gimplify a comparison between two variable-sized objects. Do this
4507 with a call to BUILT_IN_MEMCMP. */
4508
4509 static enum gimplify_status
4510 gimplify_variable_sized_compare (tree *expr_p)
4511 {
4512 tree op0 = TREE_OPERAND (*expr_p, 0);
4513 tree op1 = TREE_OPERAND (*expr_p, 1);
4514 tree t, arg, dest, src;
4515
4516 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
4517 arg = unshare_expr (arg);
4518 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
4519 src = build_fold_addr_expr (op1);
4520 dest = build_fold_addr_expr (op0);
4521 t = implicit_built_in_decls[BUILT_IN_MEMCMP];
4522 t = build_call_expr (t, 3, dest, src, arg);
4523 *expr_p
4524 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
4525
4526 return GS_OK;
4527 }
4528
4529 /* Gimplify a comparison between two aggregate objects of integral scalar
4530 mode as a comparison between the bitwise equivalent scalar values. */
4531
4532 static enum gimplify_status
4533 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
4534 {
4535 tree op0 = TREE_OPERAND (*expr_p, 0);
4536 tree op1 = TREE_OPERAND (*expr_p, 1);
4537
4538 tree type = TREE_TYPE (op0);
4539 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
4540
4541 op0 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op0);
4542 op1 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op1);
4543
4544 *expr_p
4545 = fold_build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
4546
4547 return GS_OK;
4548 }
4549
4550 /* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P
4551 points to the expression to gimplify.
4552
4553 Expressions of the form 'a && b' are gimplified to:
4554
4555 a && b ? true : false
4556
4557 LOCUS is the source location to be put on the generated COND_EXPR.
4558 gimplify_cond_expr will do the rest. */
4559
4560 static enum gimplify_status
4561 gimplify_boolean_expr (tree *expr_p, location_t locus)
4562 {
4563 /* Preserve the original type of the expression. */
4564 tree type = TREE_TYPE (*expr_p);
4565
4566 *expr_p = build3 (COND_EXPR, type, *expr_p,
4567 fold_convert (type, boolean_true_node),
4568 fold_convert (type, boolean_false_node));
4569
4570 SET_EXPR_LOCATION (*expr_p, locus);
4571
4572 return GS_OK;
4573 }
4574
4575 /* Gimplifies an expression sequence. This function gimplifies each
4576 expression and re-writes the original expression with the last
4577 expression of the sequence in GIMPLE form.
4578
4579 PRE_P points to the list where the side effects for all the
4580 expressions in the sequence will be emitted.
4581
4582 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4583
4584 static enum gimplify_status
4585 gimplify_compound_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
4586 {
4587 tree t = *expr_p;
4588
4589 do
4590 {
4591 tree *sub_p = &TREE_OPERAND (t, 0);
4592
4593 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
4594 gimplify_compound_expr (sub_p, pre_p, false);
4595 else
4596 gimplify_stmt (sub_p, pre_p);
4597
4598 t = TREE_OPERAND (t, 1);
4599 }
4600 while (TREE_CODE (t) == COMPOUND_EXPR);
4601
4602 *expr_p = t;
4603 if (want_value)
4604 return GS_OK;
4605 else
4606 {
4607 gimplify_stmt (expr_p, pre_p);
4608 return GS_ALL_DONE;
4609 }
4610 }
4611
4612
4613 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4614 gimplify. After gimplification, EXPR_P will point to a new temporary
4615 that holds the original value of the SAVE_EXPR node.
4616
4617 PRE_P points to the list where side effects that must happen before
4618 *EXPR_P should be stored. */
4619
4620 static enum gimplify_status
4621 gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4622 {
4623 enum gimplify_status ret = GS_ALL_DONE;
4624 tree val;
4625
4626 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
4627 val = TREE_OPERAND (*expr_p, 0);
4628
4629 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4630 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
4631 {
4632 /* The operand may be a void-valued expression such as SAVE_EXPRs
4633 generated by the Java frontend for class initialization. It is
4634 being executed only for its side-effects. */
4635 if (TREE_TYPE (val) == void_type_node)
4636 {
4637 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
4638 is_gimple_stmt, fb_none);
4639 val = NULL;
4640 }
4641 else
4642 val = get_initialized_tmp_var (val, pre_p, post_p);
4643
4644 TREE_OPERAND (*expr_p, 0) = val;
4645 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
4646 }
4647
4648 *expr_p = val;
4649
4650 return ret;
4651 }
4652
4653 /* Re-write the ADDR_EXPR node pointed to by EXPR_P
4654
4655 unary_expr
4656 : ...
4657 | '&' varname
4658 ...
4659
4660 PRE_P points to the list where side effects that must happen before
4661 *EXPR_P should be stored.
4662
4663 POST_P points to the list where side effects that must happen after
4664 *EXPR_P should be stored. */
4665
4666 static enum gimplify_status
4667 gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4668 {
4669 tree expr = *expr_p;
4670 tree op0 = TREE_OPERAND (expr, 0);
4671 enum gimplify_status ret;
4672
4673 switch (TREE_CODE (op0))
4674 {
4675 case INDIRECT_REF:
4676 case MISALIGNED_INDIRECT_REF:
4677 do_indirect_ref:
4678 /* Check if we are dealing with an expression of the form '&*ptr'.
4679 While the front end folds away '&*ptr' into 'ptr', these
4680 expressions may be generated internally by the compiler (e.g.,
4681 builtins like __builtin_va_end). */
4682 /* Caution: the silent array decomposition semantics we allow for
4683 ADDR_EXPR means we can't always discard the pair. */
4684 /* Gimplification of the ADDR_EXPR operand may drop
4685 cv-qualification conversions, so make sure we add them if
4686 needed. */
4687 {
4688 tree op00 = TREE_OPERAND (op0, 0);
4689 tree t_expr = TREE_TYPE (expr);
4690 tree t_op00 = TREE_TYPE (op00);
4691
4692 if (!useless_type_conversion_p (t_expr, t_op00))
4693 op00 = fold_convert (TREE_TYPE (expr), op00);
4694 *expr_p = op00;
4695 ret = GS_OK;
4696 }
4697 break;
4698
4699 case VIEW_CONVERT_EXPR:
4700 /* Take the address of our operand and then convert it to the type of
4701 this ADDR_EXPR.
4702
4703 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
4704 all clear. The impact of this transformation is even less clear. */
4705
4706 /* If the operand is a useless conversion, look through it. Doing so
4707 guarantees that the ADDR_EXPR and its operand will remain of the
4708 same type. */
4709 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
4710 op0 = TREE_OPERAND (op0, 0);
4711
4712 *expr_p = fold_convert (TREE_TYPE (expr),
4713 build_fold_addr_expr (TREE_OPERAND (op0, 0)));
4714 ret = GS_OK;
4715 break;
4716
4717 default:
4718 /* We use fb_either here because the C frontend sometimes takes
4719 the address of a call that returns a struct; see
4720 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
4721 the implied temporary explicit. */
4722
4723 /* Mark the RHS addressable. */
4724 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
4725 is_gimple_addressable, fb_either);
4726 if (ret == GS_ERROR)
4727 break;
4728
4729 /* We cannot rely on making the RHS addressable if it is
4730 a temporary created by gimplification. In this case create a
4731 new temporary that is initialized by a copy (which will
4732 become a store after we mark it addressable).
4733 This mostly happens if the frontend passed us something that
4734 it could not mark addressable yet, like a fortran
4735 pass-by-reference parameter (int) floatvar. */
4736 if (is_gimple_reg (TREE_OPERAND (expr, 0)))
4737 TREE_OPERAND (expr, 0)
4738 = get_initialized_tmp_var (TREE_OPERAND (expr, 0), pre_p, post_p);
4739
4740 op0 = TREE_OPERAND (expr, 0);
4741
4742 /* For various reasons, the gimplification of the expression
4743 may have made a new INDIRECT_REF. */
4744 if (TREE_CODE (op0) == INDIRECT_REF)
4745 goto do_indirect_ref;
4746
4747 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
4748 recompute_tree_invariant_for_addr_expr (expr);
4749
4750 mark_addressable (TREE_OPERAND (expr, 0));
4751 break;
4752 }
4753
4754 return ret;
4755 }
4756
4757 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
4758 value; output operands should be a gimple lvalue. */
4759
4760 static enum gimplify_status
4761 gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4762 {
4763 tree expr;
4764 int noutputs;
4765 const char **oconstraints;
4766 int i;
4767 tree link;
4768 const char *constraint;
4769 bool allows_mem, allows_reg, is_inout;
4770 enum gimplify_status ret, tret;
4771 gimple stmt;
4772 VEC(tree, gc) *inputs;
4773 VEC(tree, gc) *outputs;
4774 VEC(tree, gc) *clobbers;
4775 tree link_next;
4776
4777 expr = *expr_p;
4778 noutputs = list_length (ASM_OUTPUTS (expr));
4779 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
4780
4781 inputs = outputs = clobbers = NULL;
4782
4783 ret = GS_ALL_DONE;
4784 link_next = NULL_TREE;
4785 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = link_next)
4786 {
4787 bool ok;
4788 size_t constraint_len;
4789
4790 link_next = TREE_CHAIN (link);
4791
4792 oconstraints[i]
4793 = constraint
4794 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
4795 constraint_len = strlen (constraint);
4796 if (constraint_len == 0)
4797 continue;
4798
4799 ok = parse_output_constraint (&constraint, i, 0, 0,
4800 &allows_mem, &allows_reg, &is_inout);
4801 if (!ok)
4802 {
4803 ret = GS_ERROR;
4804 is_inout = false;
4805 }
4806
4807 if (!allows_reg && allows_mem)
4808 mark_addressable (TREE_VALUE (link));
4809
4810 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4811 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
4812 fb_lvalue | fb_mayfail);
4813 if (tret == GS_ERROR)
4814 {
4815 error ("invalid lvalue in asm output %d", i);
4816 ret = tret;
4817 }
4818
4819 VEC_safe_push (tree, gc, outputs, link);
4820 TREE_CHAIN (link) = NULL_TREE;
4821
4822 if (is_inout)
4823 {
4824 /* An input/output operand. To give the optimizers more
4825 flexibility, split it into separate input and output
4826 operands. */
4827 tree input;
4828 char buf[10];
4829
4830 /* Turn the in/out constraint into an output constraint. */
4831 char *p = xstrdup (constraint);
4832 p[0] = '=';
4833 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
4834
4835 /* And add a matching input constraint. */
4836 if (allows_reg)
4837 {
4838 sprintf (buf, "%d", i);
4839
4840 /* If there are multiple alternatives in the constraint,
4841 handle each of them individually. Those that allow register
4842 will be replaced with operand number, the others will stay
4843 unchanged. */
4844 if (strchr (p, ',') != NULL)
4845 {
4846 size_t len = 0, buflen = strlen (buf);
4847 char *beg, *end, *str, *dst;
4848
4849 for (beg = p + 1;;)
4850 {
4851 end = strchr (beg, ',');
4852 if (end == NULL)
4853 end = strchr (beg, '\0');
4854 if ((size_t) (end - beg) < buflen)
4855 len += buflen + 1;
4856 else
4857 len += end - beg + 1;
4858 if (*end)
4859 beg = end + 1;
4860 else
4861 break;
4862 }
4863
4864 str = (char *) alloca (len);
4865 for (beg = p + 1, dst = str;;)
4866 {
4867 const char *tem;
4868 bool mem_p, reg_p, inout_p;
4869
4870 end = strchr (beg, ',');
4871 if (end)
4872 *end = '\0';
4873 beg[-1] = '=';
4874 tem = beg - 1;
4875 parse_output_constraint (&tem, i, 0, 0,
4876 &mem_p, &reg_p, &inout_p);
4877 if (dst != str)
4878 *dst++ = ',';
4879 if (reg_p)
4880 {
4881 memcpy (dst, buf, buflen);
4882 dst += buflen;
4883 }
4884 else
4885 {
4886 if (end)
4887 len = end - beg;
4888 else
4889 len = strlen (beg);
4890 memcpy (dst, beg, len);
4891 dst += len;
4892 }
4893 if (end)
4894 beg = end + 1;
4895 else
4896 break;
4897 }
4898 *dst = '\0';
4899 input = build_string (dst - str, str);
4900 }
4901 else
4902 input = build_string (strlen (buf), buf);
4903 }
4904 else
4905 input = build_string (constraint_len - 1, constraint + 1);
4906
4907 free (p);
4908
4909 input = build_tree_list (build_tree_list (NULL_TREE, input),
4910 unshare_expr (TREE_VALUE (link)));
4911 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
4912 }
4913 }
4914
4915 link_next = NULL_TREE;
4916 for (link = ASM_INPUTS (expr); link; ++i, link = link_next)
4917 {
4918 link_next = TREE_CHAIN (link);
4919 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
4920 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
4921 oconstraints, &allows_mem, &allows_reg);
4922
4923 /* If we can't make copies, we can only accept memory. */
4924 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
4925 {
4926 if (allows_mem)
4927 allows_reg = 0;
4928 else
4929 {
4930 error ("impossible constraint in %<asm%>");
4931 error ("non-memory input %d must stay in memory", i);
4932 return GS_ERROR;
4933 }
4934 }
4935
4936 /* If the operand is a memory input, it should be an lvalue. */
4937 if (!allows_reg && allows_mem)
4938 {
4939 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4940 is_gimple_lvalue, fb_lvalue | fb_mayfail);
4941 mark_addressable (TREE_VALUE (link));
4942 if (tret == GS_ERROR)
4943 {
4944 if (EXPR_HAS_LOCATION (TREE_VALUE (link)))
4945 input_location = EXPR_LOCATION (TREE_VALUE (link));
4946 error ("memory input %d is not directly addressable", i);
4947 ret = tret;
4948 }
4949 }
4950 else
4951 {
4952 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4953 is_gimple_asm_val, fb_rvalue);
4954 if (tret == GS_ERROR)
4955 ret = tret;
4956 }
4957
4958 TREE_CHAIN (link) = NULL_TREE;
4959 VEC_safe_push (tree, gc, inputs, link);
4960 }
4961
4962 for (link = ASM_CLOBBERS (expr); link; ++i, link = TREE_CHAIN (link))
4963 VEC_safe_push (tree, gc, clobbers, link);
4964
4965 stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
4966 inputs, outputs, clobbers);
4967
4968 gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr));
4969 gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
4970
4971 gimplify_seq_add_stmt (pre_p, stmt);
4972
4973 return ret;
4974 }
4975
4976 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
4977 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
4978 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
4979 return to this function.
4980
4981 FIXME should we complexify the prequeue handling instead? Or use flags
4982 for all the cleanups and let the optimizer tighten them up? The current
4983 code seems pretty fragile; it will break on a cleanup within any
4984 non-conditional nesting. But any such nesting would be broken, anyway;
4985 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
4986 and continues out of it. We can do that at the RTL level, though, so
4987 having an optimizer to tighten up try/finally regions would be a Good
4988 Thing. */
4989
4990 static enum gimplify_status
4991 gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
4992 {
4993 gimple_stmt_iterator iter;
4994 gimple_seq body_sequence = NULL;
4995
4996 tree temp = voidify_wrapper_expr (*expr_p, NULL);
4997
4998 /* We only care about the number of conditions between the innermost
4999 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5000 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5001 int old_conds = gimplify_ctxp->conditions;
5002 gimple_seq old_cleanups = gimplify_ctxp->conditional_cleanups;
5003 gimplify_ctxp->conditions = 0;
5004 gimplify_ctxp->conditional_cleanups = NULL;
5005
5006 gimplify_stmt (&TREE_OPERAND (*expr_p, 0), &body_sequence);
5007
5008 gimplify_ctxp->conditions = old_conds;
5009 gimplify_ctxp->conditional_cleanups = old_cleanups;
5010
5011 for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
5012 {
5013 gimple wce = gsi_stmt (iter);
5014
5015 if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
5016 {
5017 if (gsi_one_before_end_p (iter))
5018 {
5019 /* Note that gsi_insert_seq_before and gsi_remove do not
5020 scan operands, unlike some other sequence mutators. */
5021 gsi_insert_seq_before_without_update (&iter,
5022 gimple_wce_cleanup (wce),
5023 GSI_SAME_STMT);
5024 gsi_remove (&iter, true);
5025 break;
5026 }
5027 else
5028 {
5029 gimple gtry;
5030 gimple_seq seq;
5031 enum gimple_try_flags kind;
5032
5033 if (gimple_wce_cleanup_eh_only (wce))
5034 kind = GIMPLE_TRY_CATCH;
5035 else
5036 kind = GIMPLE_TRY_FINALLY;
5037 seq = gsi_split_seq_after (iter);
5038
5039 gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
5040 /* Do not use gsi_replace here, as it may scan operands.
5041 We want to do a simple structural modification only. */
5042 *gsi_stmt_ptr (&iter) = gtry;
5043 iter = gsi_start (seq);
5044 }
5045 }
5046 else
5047 gsi_next (&iter);
5048 }
5049
5050 gimplify_seq_add_seq (pre_p, body_sequence);
5051 if (temp)
5052 {
5053 *expr_p = temp;
5054 return GS_OK;
5055 }
5056 else
5057 {
5058 *expr_p = NULL;
5059 return GS_ALL_DONE;
5060 }
5061 }
5062
5063 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5064 is the cleanup action required. EH_ONLY is true if the cleanup should
5065 only be executed if an exception is thrown, not on normal exit. */
5066
5067 static void
5068 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p)
5069 {
5070 gimple wce;
5071 gimple_seq cleanup_stmts = NULL;
5072
5073 /* Errors can result in improperly nested cleanups. Which results in
5074 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5075 if (errorcount || sorrycount)
5076 return;
5077
5078 if (gimple_conditional_context ())
5079 {
5080 /* If we're in a conditional context, this is more complex. We only
5081 want to run the cleanup if we actually ran the initialization that
5082 necessitates it, but we want to run it after the end of the
5083 conditional context. So we wrap the try/finally around the
5084 condition and use a flag to determine whether or not to actually
5085 run the destructor. Thus
5086
5087 test ? f(A()) : 0
5088
5089 becomes (approximately)
5090
5091 flag = 0;
5092 try {
5093 if (test) { A::A(temp); flag = 1; val = f(temp); }
5094 else { val = 0; }
5095 } finally {
5096 if (flag) A::~A(temp);
5097 }
5098 val
5099 */
5100 tree flag = create_tmp_var (boolean_type_node, "cleanup");
5101 gimple ffalse = gimple_build_assign (flag, boolean_false_node);
5102 gimple ftrue = gimple_build_assign (flag, boolean_true_node);
5103
5104 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
5105 gimplify_stmt (&cleanup, &cleanup_stmts);
5106 wce = gimple_build_wce (cleanup_stmts);
5107
5108 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, ffalse);
5109 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
5110 gimplify_seq_add_stmt (pre_p, ftrue);
5111
5112 /* Because of this manipulation, and the EH edges that jump
5113 threading cannot redirect, the temporary (VAR) will appear
5114 to be used uninitialized. Don't warn. */
5115 TREE_NO_WARNING (var) = 1;
5116 }
5117 else
5118 {
5119 gimplify_stmt (&cleanup, &cleanup_stmts);
5120 wce = gimple_build_wce (cleanup_stmts);
5121 gimple_wce_set_cleanup_eh_only (wce, eh_only);
5122 gimplify_seq_add_stmt (pre_p, wce);
5123 }
5124 }
5125
5126 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5127
5128 static enum gimplify_status
5129 gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5130 {
5131 tree targ = *expr_p;
5132 tree temp = TARGET_EXPR_SLOT (targ);
5133 tree init = TARGET_EXPR_INITIAL (targ);
5134 enum gimplify_status ret;
5135
5136 if (init)
5137 {
5138 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5139 to the temps list. Handle also variable length TARGET_EXPRs. */
5140 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
5141 {
5142 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
5143 gimplify_type_sizes (TREE_TYPE (temp), pre_p);
5144 gimplify_vla_decl (temp, pre_p);
5145 }
5146 else
5147 gimple_add_tmp_var (temp);
5148
5149 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5150 expression is supposed to initialize the slot. */
5151 if (VOID_TYPE_P (TREE_TYPE (init)))
5152 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
5153 else
5154 {
5155 tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
5156 init = init_expr;
5157 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
5158 init = NULL;
5159 ggc_free (init_expr);
5160 }
5161 if (ret == GS_ERROR)
5162 {
5163 /* PR c++/28266 Make sure this is expanded only once. */
5164 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
5165 return GS_ERROR;
5166 }
5167 if (init)
5168 gimplify_and_add (init, pre_p);
5169
5170 /* If needed, push the cleanup for the temp. */
5171 if (TARGET_EXPR_CLEANUP (targ))
5172 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
5173 CLEANUP_EH_ONLY (targ), pre_p);
5174
5175 /* Only expand this once. */
5176 TREE_OPERAND (targ, 3) = init;
5177 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
5178 }
5179 else
5180 /* We should have expanded this before. */
5181 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
5182
5183 *expr_p = temp;
5184 return GS_OK;
5185 }
5186
5187 /* Gimplification of expression trees. */
5188
5189 /* Gimplify an expression which appears at statement context. The
5190 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5191 NULL, a new sequence is allocated.
5192
5193 Return true if we actually added a statement to the queue. */
5194
5195 bool
5196 gimplify_stmt (tree *stmt_p, gimple_seq *seq_p)
5197 {
5198 gimple_seq_node last;
5199
5200 if (!*seq_p)
5201 *seq_p = gimple_seq_alloc ();
5202
5203 last = gimple_seq_last (*seq_p);
5204 gimplify_expr (stmt_p, seq_p, NULL, is_gimple_stmt, fb_none);
5205 return last != gimple_seq_last (*seq_p);
5206 }
5207
5208
5209 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5210 to CTX. If entries already exist, force them to be some flavor of private.
5211 If there is no enclosing parallel, do nothing. */
5212
5213 void
5214 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
5215 {
5216 splay_tree_node n;
5217
5218 if (decl == NULL || !DECL_P (decl))
5219 return;
5220
5221 do
5222 {
5223 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5224 if (n != NULL)
5225 {
5226 if (n->value & GOVD_SHARED)
5227 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
5228 else
5229 return;
5230 }
5231 else if (ctx->region_type != ORT_WORKSHARE)
5232 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
5233
5234 ctx = ctx->outer_context;
5235 }
5236 while (ctx);
5237 }
5238
5239 /* Similarly for each of the type sizes of TYPE. */
5240
5241 static void
5242 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
5243 {
5244 if (type == NULL || type == error_mark_node)
5245 return;
5246 type = TYPE_MAIN_VARIANT (type);
5247
5248 if (pointer_set_insert (ctx->privatized_types, type))
5249 return;
5250
5251 switch (TREE_CODE (type))
5252 {
5253 case INTEGER_TYPE:
5254 case ENUMERAL_TYPE:
5255 case BOOLEAN_TYPE:
5256 case REAL_TYPE:
5257 case FIXED_POINT_TYPE:
5258 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
5259 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
5260 break;
5261
5262 case ARRAY_TYPE:
5263 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
5264 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
5265 break;
5266
5267 case RECORD_TYPE:
5268 case UNION_TYPE:
5269 case QUAL_UNION_TYPE:
5270 {
5271 tree field;
5272 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5273 if (TREE_CODE (field) == FIELD_DECL)
5274 {
5275 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
5276 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
5277 }
5278 }
5279 break;
5280
5281 case POINTER_TYPE:
5282 case REFERENCE_TYPE:
5283 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
5284 break;
5285
5286 default:
5287 break;
5288 }
5289
5290 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
5291 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
5292 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
5293 }
5294
5295 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5296
5297 static void
5298 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
5299 {
5300 splay_tree_node n;
5301 unsigned int nflags;
5302 tree t;
5303
5304 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
5305 return;
5306
5307 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5308 there are constructors involved somewhere. */
5309 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
5310 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
5311 flags |= GOVD_SEEN;
5312
5313 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5314 if (n != NULL)
5315 {
5316 /* We shouldn't be re-adding the decl with the same data
5317 sharing class. */
5318 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
5319 /* The only combination of data sharing classes we should see is
5320 FIRSTPRIVATE and LASTPRIVATE. */
5321 nflags = n->value | flags;
5322 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
5323 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
5324 n->value = nflags;
5325 return;
5326 }
5327
5328 /* When adding a variable-sized variable, we have to handle all sorts
5329 of additional bits of data: the pointer replacement variable, and
5330 the parameters of the type. */
5331 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
5332 {
5333 /* Add the pointer replacement variable as PRIVATE if the variable
5334 replacement is private, else FIRSTPRIVATE since we'll need the
5335 address of the original variable either for SHARED, or for the
5336 copy into or out of the context. */
5337 if (!(flags & GOVD_LOCAL))
5338 {
5339 nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
5340 nflags |= flags & GOVD_SEEN;
5341 t = DECL_VALUE_EXPR (decl);
5342 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
5343 t = TREE_OPERAND (t, 0);
5344 gcc_assert (DECL_P (t));
5345 omp_add_variable (ctx, t, nflags);
5346 }
5347
5348 /* Add all of the variable and type parameters (which should have
5349 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5350 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
5351 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
5352 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
5353
5354 /* The variable-sized variable itself is never SHARED, only some form
5355 of PRIVATE. The sharing would take place via the pointer variable
5356 which we remapped above. */
5357 if (flags & GOVD_SHARED)
5358 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
5359 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
5360
5361 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5362 alloca statement we generate for the variable, so make sure it
5363 is available. This isn't automatically needed for the SHARED
5364 case, since we won't be allocating local storage then.
5365 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5366 in this case omp_notice_variable will be called later
5367 on when it is gimplified. */
5368 else if (! (flags & GOVD_LOCAL))
5369 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
5370 }
5371 else if (lang_hooks.decls.omp_privatize_by_reference (decl))
5372 {
5373 gcc_assert ((flags & GOVD_LOCAL) == 0);
5374 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
5375
5376 /* Similar to the direct variable sized case above, we'll need the
5377 size of references being privatized. */
5378 if ((flags & GOVD_SHARED) == 0)
5379 {
5380 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
5381 if (TREE_CODE (t) != INTEGER_CST)
5382 omp_notice_variable (ctx, t, true);
5383 }
5384 }
5385
5386 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
5387 }
5388
5389 /* Record the fact that DECL was used within the OpenMP context CTX.
5390 IN_CODE is true when real code uses DECL, and false when we should
5391 merely emit default(none) errors. Return true if DECL is going to
5392 be remapped and thus DECL shouldn't be gimplified into its
5393 DECL_VALUE_EXPR (if any). */
5394
5395 static bool
5396 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
5397 {
5398 splay_tree_node n;
5399 unsigned flags = in_code ? GOVD_SEEN : 0;
5400 bool ret = false, shared;
5401
5402 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
5403 return false;
5404
5405 /* Threadprivate variables are predetermined. */
5406 if (is_global_var (decl))
5407 {
5408 if (DECL_THREAD_LOCAL_P (decl))
5409 return false;
5410
5411 if (DECL_HAS_VALUE_EXPR_P (decl))
5412 {
5413 tree value = get_base_address (DECL_VALUE_EXPR (decl));
5414
5415 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
5416 return false;
5417 }
5418 }
5419
5420 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5421 if (n == NULL)
5422 {
5423 enum omp_clause_default_kind default_kind, kind;
5424 struct gimplify_omp_ctx *octx;
5425
5426 if (ctx->region_type == ORT_WORKSHARE)
5427 goto do_outer;
5428
5429 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5430 remapped firstprivate instead of shared. To some extent this is
5431 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5432 default_kind = ctx->default_kind;
5433 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
5434 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
5435 default_kind = kind;
5436
5437 switch (default_kind)
5438 {
5439 case OMP_CLAUSE_DEFAULT_NONE:
5440 error ("%qE not specified in enclosing parallel",
5441 DECL_NAME (decl));
5442 error ("%Henclosing parallel", &ctx->location);
5443 /* FALLTHRU */
5444 case OMP_CLAUSE_DEFAULT_SHARED:
5445 flags |= GOVD_SHARED;
5446 break;
5447 case OMP_CLAUSE_DEFAULT_PRIVATE:
5448 flags |= GOVD_PRIVATE;
5449 break;
5450 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
5451 flags |= GOVD_FIRSTPRIVATE;
5452 break;
5453 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
5454 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5455 gcc_assert (ctx->region_type == ORT_TASK);
5456 if (ctx->outer_context)
5457 omp_notice_variable (ctx->outer_context, decl, in_code);
5458 for (octx = ctx->outer_context; octx; octx = octx->outer_context)
5459 {
5460 splay_tree_node n2;
5461
5462 n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
5463 if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
5464 {
5465 flags |= GOVD_FIRSTPRIVATE;
5466 break;
5467 }
5468 if ((octx->region_type & ORT_PARALLEL) != 0)
5469 break;
5470 }
5471 if (flags & GOVD_FIRSTPRIVATE)
5472 break;
5473 if (octx == NULL
5474 && (TREE_CODE (decl) == PARM_DECL
5475 || (!is_global_var (decl)
5476 && DECL_CONTEXT (decl) == current_function_decl)))
5477 {
5478 flags |= GOVD_FIRSTPRIVATE;
5479 break;
5480 }
5481 flags |= GOVD_SHARED;
5482 break;
5483 default:
5484 gcc_unreachable ();
5485 }
5486
5487 if ((flags & GOVD_PRIVATE)
5488 && lang_hooks.decls.omp_private_outer_ref (decl))
5489 flags |= GOVD_PRIVATE_OUTER_REF;
5490
5491 omp_add_variable (ctx, decl, flags);
5492
5493 shared = (flags & GOVD_SHARED) != 0;
5494 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
5495 goto do_outer;
5496 }
5497
5498 if ((n->value & (GOVD_SEEN | GOVD_LOCAL)) == 0
5499 && (flags & (GOVD_SEEN | GOVD_LOCAL)) == GOVD_SEEN
5500 && DECL_SIZE (decl)
5501 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
5502 {
5503 splay_tree_node n2;
5504 tree t = DECL_VALUE_EXPR (decl);
5505 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
5506 t = TREE_OPERAND (t, 0);
5507 gcc_assert (DECL_P (t));
5508 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
5509 n2->value |= GOVD_SEEN;
5510 }
5511
5512 shared = ((flags | n->value) & GOVD_SHARED) != 0;
5513 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
5514
5515 /* If nothing changed, there's nothing left to do. */
5516 if ((n->value & flags) == flags)
5517 return ret;
5518 flags |= n->value;
5519 n->value = flags;
5520
5521 do_outer:
5522 /* If the variable is private in the current context, then we don't
5523 need to propagate anything to an outer context. */
5524 if ((flags & GOVD_PRIVATE) && !(flags & GOVD_PRIVATE_OUTER_REF))
5525 return ret;
5526 if (ctx->outer_context
5527 && omp_notice_variable (ctx->outer_context, decl, in_code))
5528 return true;
5529 return ret;
5530 }
5531
5532 /* Verify that DECL is private within CTX. If there's specific information
5533 to the contrary in the innermost scope, generate an error. */
5534
5535 static bool
5536 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl)
5537 {
5538 splay_tree_node n;
5539
5540 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5541 if (n != NULL)
5542 {
5543 if (n->value & GOVD_SHARED)
5544 {
5545 if (ctx == gimplify_omp_ctxp)
5546 {
5547 error ("iteration variable %qE should be private",
5548 DECL_NAME (decl));
5549 n->value = GOVD_PRIVATE;
5550 return true;
5551 }
5552 else
5553 return false;
5554 }
5555 else if ((n->value & GOVD_EXPLICIT) != 0
5556 && (ctx == gimplify_omp_ctxp
5557 || (ctx->region_type == ORT_COMBINED_PARALLEL
5558 && gimplify_omp_ctxp->outer_context == ctx)))
5559 {
5560 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
5561 error ("iteration variable %qE should not be firstprivate",
5562 DECL_NAME (decl));
5563 else if ((n->value & GOVD_REDUCTION) != 0)
5564 error ("iteration variable %qE should not be reduction",
5565 DECL_NAME (decl));
5566 }
5567 return (ctx == gimplify_omp_ctxp
5568 || (ctx->region_type == ORT_COMBINED_PARALLEL
5569 && gimplify_omp_ctxp->outer_context == ctx));
5570 }
5571
5572 if (ctx->region_type != ORT_WORKSHARE)
5573 return false;
5574 else if (ctx->outer_context)
5575 return omp_is_private (ctx->outer_context, decl);
5576 return false;
5577 }
5578
5579 /* Return true if DECL is private within a parallel region
5580 that binds to the current construct's context or in parallel
5581 region's REDUCTION clause. */
5582
5583 static bool
5584 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl)
5585 {
5586 splay_tree_node n;
5587
5588 do
5589 {
5590 ctx = ctx->outer_context;
5591 if (ctx == NULL)
5592 return !(is_global_var (decl)
5593 /* References might be private, but might be shared too. */
5594 || lang_hooks.decls.omp_privatize_by_reference (decl));
5595
5596 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5597 if (n != NULL)
5598 return (n->value & GOVD_SHARED) == 0;
5599 }
5600 while (ctx->region_type == ORT_WORKSHARE);
5601 return false;
5602 }
5603
5604 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
5605 and previous omp contexts. */
5606
5607 static void
5608 gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
5609 enum omp_region_type region_type)
5610 {
5611 struct gimplify_omp_ctx *ctx, *outer_ctx;
5612 struct gimplify_ctx gctx;
5613 tree c;
5614
5615 ctx = new_omp_context (region_type);
5616 outer_ctx = ctx->outer_context;
5617
5618 while ((c = *list_p) != NULL)
5619 {
5620 bool remove = false;
5621 bool notice_outer = true;
5622 const char *check_non_private = NULL;
5623 unsigned int flags;
5624 tree decl;
5625
5626 switch (OMP_CLAUSE_CODE (c))
5627 {
5628 case OMP_CLAUSE_PRIVATE:
5629 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
5630 if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
5631 {
5632 flags |= GOVD_PRIVATE_OUTER_REF;
5633 OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
5634 }
5635 else
5636 notice_outer = false;
5637 goto do_add;
5638 case OMP_CLAUSE_SHARED:
5639 flags = GOVD_SHARED | GOVD_EXPLICIT;
5640 goto do_add;
5641 case OMP_CLAUSE_FIRSTPRIVATE:
5642 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
5643 check_non_private = "firstprivate";
5644 goto do_add;
5645 case OMP_CLAUSE_LASTPRIVATE:
5646 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
5647 check_non_private = "lastprivate";
5648 goto do_add;
5649 case OMP_CLAUSE_REDUCTION:
5650 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
5651 check_non_private = "reduction";
5652 goto do_add;
5653
5654 do_add:
5655 decl = OMP_CLAUSE_DECL (c);
5656 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
5657 {
5658 remove = true;
5659 break;
5660 }
5661 omp_add_variable (ctx, decl, flags);
5662 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
5663 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
5664 {
5665 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
5666 GOVD_LOCAL | GOVD_SEEN);
5667 gimplify_omp_ctxp = ctx;
5668 push_gimplify_context (&gctx);
5669
5670 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = gimple_seq_alloc ();
5671 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = gimple_seq_alloc ();
5672
5673 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
5674 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
5675 pop_gimplify_context
5676 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
5677 push_gimplify_context (&gctx);
5678 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
5679 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
5680 pop_gimplify_context
5681 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c)));
5682 OMP_CLAUSE_REDUCTION_INIT (c) = NULL_TREE;
5683 OMP_CLAUSE_REDUCTION_MERGE (c) = NULL_TREE;
5684
5685 gimplify_omp_ctxp = outer_ctx;
5686 }
5687 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
5688 && OMP_CLAUSE_LASTPRIVATE_STMT (c))
5689 {
5690 gimplify_omp_ctxp = ctx;
5691 push_gimplify_context (&gctx);
5692 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
5693 {
5694 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
5695 NULL, NULL);
5696 TREE_SIDE_EFFECTS (bind) = 1;
5697 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
5698 OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
5699 }
5700 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c),
5701 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
5702 pop_gimplify_context
5703 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c)));
5704 OMP_CLAUSE_LASTPRIVATE_STMT (c) = NULL_TREE;
5705
5706 gimplify_omp_ctxp = outer_ctx;
5707 }
5708 if (notice_outer)
5709 goto do_notice;
5710 break;
5711
5712 case OMP_CLAUSE_COPYIN:
5713 case OMP_CLAUSE_COPYPRIVATE:
5714 decl = OMP_CLAUSE_DECL (c);
5715 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
5716 {
5717 remove = true;
5718 break;
5719 }
5720 do_notice:
5721 if (outer_ctx)
5722 omp_notice_variable (outer_ctx, decl, true);
5723 if (check_non_private
5724 && region_type == ORT_WORKSHARE
5725 && omp_check_private (ctx, decl))
5726 {
5727 error ("%s variable %qE is private in outer context",
5728 check_non_private, DECL_NAME (decl));
5729 remove = true;
5730 }
5731 break;
5732
5733 case OMP_CLAUSE_IF:
5734 OMP_CLAUSE_OPERAND (c, 0)
5735 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
5736 /* Fall through. */
5737
5738 case OMP_CLAUSE_SCHEDULE:
5739 case OMP_CLAUSE_NUM_THREADS:
5740 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
5741 is_gimple_val, fb_rvalue) == GS_ERROR)
5742 remove = true;
5743 break;
5744
5745 case OMP_CLAUSE_NOWAIT:
5746 case OMP_CLAUSE_ORDERED:
5747 case OMP_CLAUSE_UNTIED:
5748 case OMP_CLAUSE_COLLAPSE:
5749 break;
5750
5751 case OMP_CLAUSE_DEFAULT:
5752 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
5753 break;
5754
5755 default:
5756 gcc_unreachable ();
5757 }
5758
5759 if (remove)
5760 *list_p = OMP_CLAUSE_CHAIN (c);
5761 else
5762 list_p = &OMP_CLAUSE_CHAIN (c);
5763 }
5764
5765 gimplify_omp_ctxp = ctx;
5766 }
5767
5768 /* For all variables that were not actually used within the context,
5769 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
5770
5771 static int
5772 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
5773 {
5774 tree *list_p = (tree *) data;
5775 tree decl = (tree) n->key;
5776 unsigned flags = n->value;
5777 enum omp_clause_code code;
5778 tree clause;
5779 bool private_debug;
5780
5781 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
5782 return 0;
5783 if ((flags & GOVD_SEEN) == 0)
5784 return 0;
5785 if (flags & GOVD_DEBUG_PRIVATE)
5786 {
5787 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
5788 private_debug = true;
5789 }
5790 else
5791 private_debug
5792 = lang_hooks.decls.omp_private_debug_clause (decl,
5793 !!(flags & GOVD_SHARED));
5794 if (private_debug)
5795 code = OMP_CLAUSE_PRIVATE;
5796 else if (flags & GOVD_SHARED)
5797 {
5798 if (is_global_var (decl))
5799 {
5800 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
5801 while (ctx != NULL)
5802 {
5803 splay_tree_node on
5804 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5805 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
5806 | GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
5807 break;
5808 ctx = ctx->outer_context;
5809 }
5810 if (ctx == NULL)
5811 return 0;
5812 }
5813 code = OMP_CLAUSE_SHARED;
5814 }
5815 else if (flags & GOVD_PRIVATE)
5816 code = OMP_CLAUSE_PRIVATE;
5817 else if (flags & GOVD_FIRSTPRIVATE)
5818 code = OMP_CLAUSE_FIRSTPRIVATE;
5819 else
5820 gcc_unreachable ();
5821
5822 clause = build_omp_clause (code);
5823 OMP_CLAUSE_DECL (clause) = decl;
5824 OMP_CLAUSE_CHAIN (clause) = *list_p;
5825 if (private_debug)
5826 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
5827 else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
5828 OMP_CLAUSE_PRIVATE_OUTER_REF (clause) = 1;
5829 *list_p = clause;
5830 lang_hooks.decls.omp_finish_clause (clause);
5831
5832 return 0;
5833 }
5834
5835 static void
5836 gimplify_adjust_omp_clauses (tree *list_p)
5837 {
5838 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
5839 tree c, decl;
5840
5841 while ((c = *list_p) != NULL)
5842 {
5843 splay_tree_node n;
5844 bool remove = false;
5845
5846 switch (OMP_CLAUSE_CODE (c))
5847 {
5848 case OMP_CLAUSE_PRIVATE:
5849 case OMP_CLAUSE_SHARED:
5850 case OMP_CLAUSE_FIRSTPRIVATE:
5851 decl = OMP_CLAUSE_DECL (c);
5852 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5853 remove = !(n->value & GOVD_SEEN);
5854 if (! remove)
5855 {
5856 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
5857 if ((n->value & GOVD_DEBUG_PRIVATE)
5858 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
5859 {
5860 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
5861 || ((n->value & GOVD_DATA_SHARE_CLASS)
5862 == GOVD_PRIVATE));
5863 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
5864 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
5865 }
5866 }
5867 break;
5868
5869 case OMP_CLAUSE_LASTPRIVATE:
5870 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
5871 accurately reflect the presence of a FIRSTPRIVATE clause. */
5872 decl = OMP_CLAUSE_DECL (c);
5873 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5874 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
5875 = (n->value & GOVD_FIRSTPRIVATE) != 0;
5876 break;
5877
5878 case OMP_CLAUSE_REDUCTION:
5879 case OMP_CLAUSE_COPYIN:
5880 case OMP_CLAUSE_COPYPRIVATE:
5881 case OMP_CLAUSE_IF:
5882 case OMP_CLAUSE_NUM_THREADS:
5883 case OMP_CLAUSE_SCHEDULE:
5884 case OMP_CLAUSE_NOWAIT:
5885 case OMP_CLAUSE_ORDERED:
5886 case OMP_CLAUSE_DEFAULT:
5887 case OMP_CLAUSE_UNTIED:
5888 case OMP_CLAUSE_COLLAPSE:
5889 break;
5890
5891 default:
5892 gcc_unreachable ();
5893 }
5894
5895 if (remove)
5896 *list_p = OMP_CLAUSE_CHAIN (c);
5897 else
5898 list_p = &OMP_CLAUSE_CHAIN (c);
5899 }
5900
5901 /* Add in any implicit data sharing. */
5902 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
5903
5904 gimplify_omp_ctxp = ctx->outer_context;
5905 delete_omp_context (ctx);
5906 }
5907
5908 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
5909 gimplification of the body, as well as scanning the body for used
5910 variables. We need to do this scan now, because variable-sized
5911 decls will be decomposed during gimplification. */
5912
5913 static void
5914 gimplify_omp_parallel (tree *expr_p, gimple_seq *pre_p)
5915 {
5916 tree expr = *expr_p;
5917 gimple g;
5918 gimple_seq body = NULL;
5919 struct gimplify_ctx gctx;
5920
5921 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
5922 OMP_PARALLEL_COMBINED (expr)
5923 ? ORT_COMBINED_PARALLEL
5924 : ORT_PARALLEL);
5925
5926 push_gimplify_context (&gctx);
5927
5928 g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
5929 if (gimple_code (g) == GIMPLE_BIND)
5930 pop_gimplify_context (g);
5931 else
5932 pop_gimplify_context (NULL);
5933
5934 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
5935
5936 g = gimple_build_omp_parallel (body,
5937 OMP_PARALLEL_CLAUSES (expr),
5938 NULL_TREE, NULL_TREE);
5939 if (OMP_PARALLEL_COMBINED (expr))
5940 gimple_omp_set_subcode (g, GF_OMP_PARALLEL_COMBINED);
5941 gimplify_seq_add_stmt (pre_p, g);
5942 *expr_p = NULL_TREE;
5943 }
5944
5945 /* Gimplify the contents of an OMP_TASK statement. This involves
5946 gimplification of the body, as well as scanning the body for used
5947 variables. We need to do this scan now, because variable-sized
5948 decls will be decomposed during gimplification. */
5949
5950 static void
5951 gimplify_omp_task (tree *expr_p, gimple_seq *pre_p)
5952 {
5953 tree expr = *expr_p;
5954 gimple g;
5955 gimple_seq body = NULL;
5956 struct gimplify_ctx gctx;
5957
5958 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p, ORT_TASK);
5959
5960 push_gimplify_context (&gctx);
5961
5962 g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
5963 if (gimple_code (g) == GIMPLE_BIND)
5964 pop_gimplify_context (g);
5965 else
5966 pop_gimplify_context (NULL);
5967
5968 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr));
5969
5970 g = gimple_build_omp_task (body,
5971 OMP_TASK_CLAUSES (expr),
5972 NULL_TREE, NULL_TREE,
5973 NULL_TREE, NULL_TREE, NULL_TREE);
5974 gimplify_seq_add_stmt (pre_p, g);
5975 *expr_p = NULL_TREE;
5976 }
5977
5978 /* Gimplify the gross structure of an OMP_FOR statement. */
5979
5980 static enum gimplify_status
5981 gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
5982 {
5983 tree for_stmt, decl, var, t;
5984 enum gimplify_status ret = GS_ALL_DONE;
5985 enum gimplify_status tret;
5986 gimple gfor;
5987 gimple_seq for_body, for_pre_body;
5988 int i;
5989
5990 for_stmt = *expr_p;
5991
5992 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p,
5993 ORT_WORKSHARE);
5994
5995 /* Handle OMP_FOR_INIT. */
5996 for_pre_body = NULL;
5997 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
5998 OMP_FOR_PRE_BODY (for_stmt) = NULL_TREE;
5999
6000 for_body = gimple_seq_alloc ();
6001 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
6002 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
6003 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
6004 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
6005 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
6006 {
6007 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
6008 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
6009 decl = TREE_OPERAND (t, 0);
6010 gcc_assert (DECL_P (decl));
6011 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))
6012 || POINTER_TYPE_P (TREE_TYPE (decl)));
6013
6014 /* Make sure the iteration variable is private. */
6015 if (omp_is_private (gimplify_omp_ctxp, decl))
6016 omp_notice_variable (gimplify_omp_ctxp, decl, true);
6017 else
6018 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
6019
6020 /* If DECL is not a gimple register, create a temporary variable to act
6021 as an iteration counter. This is valid, since DECL cannot be
6022 modified in the body of the loop. */
6023 if (!is_gimple_reg (decl))
6024 {
6025 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
6026 TREE_OPERAND (t, 0) = var;
6027
6028 gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
6029
6030 omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
6031 }
6032 else
6033 var = decl;
6034
6035 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6036 is_gimple_val, fb_rvalue);
6037 ret = MIN (ret, tret);
6038 if (ret == GS_ERROR)
6039 return ret;
6040
6041 /* Handle OMP_FOR_COND. */
6042 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
6043 gcc_assert (COMPARISON_CLASS_P (t));
6044 gcc_assert (TREE_OPERAND (t, 0) == decl);
6045
6046 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6047 is_gimple_val, fb_rvalue);
6048 ret = MIN (ret, tret);
6049
6050 /* Handle OMP_FOR_INCR. */
6051 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6052 switch (TREE_CODE (t))
6053 {
6054 case PREINCREMENT_EXPR:
6055 case POSTINCREMENT_EXPR:
6056 t = build_int_cst (TREE_TYPE (decl), 1);
6057 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
6058 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
6059 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
6060 break;
6061
6062 case PREDECREMENT_EXPR:
6063 case POSTDECREMENT_EXPR:
6064 t = build_int_cst (TREE_TYPE (decl), -1);
6065 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
6066 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
6067 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
6068 break;
6069
6070 case MODIFY_EXPR:
6071 gcc_assert (TREE_OPERAND (t, 0) == decl);
6072 TREE_OPERAND (t, 0) = var;
6073
6074 t = TREE_OPERAND (t, 1);
6075 switch (TREE_CODE (t))
6076 {
6077 case PLUS_EXPR:
6078 if (TREE_OPERAND (t, 1) == decl)
6079 {
6080 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
6081 TREE_OPERAND (t, 0) = var;
6082 break;
6083 }
6084
6085 /* Fallthru. */
6086 case MINUS_EXPR:
6087 case POINTER_PLUS_EXPR:
6088 gcc_assert (TREE_OPERAND (t, 0) == decl);
6089 TREE_OPERAND (t, 0) = var;
6090 break;
6091 default:
6092 gcc_unreachable ();
6093 }
6094
6095 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6096 is_gimple_val, fb_rvalue);
6097 ret = MIN (ret, tret);
6098 break;
6099
6100 default:
6101 gcc_unreachable ();
6102 }
6103
6104 if (var != decl || TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1)
6105 {
6106 tree c;
6107 for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
6108 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
6109 && OMP_CLAUSE_DECL (c) == decl
6110 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) == NULL)
6111 {
6112 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6113 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
6114 gcc_assert (TREE_OPERAND (t, 0) == var);
6115 t = TREE_OPERAND (t, 1);
6116 gcc_assert (TREE_CODE (t) == PLUS_EXPR
6117 || TREE_CODE (t) == MINUS_EXPR
6118 || TREE_CODE (t) == POINTER_PLUS_EXPR);
6119 gcc_assert (TREE_OPERAND (t, 0) == var);
6120 t = build2 (TREE_CODE (t), TREE_TYPE (decl), decl,
6121 TREE_OPERAND (t, 1));
6122 gimplify_assign (decl, t,
6123 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
6124 }
6125 }
6126 }
6127
6128 gimplify_and_add (OMP_FOR_BODY (for_stmt), &for_body);
6129
6130 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
6131
6132 gfor = gimple_build_omp_for (for_body, OMP_FOR_CLAUSES (for_stmt),
6133 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)),
6134 for_pre_body);
6135
6136 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
6137 {
6138 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
6139 gimple_omp_for_set_index (gfor, i, TREE_OPERAND (t, 0));
6140 gimple_omp_for_set_initial (gfor, i, TREE_OPERAND (t, 1));
6141 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
6142 gimple_omp_for_set_cond (gfor, i, TREE_CODE (t));
6143 gimple_omp_for_set_final (gfor, i, TREE_OPERAND (t, 1));
6144 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6145 gimple_omp_for_set_incr (gfor, i, TREE_OPERAND (t, 1));
6146 }
6147
6148 gimplify_seq_add_stmt (pre_p, gfor);
6149 return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR;
6150 }
6151
6152 /* Gimplify the gross structure of other OpenMP worksharing constructs.
6153 In particular, OMP_SECTIONS and OMP_SINGLE. */
6154
6155 static void
6156 gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p)
6157 {
6158 tree expr = *expr_p;
6159 gimple stmt;
6160 gimple_seq body = NULL;
6161
6162 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr), pre_p, ORT_WORKSHARE);
6163 gimplify_and_add (OMP_BODY (expr), &body);
6164 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr));
6165
6166 if (TREE_CODE (expr) == OMP_SECTIONS)
6167 stmt = gimple_build_omp_sections (body, OMP_CLAUSES (expr));
6168 else if (TREE_CODE (expr) == OMP_SINGLE)
6169 stmt = gimple_build_omp_single (body, OMP_CLAUSES (expr));
6170 else
6171 gcc_unreachable ();
6172
6173 gimplify_seq_add_stmt (pre_p, stmt);
6174 }
6175
6176 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
6177 stabilized the lhs of the atomic operation as *ADDR. Return true if
6178 EXPR is this stabilized form. */
6179
6180 static bool
6181 goa_lhs_expr_p (tree expr, tree addr)
6182 {
6183 /* Also include casts to other type variants. The C front end is fond
6184 of adding these for e.g. volatile variables. This is like
6185 STRIP_TYPE_NOPS but includes the main variant lookup. */
6186 while ((CONVERT_EXPR_P (expr)
6187 || TREE_CODE (expr) == NON_LVALUE_EXPR)
6188 && TREE_OPERAND (expr, 0) != error_mark_node
6189 && (TYPE_MAIN_VARIANT (TREE_TYPE (expr))
6190 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (expr, 0)))))
6191 expr = TREE_OPERAND (expr, 0);
6192
6193 if (TREE_CODE (expr) == INDIRECT_REF)
6194 {
6195 expr = TREE_OPERAND (expr, 0);
6196 while (expr != addr
6197 && (CONVERT_EXPR_P (expr)
6198 || TREE_CODE (expr) == NON_LVALUE_EXPR)
6199 && TREE_CODE (expr) == TREE_CODE (addr)
6200 && TYPE_MAIN_VARIANT (TREE_TYPE (expr))
6201 == TYPE_MAIN_VARIANT (TREE_TYPE (addr)))
6202 {
6203 expr = TREE_OPERAND (expr, 0);
6204 addr = TREE_OPERAND (addr, 0);
6205 }
6206 if (expr == addr)
6207 return true;
6208 return (TREE_CODE (addr) == ADDR_EXPR
6209 && TREE_CODE (expr) == ADDR_EXPR
6210 && TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
6211 }
6212 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
6213 return true;
6214 return false;
6215 }
6216
6217 /* Walk *EXPR_P and replace
6218 appearances of *LHS_ADDR with LHS_VAR. If an expression does not involve
6219 the lhs, evaluate it into a temporary. Return 1 if the lhs appeared as
6220 a subexpression, 0 if it did not, or -1 if an error was encountered. */
6221
6222 static int
6223 goa_stabilize_expr (tree *expr_p, gimple_seq *pre_p, tree lhs_addr,
6224 tree lhs_var)
6225 {
6226 tree expr = *expr_p;
6227 int saw_lhs;
6228
6229 if (goa_lhs_expr_p (expr, lhs_addr))
6230 {
6231 *expr_p = lhs_var;
6232 return 1;
6233 }
6234 if (is_gimple_val (expr))
6235 return 0;
6236
6237 saw_lhs = 0;
6238 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
6239 {
6240 case tcc_binary:
6241 case tcc_comparison:
6242 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p, lhs_addr,
6243 lhs_var);
6244 case tcc_unary:
6245 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, lhs_addr,
6246 lhs_var);
6247 break;
6248 case tcc_expression:
6249 switch (TREE_CODE (expr))
6250 {
6251 case TRUTH_ANDIF_EXPR:
6252 case TRUTH_ORIF_EXPR:
6253 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
6254 lhs_addr, lhs_var);
6255 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
6256 lhs_addr, lhs_var);
6257 break;
6258 default:
6259 break;
6260 }
6261 break;
6262 default:
6263 break;
6264 }
6265
6266 if (saw_lhs == 0)
6267 {
6268 enum gimplify_status gs;
6269 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
6270 if (gs != GS_ALL_DONE)
6271 saw_lhs = -1;
6272 }
6273
6274 return saw_lhs;
6275 }
6276
6277
6278 /* Gimplify an OMP_ATOMIC statement. */
6279
6280 static enum gimplify_status
6281 gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p)
6282 {
6283 tree addr = TREE_OPERAND (*expr_p, 0);
6284 tree rhs = TREE_OPERAND (*expr_p, 1);
6285 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
6286 tree tmp_load;
6287
6288 tmp_load = create_tmp_var (type, NULL);
6289 if (goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
6290 return GS_ERROR;
6291
6292 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
6293 != GS_ALL_DONE)
6294 return GS_ERROR;
6295
6296 gimplify_seq_add_stmt (pre_p, gimple_build_omp_atomic_load (tmp_load, addr));
6297 if (gimplify_expr (&rhs, pre_p, NULL, is_gimple_val, fb_rvalue)
6298 != GS_ALL_DONE)
6299 return GS_ERROR;
6300 gimplify_seq_add_stmt (pre_p, gimple_build_omp_atomic_store (rhs));
6301 *expr_p = NULL;
6302
6303 return GS_ALL_DONE;
6304 }
6305
6306
6307 /* Converts the GENERIC expression tree *EXPR_P to GIMPLE. If the
6308 expression produces a value to be used as an operand inside a GIMPLE
6309 statement, the value will be stored back in *EXPR_P. This value will
6310 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
6311 an SSA_NAME. The corresponding sequence of GIMPLE statements is
6312 emitted in PRE_P and POST_P.
6313
6314 Additionally, this process may overwrite parts of the input
6315 expression during gimplification. Ideally, it should be
6316 possible to do non-destructive gimplification.
6317
6318 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
6319 the expression needs to evaluate to a value to be used as
6320 an operand in a GIMPLE statement, this value will be stored in
6321 *EXPR_P on exit. This happens when the caller specifies one
6322 of fb_lvalue or fb_rvalue fallback flags.
6323
6324 PRE_P will contain the sequence of GIMPLE statements corresponding
6325 to the evaluation of EXPR and all the side-effects that must
6326 be executed before the main expression. On exit, the last
6327 statement of PRE_P is the core statement being gimplified. For
6328 instance, when gimplifying 'if (++a)' the last statement in
6329 PRE_P will be 'if (t.1)' where t.1 is the result of
6330 pre-incrementing 'a'.
6331
6332 POST_P will contain the sequence of GIMPLE statements corresponding
6333 to the evaluation of all the side-effects that must be executed
6334 after the main expression. If this is NULL, the post
6335 side-effects are stored at the end of PRE_P.
6336
6337 The reason why the output is split in two is to handle post
6338 side-effects explicitly. In some cases, an expression may have
6339 inner and outer post side-effects which need to be emitted in
6340 an order different from the one given by the recursive
6341 traversal. For instance, for the expression (*p--)++ the post
6342 side-effects of '--' must actually occur *after* the post
6343 side-effects of '++'. However, gimplification will first visit
6344 the inner expression, so if a separate POST sequence was not
6345 used, the resulting sequence would be:
6346
6347 1 t.1 = *p
6348 2 p = p - 1
6349 3 t.2 = t.1 + 1
6350 4 *p = t.2
6351
6352 However, the post-decrement operation in line #2 must not be
6353 evaluated until after the store to *p at line #4, so the
6354 correct sequence should be:
6355
6356 1 t.1 = *p
6357 2 t.2 = t.1 + 1
6358 3 *p = t.2
6359 4 p = p - 1
6360
6361 So, by specifying a separate post queue, it is possible
6362 to emit the post side-effects in the correct order.
6363 If POST_P is NULL, an internal queue will be used. Before
6364 returning to the caller, the sequence POST_P is appended to
6365 the main output sequence PRE_P.
6366
6367 GIMPLE_TEST_F points to a function that takes a tree T and
6368 returns nonzero if T is in the GIMPLE form requested by the
6369 caller. The GIMPLE predicates are in tree-gimple.c.
6370
6371 FALLBACK tells the function what sort of a temporary we want if
6372 gimplification cannot produce an expression that complies with
6373 GIMPLE_TEST_F.
6374
6375 fb_none means that no temporary should be generated
6376 fb_rvalue means that an rvalue is OK to generate
6377 fb_lvalue means that an lvalue is OK to generate
6378 fb_either means that either is OK, but an lvalue is preferable.
6379 fb_mayfail means that gimplification may fail (in which case
6380 GS_ERROR will be returned)
6381
6382 The return value is either GS_ERROR or GS_ALL_DONE, since this
6383 function iterates until EXPR is completely gimplified or an error
6384 occurs. */
6385
6386 enum gimplify_status
6387 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
6388 bool (*gimple_test_f) (tree), fallback_t fallback)
6389 {
6390 tree tmp;
6391 gimple_seq internal_pre = NULL;
6392 gimple_seq internal_post = NULL;
6393 tree save_expr;
6394 bool is_statement;
6395 location_t saved_location;
6396 enum gimplify_status ret;
6397 gimple_stmt_iterator pre_last_gsi, post_last_gsi;
6398
6399 save_expr = *expr_p;
6400 if (save_expr == NULL_TREE)
6401 return GS_ALL_DONE;
6402
6403 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
6404 is_statement = gimple_test_f == is_gimple_stmt;
6405 if (is_statement)
6406 gcc_assert (pre_p);
6407
6408 /* Consistency checks. */
6409 if (gimple_test_f == is_gimple_reg)
6410 gcc_assert (fallback & (fb_rvalue | fb_lvalue));
6411 else if (gimple_test_f == is_gimple_val
6412 || gimple_test_f == is_gimple_call_addr
6413 || gimple_test_f == is_gimple_condexpr
6414 || gimple_test_f == is_gimple_mem_rhs
6415 || gimple_test_f == is_gimple_mem_rhs_or_call
6416 || gimple_test_f == is_gimple_reg_rhs
6417 || gimple_test_f == is_gimple_reg_rhs_or_call
6418 || gimple_test_f == is_gimple_asm_val)
6419 gcc_assert (fallback & fb_rvalue);
6420 else if (gimple_test_f == is_gimple_min_lval
6421 || gimple_test_f == is_gimple_lvalue)
6422 gcc_assert (fallback & fb_lvalue);
6423 else if (gimple_test_f == is_gimple_addressable)
6424 gcc_assert (fallback & fb_either);
6425 else if (gimple_test_f == is_gimple_stmt)
6426 gcc_assert (fallback == fb_none);
6427 else
6428 {
6429 /* We should have recognized the GIMPLE_TEST_F predicate to
6430 know what kind of fallback to use in case a temporary is
6431 needed to hold the value or address of *EXPR_P. */
6432 gcc_unreachable ();
6433 }
6434
6435 /* We used to check the predicate here and return immediately if it
6436 succeeds. This is wrong; the design is for gimplification to be
6437 idempotent, and for the predicates to only test for valid forms, not
6438 whether they are fully simplified. */
6439 if (pre_p == NULL)
6440 pre_p = &internal_pre;
6441
6442 if (post_p == NULL)
6443 post_p = &internal_post;
6444
6445 /* Remember the last statements added to PRE_P and POST_P. Every
6446 new statement added by the gimplification helpers needs to be
6447 annotated with location information. To centralize the
6448 responsibility, we remember the last statement that had been
6449 added to both queues before gimplifying *EXPR_P. If
6450 gimplification produces new statements in PRE_P and POST_P, those
6451 statements will be annotated with the same location information
6452 as *EXPR_P. */
6453 pre_last_gsi = gsi_last (*pre_p);
6454 post_last_gsi = gsi_last (*post_p);
6455
6456 saved_location = input_location;
6457 if (save_expr != error_mark_node
6458 && EXPR_HAS_LOCATION (*expr_p))
6459 input_location = EXPR_LOCATION (*expr_p);
6460
6461 /* Loop over the specific gimplifiers until the toplevel node
6462 remains the same. */
6463 do
6464 {
6465 /* Strip away as many useless type conversions as possible
6466 at the toplevel. */
6467 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
6468
6469 /* Remember the expr. */
6470 save_expr = *expr_p;
6471
6472 /* Die, die, die, my darling. */
6473 if (save_expr == error_mark_node
6474 || (TREE_TYPE (save_expr)
6475 && TREE_TYPE (save_expr) == error_mark_node))
6476 {
6477 ret = GS_ERROR;
6478 break;
6479 }
6480
6481 /* Do any language-specific gimplification. */
6482 ret = ((enum gimplify_status)
6483 lang_hooks.gimplify_expr (expr_p, pre_p, post_p));
6484 if (ret == GS_OK)
6485 {
6486 if (*expr_p == NULL_TREE)
6487 break;
6488 if (*expr_p != save_expr)
6489 continue;
6490 }
6491 else if (ret != GS_UNHANDLED)
6492 break;
6493
6494 ret = GS_OK;
6495 switch (TREE_CODE (*expr_p))
6496 {
6497 /* First deal with the special cases. */
6498
6499 case POSTINCREMENT_EXPR:
6500 case POSTDECREMENT_EXPR:
6501 case PREINCREMENT_EXPR:
6502 case PREDECREMENT_EXPR:
6503 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
6504 fallback != fb_none);
6505 break;
6506
6507 case ARRAY_REF:
6508 case ARRAY_RANGE_REF:
6509 case REALPART_EXPR:
6510 case IMAGPART_EXPR:
6511 case COMPONENT_REF:
6512 case VIEW_CONVERT_EXPR:
6513 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
6514 fallback ? fallback : fb_rvalue);
6515 break;
6516
6517 case COND_EXPR:
6518 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
6519
6520 /* C99 code may assign to an array in a structure value of a
6521 conditional expression, and this has undefined behavior
6522 only on execution, so create a temporary if an lvalue is
6523 required. */
6524 if (fallback == fb_lvalue)
6525 {
6526 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6527 mark_addressable (*expr_p);
6528 }
6529 break;
6530
6531 case CALL_EXPR:
6532 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
6533
6534 /* C99 code may assign to an array in a structure returned
6535 from a function, and this has undefined behavior only on
6536 execution, so create a temporary if an lvalue is
6537 required. */
6538 if (fallback == fb_lvalue)
6539 {
6540 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6541 mark_addressable (*expr_p);
6542 }
6543 break;
6544
6545 case TREE_LIST:
6546 gcc_unreachable ();
6547
6548 case COMPOUND_EXPR:
6549 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
6550 break;
6551
6552 case COMPOUND_LITERAL_EXPR:
6553 ret = gimplify_compound_literal_expr (expr_p, pre_p);
6554 break;
6555
6556 case MODIFY_EXPR:
6557 case INIT_EXPR:
6558 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
6559 fallback != fb_none);
6560 break;
6561
6562 case TRUTH_ANDIF_EXPR:
6563 case TRUTH_ORIF_EXPR:
6564 /* Pass the source location of the outer expression. */
6565 ret = gimplify_boolean_expr (expr_p, saved_location);
6566 break;
6567
6568 case TRUTH_NOT_EXPR:
6569 if (TREE_CODE (TREE_TYPE (*expr_p)) != BOOLEAN_TYPE)
6570 {
6571 tree type = TREE_TYPE (*expr_p);
6572 *expr_p = fold_convert (type, gimple_boolify (*expr_p));
6573 ret = GS_OK;
6574 break;
6575 }
6576
6577 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
6578 is_gimple_val, fb_rvalue);
6579 recalculate_side_effects (*expr_p);
6580 break;
6581
6582 case ADDR_EXPR:
6583 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
6584 break;
6585
6586 case VA_ARG_EXPR:
6587 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
6588 break;
6589
6590 CASE_CONVERT:
6591 if (IS_EMPTY_STMT (*expr_p))
6592 {
6593 ret = GS_ALL_DONE;
6594 break;
6595 }
6596
6597 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
6598 || fallback == fb_none)
6599 {
6600 /* Just strip a conversion to void (or in void context) and
6601 try again. */
6602 *expr_p = TREE_OPERAND (*expr_p, 0);
6603 break;
6604 }
6605
6606 ret = gimplify_conversion (expr_p);
6607 if (ret == GS_ERROR)
6608 break;
6609 if (*expr_p != save_expr)
6610 break;
6611 /* FALLTHRU */
6612
6613 case FIX_TRUNC_EXPR:
6614 /* unary_expr: ... | '(' cast ')' val | ... */
6615 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
6616 is_gimple_val, fb_rvalue);
6617 recalculate_side_effects (*expr_p);
6618 break;
6619
6620 case INDIRECT_REF:
6621 *expr_p = fold_indirect_ref (*expr_p);
6622 if (*expr_p != save_expr)
6623 break;
6624 /* else fall through. */
6625 case ALIGN_INDIRECT_REF:
6626 case MISALIGNED_INDIRECT_REF:
6627 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
6628 is_gimple_reg, fb_rvalue);
6629 recalculate_side_effects (*expr_p);
6630 break;
6631
6632 /* Constants need not be gimplified. */
6633 case INTEGER_CST:
6634 case REAL_CST:
6635 case FIXED_CST:
6636 case STRING_CST:
6637 case COMPLEX_CST:
6638 case VECTOR_CST:
6639 ret = GS_ALL_DONE;
6640 break;
6641
6642 case CONST_DECL:
6643 /* If we require an lvalue, such as for ADDR_EXPR, retain the
6644 CONST_DECL node. Otherwise the decl is replaceable by its
6645 value. */
6646 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
6647 if (fallback & fb_lvalue)
6648 ret = GS_ALL_DONE;
6649 else
6650 *expr_p = DECL_INITIAL (*expr_p);
6651 break;
6652
6653 case DECL_EXPR:
6654 ret = gimplify_decl_expr (expr_p, pre_p);
6655 break;
6656
6657 case EXC_PTR_EXPR:
6658 /* FIXME make this a decl. */
6659 ret = GS_ALL_DONE;
6660 break;
6661
6662 case BIND_EXPR:
6663 ret = gimplify_bind_expr (expr_p, pre_p);
6664 break;
6665
6666 case LOOP_EXPR:
6667 ret = gimplify_loop_expr (expr_p, pre_p);
6668 break;
6669
6670 case SWITCH_EXPR:
6671 ret = gimplify_switch_expr (expr_p, pre_p);
6672 break;
6673
6674 case EXIT_EXPR:
6675 ret = gimplify_exit_expr (expr_p);
6676 break;
6677
6678 case GOTO_EXPR:
6679 /* If the target is not LABEL, then it is a computed jump
6680 and the target needs to be gimplified. */
6681 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
6682 {
6683 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
6684 NULL, is_gimple_val, fb_rvalue);
6685 if (ret == GS_ERROR)
6686 break;
6687 }
6688 gimplify_seq_add_stmt (pre_p,
6689 gimple_build_goto (GOTO_DESTINATION (*expr_p)));
6690 break;
6691
6692 case PREDICT_EXPR:
6693 gimplify_seq_add_stmt (pre_p,
6694 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
6695 PREDICT_EXPR_OUTCOME (*expr_p)));
6696 ret = GS_ALL_DONE;
6697 break;
6698
6699 case LABEL_EXPR:
6700 ret = GS_ALL_DONE;
6701 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
6702 == current_function_decl);
6703 gimplify_seq_add_stmt (pre_p,
6704 gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
6705 break;
6706
6707 case CASE_LABEL_EXPR:
6708 ret = gimplify_case_label_expr (expr_p, pre_p);
6709 break;
6710
6711 case RETURN_EXPR:
6712 ret = gimplify_return_expr (*expr_p, pre_p);
6713 break;
6714
6715 case CONSTRUCTOR:
6716 /* Don't reduce this in place; let gimplify_init_constructor work its
6717 magic. Buf if we're just elaborating this for side effects, just
6718 gimplify any element that has side-effects. */
6719 if (fallback == fb_none)
6720 {
6721 unsigned HOST_WIDE_INT ix;
6722 constructor_elt *ce;
6723 tree temp = NULL_TREE;
6724 for (ix = 0;
6725 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
6726 ix, ce);
6727 ix++)
6728 if (TREE_SIDE_EFFECTS (ce->value))
6729 append_to_statement_list (ce->value, &temp);
6730
6731 *expr_p = temp;
6732 ret = GS_OK;
6733 }
6734 /* C99 code may assign to an array in a constructed
6735 structure or union, and this has undefined behavior only
6736 on execution, so create a temporary if an lvalue is
6737 required. */
6738 else if (fallback == fb_lvalue)
6739 {
6740 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6741 mark_addressable (*expr_p);
6742 }
6743 else
6744 ret = GS_ALL_DONE;
6745 break;
6746
6747 /* The following are special cases that are not handled by the
6748 original GIMPLE grammar. */
6749
6750 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
6751 eliminated. */
6752 case SAVE_EXPR:
6753 ret = gimplify_save_expr (expr_p, pre_p, post_p);
6754 break;
6755
6756 case BIT_FIELD_REF:
6757 {
6758 enum gimplify_status r0, r1, r2;
6759
6760 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
6761 post_p, is_gimple_lvalue, fb_either);
6762 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
6763 post_p, is_gimple_val, fb_rvalue);
6764 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
6765 post_p, is_gimple_val, fb_rvalue);
6766 recalculate_side_effects (*expr_p);
6767
6768 ret = MIN (r0, MIN (r1, r2));
6769 }
6770 break;
6771
6772 case NON_LVALUE_EXPR:
6773 /* This should have been stripped above. */
6774 gcc_unreachable ();
6775
6776 case ASM_EXPR:
6777 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
6778 break;
6779
6780 case TRY_FINALLY_EXPR:
6781 case TRY_CATCH_EXPR:
6782 {
6783 gimple_seq eval, cleanup;
6784 gimple try_;
6785
6786 eval = cleanup = NULL;
6787 gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
6788 gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
6789 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
6790 if (gimple_seq_empty_p (cleanup))
6791 {
6792 gimple_seq_add_seq (pre_p, eval);
6793 ret = GS_ALL_DONE;
6794 break;
6795 }
6796 try_ = gimple_build_try (eval, cleanup,
6797 TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
6798 ? GIMPLE_TRY_FINALLY
6799 : GIMPLE_TRY_CATCH);
6800 if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
6801 gimple_try_set_catch_is_cleanup (try_,
6802 TRY_CATCH_IS_CLEANUP (*expr_p));
6803 gimplify_seq_add_stmt (pre_p, try_);
6804 ret = GS_ALL_DONE;
6805 break;
6806 }
6807
6808 case CLEANUP_POINT_EXPR:
6809 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
6810 break;
6811
6812 case TARGET_EXPR:
6813 ret = gimplify_target_expr (expr_p, pre_p, post_p);
6814 break;
6815
6816 case CATCH_EXPR:
6817 {
6818 gimple c;
6819 gimple_seq handler = NULL;
6820 gimplify_and_add (CATCH_BODY (*expr_p), &handler);
6821 c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
6822 gimplify_seq_add_stmt (pre_p, c);
6823 ret = GS_ALL_DONE;
6824 break;
6825 }
6826
6827 case EH_FILTER_EXPR:
6828 {
6829 gimple ehf;
6830 gimple_seq failure = NULL;
6831
6832 gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
6833 ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
6834 gimple_eh_filter_set_must_not_throw
6835 (ehf, EH_FILTER_MUST_NOT_THROW (*expr_p));
6836 gimplify_seq_add_stmt (pre_p, ehf);
6837 ret = GS_ALL_DONE;
6838 break;
6839 }
6840
6841 case CHANGE_DYNAMIC_TYPE_EXPR:
6842 {
6843 gimple cdt;
6844
6845 ret = gimplify_expr (&CHANGE_DYNAMIC_TYPE_LOCATION (*expr_p),
6846 pre_p, post_p, is_gimple_reg, fb_lvalue);
6847 cdt = gimple_build_cdt (CHANGE_DYNAMIC_TYPE_NEW_TYPE (*expr_p),
6848 CHANGE_DYNAMIC_TYPE_LOCATION (*expr_p));
6849 gimplify_seq_add_stmt (pre_p, cdt);
6850 ret = GS_ALL_DONE;
6851 }
6852 break;
6853
6854 case OBJ_TYPE_REF:
6855 {
6856 enum gimplify_status r0, r1;
6857 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
6858 post_p, is_gimple_val, fb_rvalue);
6859 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
6860 post_p, is_gimple_val, fb_rvalue);
6861 TREE_SIDE_EFFECTS (*expr_p) = 0;
6862 ret = MIN (r0, r1);
6863 }
6864 break;
6865
6866 case LABEL_DECL:
6867 /* We get here when taking the address of a label. We mark
6868 the label as "forced"; meaning it can never be removed and
6869 it is a potential target for any computed goto. */
6870 FORCED_LABEL (*expr_p) = 1;
6871 ret = GS_ALL_DONE;
6872 break;
6873
6874 case STATEMENT_LIST:
6875 ret = gimplify_statement_list (expr_p, pre_p);
6876 break;
6877
6878 case WITH_SIZE_EXPR:
6879 {
6880 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
6881 post_p == &internal_post ? NULL : post_p,
6882 gimple_test_f, fallback);
6883 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
6884 is_gimple_val, fb_rvalue);
6885 }
6886 break;
6887
6888 case VAR_DECL:
6889 case PARM_DECL:
6890 ret = gimplify_var_or_parm_decl (expr_p);
6891 break;
6892
6893 case RESULT_DECL:
6894 /* When within an OpenMP context, notice uses of variables. */
6895 if (gimplify_omp_ctxp)
6896 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
6897 ret = GS_ALL_DONE;
6898 break;
6899
6900 case SSA_NAME:
6901 /* Allow callbacks into the gimplifier during optimization. */
6902 ret = GS_ALL_DONE;
6903 break;
6904
6905 case OMP_PARALLEL:
6906 gimplify_omp_parallel (expr_p, pre_p);
6907 ret = GS_ALL_DONE;
6908 break;
6909
6910 case OMP_TASK:
6911 gimplify_omp_task (expr_p, pre_p);
6912 ret = GS_ALL_DONE;
6913 break;
6914
6915 case OMP_FOR:
6916 ret = gimplify_omp_for (expr_p, pre_p);
6917 break;
6918
6919 case OMP_SECTIONS:
6920 case OMP_SINGLE:
6921 gimplify_omp_workshare (expr_p, pre_p);
6922 ret = GS_ALL_DONE;
6923 break;
6924
6925 case OMP_SECTION:
6926 case OMP_MASTER:
6927 case OMP_ORDERED:
6928 case OMP_CRITICAL:
6929 {
6930 gimple_seq body = NULL;
6931 gimple g;
6932
6933 gimplify_and_add (OMP_BODY (*expr_p), &body);
6934 switch (TREE_CODE (*expr_p))
6935 {
6936 case OMP_SECTION:
6937 g = gimple_build_omp_section (body);
6938 break;
6939 case OMP_MASTER:
6940 g = gimple_build_omp_master (body);
6941 break;
6942 case OMP_ORDERED:
6943 g = gimple_build_omp_ordered (body);
6944 break;
6945 case OMP_CRITICAL:
6946 g = gimple_build_omp_critical (body,
6947 OMP_CRITICAL_NAME (*expr_p));
6948 break;
6949 default:
6950 gcc_unreachable ();
6951 }
6952 gimplify_seq_add_stmt (pre_p, g);
6953 ret = GS_ALL_DONE;
6954 break;
6955 }
6956
6957 case OMP_ATOMIC:
6958 ret = gimplify_omp_atomic (expr_p, pre_p);
6959 break;
6960
6961 case POINTER_PLUS_EXPR:
6962 /* Convert ((type *)A)+offset into &A->field_of_type_and_offset.
6963 The second is gimple immediate saving a need for extra statement.
6964 */
6965 if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
6966 && (tmp = maybe_fold_offset_to_address
6967 (TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
6968 TREE_TYPE (*expr_p))))
6969 {
6970 *expr_p = tmp;
6971 break;
6972 }
6973 /* Convert (void *)&a + 4 into (void *)&a[1]. */
6974 if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
6975 && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
6976 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p,
6977 0),0)))
6978 && (tmp = maybe_fold_offset_to_address
6979 (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
6980 TREE_OPERAND (*expr_p, 1),
6981 TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
6982 0)))))
6983 {
6984 *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
6985 break;
6986 }
6987 /* FALLTHRU */
6988
6989 default:
6990 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
6991 {
6992 case tcc_comparison:
6993 /* Handle comparison of objects of non scalar mode aggregates
6994 with a call to memcmp. It would be nice to only have to do
6995 this for variable-sized objects, but then we'd have to allow
6996 the same nest of reference nodes we allow for MODIFY_EXPR and
6997 that's too complex.
6998
6999 Compare scalar mode aggregates as scalar mode values. Using
7000 memcmp for them would be very inefficient at best, and is
7001 plain wrong if bitfields are involved. */
7002 {
7003 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
7004
7005 if (!AGGREGATE_TYPE_P (type))
7006 goto expr_2;
7007 else if (TYPE_MODE (type) != BLKmode)
7008 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
7009 else
7010 ret = gimplify_variable_sized_compare (expr_p);
7011
7012 break;
7013 }
7014
7015 /* If *EXPR_P does not need to be special-cased, handle it
7016 according to its class. */
7017 case tcc_unary:
7018 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7019 post_p, is_gimple_val, fb_rvalue);
7020 break;
7021
7022 case tcc_binary:
7023 expr_2:
7024 {
7025 enum gimplify_status r0, r1;
7026
7027 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7028 post_p, is_gimple_val, fb_rvalue);
7029 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7030 post_p, is_gimple_val, fb_rvalue);
7031
7032 ret = MIN (r0, r1);
7033 break;
7034 }
7035
7036 case tcc_declaration:
7037 case tcc_constant:
7038 ret = GS_ALL_DONE;
7039 goto dont_recalculate;
7040
7041 default:
7042 gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
7043 || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
7044 || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
7045 goto expr_2;
7046 }
7047
7048 recalculate_side_effects (*expr_p);
7049
7050 dont_recalculate:
7051 break;
7052 }
7053
7054 /* If we replaced *expr_p, gimplify again. */
7055 if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
7056 ret = GS_ALL_DONE;
7057 }
7058 while (ret == GS_OK);
7059
7060 /* If we encountered an error_mark somewhere nested inside, either
7061 stub out the statement or propagate the error back out. */
7062 if (ret == GS_ERROR)
7063 {
7064 if (is_statement)
7065 *expr_p = NULL;
7066 goto out;
7067 }
7068
7069 /* This was only valid as a return value from the langhook, which
7070 we handled. Make sure it doesn't escape from any other context. */
7071 gcc_assert (ret != GS_UNHANDLED);
7072
7073 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
7074 {
7075 /* We aren't looking for a value, and we don't have a valid
7076 statement. If it doesn't have side-effects, throw it away. */
7077 if (!TREE_SIDE_EFFECTS (*expr_p))
7078 *expr_p = NULL;
7079 else if (!TREE_THIS_VOLATILE (*expr_p))
7080 {
7081 /* This is probably a _REF that contains something nested that
7082 has side effects. Recurse through the operands to find it. */
7083 enum tree_code code = TREE_CODE (*expr_p);
7084
7085 switch (code)
7086 {
7087 case COMPONENT_REF:
7088 case REALPART_EXPR:
7089 case IMAGPART_EXPR:
7090 case VIEW_CONVERT_EXPR:
7091 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7092 gimple_test_f, fallback);
7093 break;
7094
7095 case ARRAY_REF:
7096 case ARRAY_RANGE_REF:
7097 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7098 gimple_test_f, fallback);
7099 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
7100 gimple_test_f, fallback);
7101 break;
7102
7103 default:
7104 /* Anything else with side-effects must be converted to
7105 a valid statement before we get here. */
7106 gcc_unreachable ();
7107 }
7108
7109 *expr_p = NULL;
7110 }
7111 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
7112 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
7113 {
7114 /* Historically, the compiler has treated a bare reference
7115 to a non-BLKmode volatile lvalue as forcing a load. */
7116 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
7117
7118 /* Normally, we do not want to create a temporary for a
7119 TREE_ADDRESSABLE type because such a type should not be
7120 copied by bitwise-assignment. However, we make an
7121 exception here, as all we are doing here is ensuring that
7122 we read the bytes that make up the type. We use
7123 create_tmp_var_raw because create_tmp_var will abort when
7124 given a TREE_ADDRESSABLE type. */
7125 tree tmp = create_tmp_var_raw (type, "vol");
7126 gimple_add_tmp_var (tmp);
7127 gimplify_assign (tmp, *expr_p, pre_p);
7128 *expr_p = NULL;
7129 }
7130 else
7131 /* We can't do anything useful with a volatile reference to
7132 an incomplete type, so just throw it away. Likewise for
7133 a BLKmode type, since any implicit inner load should
7134 already have been turned into an explicit one by the
7135 gimplification process. */
7136 *expr_p = NULL;
7137 }
7138
7139 /* If we are gimplifying at the statement level, we're done. Tack
7140 everything together and return. */
7141 if (fallback == fb_none || is_statement)
7142 {
7143 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
7144 it out for GC to reclaim it. */
7145 *expr_p = NULL_TREE;
7146
7147 if (!gimple_seq_empty_p (internal_pre)
7148 || !gimple_seq_empty_p (internal_post))
7149 {
7150 gimplify_seq_add_seq (&internal_pre, internal_post);
7151 gimplify_seq_add_seq (pre_p, internal_pre);
7152 }
7153
7154 /* The result of gimplifying *EXPR_P is going to be the last few
7155 statements in *PRE_P and *POST_P. Add location information
7156 to all the statements that were added by the gimplification
7157 helpers. */
7158 if (!gimple_seq_empty_p (*pre_p))
7159 annotate_all_with_location_after (*pre_p, pre_last_gsi, input_location);
7160
7161 if (!gimple_seq_empty_p (*post_p))
7162 annotate_all_with_location_after (*post_p, post_last_gsi,
7163 input_location);
7164
7165 goto out;
7166 }
7167
7168 #ifdef ENABLE_GIMPLE_CHECKING
7169 if (*expr_p)
7170 {
7171 enum tree_code code = TREE_CODE (*expr_p);
7172 /* These expressions should already be in gimple IR form. */
7173 gcc_assert (code != MODIFY_EXPR
7174 && code != ASM_EXPR
7175 && code != BIND_EXPR
7176 && code != CATCH_EXPR
7177 && (code != COND_EXPR || gimplify_ctxp->allow_rhs_cond_expr)
7178 && code != EH_FILTER_EXPR
7179 && code != GOTO_EXPR
7180 && code != LABEL_EXPR
7181 && code != LOOP_EXPR
7182 && code != RESX_EXPR
7183 && code != SWITCH_EXPR
7184 && code != TRY_FINALLY_EXPR
7185 && code != OMP_CRITICAL
7186 && code != OMP_FOR
7187 && code != OMP_MASTER
7188 && code != OMP_ORDERED
7189 && code != OMP_PARALLEL
7190 && code != OMP_SECTIONS
7191 && code != OMP_SECTION
7192 && code != OMP_SINGLE);
7193 }
7194 #endif
7195
7196 /* Otherwise we're gimplifying a subexpression, so the resulting
7197 value is interesting. If it's a valid operand that matches
7198 GIMPLE_TEST_F, we're done. Unless we are handling some
7199 post-effects internally; if that's the case, we need to copy into
7200 a temporary before adding the post-effects to POST_P. */
7201 if (gimple_seq_empty_p (internal_post) && (*gimple_test_f) (*expr_p))
7202 goto out;
7203
7204 /* Otherwise, we need to create a new temporary for the gimplified
7205 expression. */
7206
7207 /* We can't return an lvalue if we have an internal postqueue. The
7208 object the lvalue refers to would (probably) be modified by the
7209 postqueue; we need to copy the value out first, which means an
7210 rvalue. */
7211 if ((fallback & fb_lvalue)
7212 && gimple_seq_empty_p (internal_post)
7213 && is_gimple_addressable (*expr_p))
7214 {
7215 /* An lvalue will do. Take the address of the expression, store it
7216 in a temporary, and replace the expression with an INDIRECT_REF of
7217 that temporary. */
7218 tmp = build_fold_addr_expr (*expr_p);
7219 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
7220 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
7221 }
7222 else if ((fallback & fb_rvalue) && is_gimple_reg_rhs_or_call (*expr_p))
7223 {
7224 /* An rvalue will do. Assign the gimplified expression into a
7225 new temporary TMP and replace the original expression with
7226 TMP. First, make sure that the expression has a type so that
7227 it can be assigned into a temporary. */
7228 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
7229
7230 if (!gimple_seq_empty_p (internal_post) || (fallback & fb_lvalue))
7231 /* The postqueue might change the value of the expression between
7232 the initialization and use of the temporary, so we can't use a
7233 formal temp. FIXME do we care? */
7234 {
7235 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
7236 if (TREE_CODE (TREE_TYPE (*expr_p)) == COMPLEX_TYPE
7237 || TREE_CODE (TREE_TYPE (*expr_p)) == VECTOR_TYPE)
7238 DECL_GIMPLE_REG_P (*expr_p) = 1;
7239 }
7240 else
7241 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
7242 }
7243 else
7244 {
7245 #ifdef ENABLE_GIMPLE_CHECKING
7246 if (!(fallback & fb_mayfail))
7247 {
7248 fprintf (stderr, "gimplification failed:\n");
7249 print_generic_expr (stderr, *expr_p, 0);
7250 debug_tree (*expr_p);
7251 internal_error ("gimplification failed");
7252 }
7253 #endif
7254 gcc_assert (fallback & fb_mayfail);
7255
7256 /* If this is an asm statement, and the user asked for the
7257 impossible, don't die. Fail and let gimplify_asm_expr
7258 issue an error. */
7259 ret = GS_ERROR;
7260 goto out;
7261 }
7262
7263 /* Make sure the temporary matches our predicate. */
7264 gcc_assert ((*gimple_test_f) (*expr_p));
7265
7266 if (!gimple_seq_empty_p (internal_post))
7267 {
7268 annotate_all_with_location (internal_post, input_location);
7269 gimplify_seq_add_seq (pre_p, internal_post);
7270 }
7271
7272 out:
7273 input_location = saved_location;
7274 return ret;
7275 }
7276
7277 /* Look through TYPE for variable-sized objects and gimplify each such
7278 size that we find. Add to LIST_P any statements generated. */
7279
7280 void
7281 gimplify_type_sizes (tree type, gimple_seq *list_p)
7282 {
7283 tree field, t;
7284
7285 if (type == NULL || type == error_mark_node)
7286 return;
7287
7288 /* We first do the main variant, then copy into any other variants. */
7289 type = TYPE_MAIN_VARIANT (type);
7290
7291 /* Avoid infinite recursion. */
7292 if (TYPE_SIZES_GIMPLIFIED (type))
7293 return;
7294
7295 TYPE_SIZES_GIMPLIFIED (type) = 1;
7296
7297 switch (TREE_CODE (type))
7298 {
7299 case INTEGER_TYPE:
7300 case ENUMERAL_TYPE:
7301 case BOOLEAN_TYPE:
7302 case REAL_TYPE:
7303 case FIXED_POINT_TYPE:
7304 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
7305 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
7306
7307 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7308 {
7309 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
7310 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
7311 }
7312 break;
7313
7314 case ARRAY_TYPE:
7315 /* These types may not have declarations, so handle them here. */
7316 gimplify_type_sizes (TREE_TYPE (type), list_p);
7317 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
7318 /* When not optimizing, ensure VLA bounds aren't removed. */
7319 if (!optimize
7320 && TYPE_DOMAIN (type)
7321 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
7322 {
7323 t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
7324 if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
7325 DECL_IGNORED_P (t) = 0;
7326 t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
7327 if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
7328 DECL_IGNORED_P (t) = 0;
7329 }
7330 break;
7331
7332 case RECORD_TYPE:
7333 case UNION_TYPE:
7334 case QUAL_UNION_TYPE:
7335 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
7336 if (TREE_CODE (field) == FIELD_DECL)
7337 {
7338 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
7339 gimplify_one_sizepos (&DECL_SIZE (field), list_p);
7340 gimplify_one_sizepos (&DECL_SIZE_UNIT (field), list_p);
7341 gimplify_type_sizes (TREE_TYPE (field), list_p);
7342 }
7343 break;
7344
7345 case POINTER_TYPE:
7346 case REFERENCE_TYPE:
7347 /* We used to recurse on the pointed-to type here, which turned out to
7348 be incorrect because its definition might refer to variables not
7349 yet initialized at this point if a forward declaration is involved.
7350
7351 It was actually useful for anonymous pointed-to types to ensure
7352 that the sizes evaluation dominates every possible later use of the
7353 values. Restricting to such types here would be safe since there
7354 is no possible forward declaration around, but would introduce an
7355 undesirable middle-end semantic to anonymity. We then defer to
7356 front-ends the responsibility of ensuring that the sizes are
7357 evaluated both early and late enough, e.g. by attaching artificial
7358 type declarations to the tree. */
7359 break;
7360
7361 default:
7362 break;
7363 }
7364
7365 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
7366 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
7367
7368 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7369 {
7370 TYPE_SIZE (t) = TYPE_SIZE (type);
7371 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
7372 TYPE_SIZES_GIMPLIFIED (t) = 1;
7373 }
7374 }
7375
7376 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
7377 a size or position, has had all of its SAVE_EXPRs evaluated.
7378 We add any required statements to *STMT_P. */
7379
7380 void
7381 gimplify_one_sizepos (tree *expr_p, gimple_seq *stmt_p)
7382 {
7383 tree type, expr = *expr_p;
7384
7385 /* We don't do anything if the value isn't there, is constant, or contains
7386 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
7387 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
7388 will want to replace it with a new variable, but that will cause problems
7389 if this type is from outside the function. It's OK to have that here. */
7390 if (expr == NULL_TREE || TREE_CONSTANT (expr)
7391 || TREE_CODE (expr) == VAR_DECL
7392 || CONTAINS_PLACEHOLDER_P (expr))
7393 return;
7394
7395 type = TREE_TYPE (expr);
7396 *expr_p = unshare_expr (expr);
7397
7398 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
7399 expr = *expr_p;
7400
7401 /* Verify that we've an exact type match with the original expression.
7402 In particular, we do not wish to drop a "sizetype" in favour of a
7403 type of similar dimensions. We don't want to pollute the generic
7404 type-stripping code with this knowledge because it doesn't matter
7405 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
7406 and friends retain their "sizetype-ness". */
7407 if (TREE_TYPE (expr) != type
7408 && TREE_CODE (type) == INTEGER_TYPE
7409 && TYPE_IS_SIZETYPE (type))
7410 {
7411 tree tmp;
7412 gimple stmt;
7413
7414 *expr_p = create_tmp_var (type, NULL);
7415 tmp = build1 (NOP_EXPR, type, expr);
7416 stmt = gimplify_assign (*expr_p, tmp, stmt_p);
7417 if (EXPR_HAS_LOCATION (expr))
7418 gimple_set_location (stmt, *EXPR_LOCUS (expr));
7419 else
7420 gimple_set_location (stmt, input_location);
7421 }
7422 }
7423
7424
7425 /* Gimplify the body of statements pointed to by BODY_P and return a
7426 GIMPLE_BIND containing the sequence of GIMPLE statements
7427 corresponding to BODY_P. FNDECL is the function decl containing
7428 *BODY_P. */
7429
7430 gimple
7431 gimplify_body (tree *body_p, tree fndecl, bool do_parms)
7432 {
7433 location_t saved_location = input_location;
7434 gimple_seq parm_stmts, seq;
7435 gimple outer_bind;
7436 struct gimplify_ctx gctx;
7437
7438 timevar_push (TV_TREE_GIMPLIFY);
7439
7440 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
7441 gimplification. */
7442 default_rtl_profile ();
7443
7444 gcc_assert (gimplify_ctxp == NULL);
7445 push_gimplify_context (&gctx);
7446
7447 /* Unshare most shared trees in the body and in that of any nested functions.
7448 It would seem we don't have to do this for nested functions because
7449 they are supposed to be output and then the outer function gimplified
7450 first, but the g++ front end doesn't always do it that way. */
7451 unshare_body (body_p, fndecl);
7452 unvisit_body (body_p, fndecl);
7453
7454 if (cgraph_node (fndecl)->origin)
7455 nonlocal_vlas = pointer_set_create ();
7456
7457 /* Make sure input_location isn't set to something weird. */
7458 input_location = DECL_SOURCE_LOCATION (fndecl);
7459
7460 /* Resolve callee-copies. This has to be done before processing
7461 the body so that DECL_VALUE_EXPR gets processed correctly. */
7462 parm_stmts = (do_parms) ? gimplify_parameters () : NULL;
7463
7464 /* Gimplify the function's body. */
7465 seq = NULL;
7466 gimplify_stmt (body_p, &seq);
7467 outer_bind = gimple_seq_first_stmt (seq);
7468 if (!outer_bind)
7469 {
7470 outer_bind = gimple_build_nop ();
7471 gimplify_seq_add_stmt (&seq, outer_bind);
7472 }
7473
7474 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
7475 not the case, wrap everything in a GIMPLE_BIND to make it so. */
7476 if (gimple_code (outer_bind) == GIMPLE_BIND
7477 && gimple_seq_first (seq) == gimple_seq_last (seq))
7478 ;
7479 else
7480 outer_bind = gimple_build_bind (NULL_TREE, seq, NULL);
7481
7482 *body_p = NULL_TREE;
7483
7484 /* If we had callee-copies statements, insert them at the beginning
7485 of the function. */
7486 if (!gimple_seq_empty_p (parm_stmts))
7487 {
7488 gimplify_seq_add_seq (&parm_stmts, gimple_bind_body (outer_bind));
7489 gimple_bind_set_body (outer_bind, parm_stmts);
7490 }
7491
7492 if (nonlocal_vlas)
7493 {
7494 pointer_set_destroy (nonlocal_vlas);
7495 nonlocal_vlas = NULL;
7496 }
7497
7498 pop_gimplify_context (outer_bind);
7499 gcc_assert (gimplify_ctxp == NULL);
7500
7501 #ifdef ENABLE_TYPES_CHECKING
7502 if (!errorcount && !sorrycount)
7503 verify_types_in_gimple_seq (gimple_bind_body (outer_bind));
7504 #endif
7505
7506 timevar_pop (TV_TREE_GIMPLIFY);
7507 input_location = saved_location;
7508
7509 return outer_bind;
7510 }
7511
7512 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
7513 node for the function we want to gimplify.
7514
7515 Returns the sequence of GIMPLE statements corresponding to the body
7516 of FNDECL. */
7517
7518 void
7519 gimplify_function_tree (tree fndecl)
7520 {
7521 tree oldfn, parm, ret;
7522 gimple_seq seq;
7523 gimple bind;
7524
7525 oldfn = current_function_decl;
7526 current_function_decl = fndecl;
7527 if (DECL_STRUCT_FUNCTION (fndecl))
7528 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
7529 else
7530 push_struct_function (fndecl);
7531
7532 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm))
7533 {
7534 /* Preliminarily mark non-addressed complex variables as eligible
7535 for promotion to gimple registers. We'll transform their uses
7536 as we find them. */
7537 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
7538 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
7539 && !TREE_THIS_VOLATILE (parm)
7540 && !needs_to_live_in_memory (parm))
7541 DECL_GIMPLE_REG_P (parm) = 1;
7542 }
7543
7544 ret = DECL_RESULT (fndecl);
7545 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
7546 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
7547 && !needs_to_live_in_memory (ret))
7548 DECL_GIMPLE_REG_P (ret) = 1;
7549
7550 bind = gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true);
7551
7552 /* The tree body of the function is no longer needed, replace it
7553 with the new GIMPLE body. */
7554 seq = gimple_seq_alloc ();
7555 gimple_seq_add_stmt (&seq, bind);
7556 gimple_set_body (fndecl, seq);
7557
7558 /* If we're instrumenting function entry/exit, then prepend the call to
7559 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
7560 catch the exit hook. */
7561 /* ??? Add some way to ignore exceptions for this TFE. */
7562 if (flag_instrument_function_entry_exit
7563 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)
7564 && !flag_instrument_functions_exclude_p (fndecl))
7565 {
7566 tree x;
7567 gimple new_bind;
7568 gimple tf;
7569 gimple_seq cleanup = NULL, body = NULL;
7570
7571 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
7572 gimplify_seq_add_stmt (&cleanup, gimple_build_call (x, 0));
7573 tf = gimple_build_try (seq, cleanup, GIMPLE_TRY_FINALLY);
7574
7575 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
7576 gimplify_seq_add_stmt (&body, gimple_build_call (x, 0));
7577 gimplify_seq_add_stmt (&body, tf);
7578 new_bind = gimple_build_bind (NULL, body, gimple_bind_block (bind));
7579 /* Clear the block for BIND, since it is no longer directly inside
7580 the function, but within a try block. */
7581 gimple_bind_set_block (bind, NULL);
7582
7583 /* Replace the current function body with the body
7584 wrapped in the try/finally TF. */
7585 seq = gimple_seq_alloc ();
7586 gimple_seq_add_stmt (&seq, new_bind);
7587 gimple_set_body (fndecl, seq);
7588 }
7589
7590 DECL_SAVED_TREE (fndecl) = NULL_TREE;
7591
7592 current_function_decl = oldfn;
7593 pop_cfun ();
7594 }
7595
7596
7597 /* Some transformations like inlining may invalidate the GIMPLE form
7598 for operands. This function traverses all the operands in STMT and
7599 gimplifies anything that is not a valid gimple operand. Any new
7600 GIMPLE statements are inserted before *GSI_P. */
7601
7602 void
7603 gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p)
7604 {
7605 size_t i, num_ops;
7606 tree orig_lhs = NULL_TREE, lhs, t;
7607 gimple_seq pre = NULL;
7608 gimple post_stmt = NULL;
7609 struct gimplify_ctx gctx;
7610
7611 push_gimplify_context (&gctx);
7612 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
7613
7614 switch (gimple_code (stmt))
7615 {
7616 case GIMPLE_COND:
7617 gimplify_expr (gimple_cond_lhs_ptr (stmt), &pre, NULL,
7618 is_gimple_val, fb_rvalue);
7619 gimplify_expr (gimple_cond_rhs_ptr (stmt), &pre, NULL,
7620 is_gimple_val, fb_rvalue);
7621 break;
7622 case GIMPLE_SWITCH:
7623 gimplify_expr (gimple_switch_index_ptr (stmt), &pre, NULL,
7624 is_gimple_val, fb_rvalue);
7625 break;
7626 case GIMPLE_OMP_ATOMIC_LOAD:
7627 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt), &pre, NULL,
7628 is_gimple_val, fb_rvalue);
7629 break;
7630 case GIMPLE_ASM:
7631 {
7632 size_t i, noutputs = gimple_asm_noutputs (stmt);
7633 const char *constraint, **oconstraints;
7634 bool allows_mem, allows_reg, is_inout;
7635
7636 oconstraints
7637 = (const char **) alloca ((noutputs) * sizeof (const char *));
7638 for (i = 0; i < noutputs; i++)
7639 {
7640 tree op = gimple_asm_output_op (stmt, i);
7641 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
7642 oconstraints[i] = constraint;
7643 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
7644 &allows_reg, &is_inout);
7645 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
7646 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
7647 fb_lvalue | fb_mayfail);
7648 }
7649 for (i = 0; i < gimple_asm_ninputs (stmt); i++)
7650 {
7651 tree op = gimple_asm_input_op (stmt, i);
7652 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
7653 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
7654 oconstraints, &allows_mem, &allows_reg);
7655 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
7656 allows_reg = 0;
7657 if (!allows_reg && allows_mem)
7658 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
7659 is_gimple_lvalue, fb_lvalue | fb_mayfail);
7660 else
7661 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
7662 is_gimple_asm_val, fb_rvalue);
7663 }
7664 }
7665 break;
7666 default:
7667 /* NOTE: We start gimplifying operands from last to first to
7668 make sure that side-effects on the RHS of calls, assignments
7669 and ASMs are executed before the LHS. The ordering is not
7670 important for other statements. */
7671 num_ops = gimple_num_ops (stmt);
7672 orig_lhs = gimple_get_lhs (stmt);
7673 for (i = num_ops; i > 0; i--)
7674 {
7675 tree op = gimple_op (stmt, i - 1);
7676 if (op == NULL_TREE)
7677 continue;
7678 if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
7679 gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
7680 else if (i == 2
7681 && is_gimple_assign (stmt)
7682 && num_ops == 2
7683 && get_gimple_rhs_class (gimple_expr_code (stmt))
7684 == GIMPLE_SINGLE_RHS)
7685 gimplify_expr (&op, &pre, NULL,
7686 rhs_predicate_for (gimple_assign_lhs (stmt)),
7687 fb_rvalue);
7688 else if (i == 2 && is_gimple_call (stmt))
7689 {
7690 if (TREE_CODE (op) == FUNCTION_DECL)
7691 continue;
7692 gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
7693 }
7694 else
7695 gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
7696 gimple_set_op (stmt, i - 1, op);
7697 }
7698
7699 lhs = gimple_get_lhs (stmt);
7700 /* If the LHS changed it in a way that requires a simple RHS,
7701 create temporary. */
7702 if (lhs && !is_gimple_reg (lhs))
7703 {
7704 bool need_temp = false;
7705
7706 if (is_gimple_assign (stmt)
7707 && num_ops == 2
7708 && get_gimple_rhs_class (gimple_expr_code (stmt))
7709 == GIMPLE_SINGLE_RHS)
7710 gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
7711 rhs_predicate_for (gimple_assign_lhs (stmt)),
7712 fb_rvalue);
7713 else if (is_gimple_reg (lhs))
7714 {
7715 if (is_gimple_reg_type (TREE_TYPE (lhs)))
7716 {
7717 if (is_gimple_call (stmt))
7718 {
7719 i = gimple_call_flags (stmt);
7720 if ((i & ECF_LOOPING_CONST_OR_PURE)
7721 || !(i & (ECF_CONST | ECF_PURE)))
7722 need_temp = true;
7723 }
7724 if (stmt_can_throw_internal (stmt))
7725 need_temp = true;
7726 }
7727 }
7728 else
7729 {
7730 if (is_gimple_reg_type (TREE_TYPE (lhs)))
7731 need_temp = true;
7732 else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
7733 {
7734 if (is_gimple_call (stmt))
7735 {
7736 tree fndecl = gimple_call_fndecl (stmt);
7737
7738 if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
7739 && !(fndecl && DECL_RESULT (fndecl)
7740 && DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
7741 need_temp = true;
7742 }
7743 else
7744 need_temp = true;
7745 }
7746 }
7747 if (need_temp)
7748 {
7749 tree temp = create_tmp_var (TREE_TYPE (lhs), NULL);
7750
7751 if (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE
7752 || TREE_CODE (TREE_TYPE (lhs)) == VECTOR_TYPE)
7753 DECL_GIMPLE_REG_P (temp) = 1;
7754 if (TREE_CODE (orig_lhs) == SSA_NAME)
7755 orig_lhs = SSA_NAME_VAR (orig_lhs);
7756 if (TREE_CODE (orig_lhs) == VAR_DECL
7757 && DECL_BASED_ON_RESTRICT_P (orig_lhs))
7758 {
7759 DECL_BASED_ON_RESTRICT_P (temp) = 1;
7760 SET_DECL_RESTRICT_BASE (temp,
7761 DECL_GET_RESTRICT_BASE (orig_lhs));
7762 }
7763
7764 if (gimple_in_ssa_p (cfun))
7765 temp = make_ssa_name (temp, NULL);
7766 gimple_set_lhs (stmt, temp);
7767 post_stmt = gimple_build_assign (lhs, temp);
7768 if (TREE_CODE (lhs) == SSA_NAME)
7769 SSA_NAME_DEF_STMT (lhs) = post_stmt;
7770 }
7771 }
7772 break;
7773 }
7774
7775 if (gimple_referenced_vars (cfun))
7776 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
7777 add_referenced_var (t);
7778
7779 if (!gimple_seq_empty_p (pre))
7780 {
7781 if (gimple_in_ssa_p (cfun))
7782 {
7783 gimple_stmt_iterator i;
7784
7785 for (i = gsi_start (pre); !gsi_end_p (i); gsi_next (&i))
7786 mark_symbols_for_renaming (gsi_stmt (i));
7787 }
7788 gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
7789 }
7790 if (post_stmt)
7791 gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
7792
7793 pop_gimplify_context (NULL);
7794 }
7795
7796
7797 /* Expands EXPR to list of gimple statements STMTS. If SIMPLE is true,
7798 force the result to be either ssa_name or an invariant, otherwise
7799 just force it to be a rhs expression. If VAR is not NULL, make the
7800 base variable of the final destination be VAR if suitable. */
7801
7802 tree
7803 force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
7804 {
7805 tree t;
7806 enum gimplify_status ret;
7807 gimple_predicate gimple_test_f;
7808 struct gimplify_ctx gctx;
7809
7810 *stmts = NULL;
7811
7812 if (is_gimple_val (expr))
7813 return expr;
7814
7815 gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs;
7816
7817 push_gimplify_context (&gctx);
7818 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
7819 gimplify_ctxp->allow_rhs_cond_expr = true;
7820
7821 if (var)
7822 expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
7823
7824 if (TREE_CODE (expr) != MODIFY_EXPR
7825 && TREE_TYPE (expr) == void_type_node)
7826 {
7827 gimplify_and_add (expr, stmts);
7828 expr = NULL_TREE;
7829 }
7830 else
7831 {
7832 ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
7833 gcc_assert (ret != GS_ERROR);
7834 }
7835
7836 if (gimple_referenced_vars (cfun))
7837 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
7838 add_referenced_var (t);
7839
7840 pop_gimplify_context (NULL);
7841
7842 return expr;
7843 }
7844
7845 /* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR. If
7846 some statements are produced, emits them at GSI. If BEFORE is true.
7847 the statements are appended before GSI, otherwise they are appended after
7848 it. M specifies the way GSI moves after insertion (GSI_SAME_STMT or
7849 GSI_CONTINUE_LINKING are the usual values). */
7850
7851 tree
7852 force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
7853 bool simple_p, tree var, bool before,
7854 enum gsi_iterator_update m)
7855 {
7856 gimple_seq stmts;
7857
7858 expr = force_gimple_operand (expr, &stmts, simple_p, var);
7859
7860 if (!gimple_seq_empty_p (stmts))
7861 {
7862 if (gimple_in_ssa_p (cfun))
7863 {
7864 gimple_stmt_iterator i;
7865
7866 for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
7867 mark_symbols_for_renaming (gsi_stmt (i));
7868 }
7869
7870 if (before)
7871 gsi_insert_seq_before (gsi, stmts, m);
7872 else
7873 gsi_insert_seq_after (gsi, stmts, m);
7874 }
7875
7876 return expr;
7877 }
7878
7879 #include "gt-gimplify.h"