2008-01-25 Douglas Gregor <doug.gregor@gmail.com>
[official-gcc.git] / gcc / gimplify.c
blob1075d6544275c2d76f16b45d44f85a2ba52f5608
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
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>.
8 This file is part of GCC.
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.
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.
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/>. */
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 "tree-gimple.h"
32 #include "tree-inline.h"
33 #include "diagnostic.h"
34 #include "langhooks.h"
35 #include "langhooks-def.h"
36 #include "tree-flow.h"
37 #include "cgraph.h"
38 #include "timevar.h"
39 #include "except.h"
40 #include "hashtab.h"
41 #include "flags.h"
42 #include "real.h"
43 #include "function.h"
44 #include "output.h"
45 #include "expr.h"
46 #include "ggc.h"
47 #include "toplev.h"
48 #include "target.h"
49 #include "optabs.h"
50 #include "pointer-set.h"
51 #include "splay-tree.h"
54 enum gimplify_omp_var_data
56 GOVD_SEEN = 1,
57 GOVD_EXPLICIT = 2,
58 GOVD_SHARED = 4,
59 GOVD_PRIVATE = 8,
60 GOVD_FIRSTPRIVATE = 16,
61 GOVD_LASTPRIVATE = 32,
62 GOVD_REDUCTION = 64,
63 GOVD_LOCAL = 128,
64 GOVD_DEBUG_PRIVATE = 256,
65 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
66 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
69 struct gimplify_omp_ctx
71 struct gimplify_omp_ctx *outer_context;
72 splay_tree variables;
73 struct pointer_set_t *privatized_types;
74 location_t location;
75 enum omp_clause_default_kind default_kind;
76 bool is_parallel;
77 bool is_combined_parallel;
80 struct gimplify_ctx
82 struct gimplify_ctx *prev_context;
84 tree current_bind_expr;
85 tree temps;
86 tree conditional_cleanups;
87 tree exit_label;
88 tree return_temp;
90 VEC(tree,heap) *case_labels;
91 /* The formal temporary table. Should this be persistent? */
92 htab_t temp_htab;
94 int conditions;
95 bool save_stack;
96 bool into_ssa;
97 bool allow_rhs_cond_expr;
100 static struct gimplify_ctx *gimplify_ctxp;
101 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
105 /* Formal (expression) temporary table handling: Multiple occurrences of
106 the same scalar expression are evaluated into the same temporary. */
108 typedef struct gimple_temp_hash_elt
110 tree val; /* Key */
111 tree temp; /* Value */
112 } elt_t;
114 /* Forward declarations. */
115 static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool);
117 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
118 form and we don't do any syntax checking. */
119 static void
120 mark_addressable (tree x)
122 while (handled_component_p (x))
123 x = TREE_OPERAND (x, 0);
124 if (TREE_CODE (x) != VAR_DECL && TREE_CODE (x) != PARM_DECL)
125 return ;
126 TREE_ADDRESSABLE (x) = 1;
129 /* Return a hash value for a formal temporary table entry. */
131 static hashval_t
132 gimple_tree_hash (const void *p)
134 tree t = ((const elt_t *) p)->val;
135 return iterative_hash_expr (t, 0);
138 /* Compare two formal temporary table entries. */
140 static int
141 gimple_tree_eq (const void *p1, const void *p2)
143 tree t1 = ((const elt_t *) p1)->val;
144 tree t2 = ((const elt_t *) p2)->val;
145 enum tree_code code = TREE_CODE (t1);
147 if (TREE_CODE (t2) != code
148 || TREE_TYPE (t1) != TREE_TYPE (t2))
149 return 0;
151 if (!operand_equal_p (t1, t2, 0))
152 return 0;
154 /* Only allow them to compare equal if they also hash equal; otherwise
155 results are nondeterminate, and we fail bootstrap comparison. */
156 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
158 return 1;
161 /* Set up a context for the gimplifier. */
163 void
164 push_gimplify_context (void)
166 struct gimplify_ctx *c;
168 c = (struct gimplify_ctx *) xcalloc (1, sizeof (struct gimplify_ctx));
169 c->prev_context = gimplify_ctxp;
170 if (optimize)
171 c->temp_htab = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
173 gimplify_ctxp = c;
176 /* Tear down a context for the gimplifier. If BODY is non-null, then
177 put the temporaries into the outer BIND_EXPR. Otherwise, put them
178 in the unexpanded_var_list. */
180 void
181 pop_gimplify_context (tree body)
183 struct gimplify_ctx *c = gimplify_ctxp;
184 tree t;
186 gcc_assert (c && !c->current_bind_expr);
187 gimplify_ctxp = c->prev_context;
189 for (t = c->temps; t ; t = TREE_CHAIN (t))
190 DECL_GIMPLE_FORMAL_TEMP_P (t) = 0;
192 if (body)
193 declare_vars (c->temps, body, false);
194 else
195 record_vars (c->temps);
197 if (optimize)
198 htab_delete (c->temp_htab);
199 free (c);
202 static void
203 gimple_push_bind_expr (tree bind)
205 TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr;
206 gimplify_ctxp->current_bind_expr = bind;
209 static void
210 gimple_pop_bind_expr (void)
212 gimplify_ctxp->current_bind_expr
213 = TREE_CHAIN (gimplify_ctxp->current_bind_expr);
216 tree
217 gimple_current_bind_expr (void)
219 return gimplify_ctxp->current_bind_expr;
222 /* Returns true iff there is a COND_EXPR between us and the innermost
223 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
225 static bool
226 gimple_conditional_context (void)
228 return gimplify_ctxp->conditions > 0;
231 /* Note that we've entered a COND_EXPR. */
233 static void
234 gimple_push_condition (void)
236 #ifdef ENABLE_CHECKING
237 if (gimplify_ctxp->conditions == 0)
238 gcc_assert (!gimplify_ctxp->conditional_cleanups);
239 #endif
240 ++(gimplify_ctxp->conditions);
243 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
244 now, add any conditional cleanups we've seen to the prequeue. */
246 static void
247 gimple_pop_condition (tree *pre_p)
249 int conds = --(gimplify_ctxp->conditions);
251 gcc_assert (conds >= 0);
252 if (conds == 0)
254 append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p);
255 gimplify_ctxp->conditional_cleanups = NULL_TREE;
259 /* A stable comparison routine for use with splay trees and DECLs. */
261 static int
262 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
264 tree a = (tree) xa;
265 tree b = (tree) xb;
267 return DECL_UID (a) - DECL_UID (b);
270 /* Create a new omp construct that deals with variable remapping. */
272 static struct gimplify_omp_ctx *
273 new_omp_context (bool is_parallel, bool is_combined_parallel)
275 struct gimplify_omp_ctx *c;
277 c = XCNEW (struct gimplify_omp_ctx);
278 c->outer_context = gimplify_omp_ctxp;
279 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
280 c->privatized_types = pointer_set_create ();
281 c->location = input_location;
282 c->is_parallel = is_parallel;
283 c->is_combined_parallel = is_combined_parallel;
284 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
286 return c;
289 /* Destroy an omp construct that deals with variable remapping. */
291 static void
292 delete_omp_context (struct gimplify_omp_ctx *c)
294 splay_tree_delete (c->variables);
295 pointer_set_destroy (c->privatized_types);
296 XDELETE (c);
299 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
300 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
302 /* A subroutine of append_to_statement_list{,_force}. T is not NULL. */
304 static void
305 append_to_statement_list_1 (tree t, tree *list_p)
307 tree list = *list_p;
308 tree_stmt_iterator i;
310 if (!list)
312 if (t && TREE_CODE (t) == STATEMENT_LIST)
314 *list_p = t;
315 return;
317 *list_p = list = alloc_stmt_list ();
320 i = tsi_last (list);
321 tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
324 /* Add T to the end of the list container pointed to by LIST_P.
325 If T is an expression with no effects, it is ignored. */
327 void
328 append_to_statement_list (tree t, tree *list_p)
330 if (t && TREE_SIDE_EFFECTS (t))
331 append_to_statement_list_1 (t, list_p);
334 /* Similar, but the statement is always added, regardless of side effects. */
336 void
337 append_to_statement_list_force (tree t, tree *list_p)
339 if (t != NULL_TREE)
340 append_to_statement_list_1 (t, list_p);
343 /* Both gimplify the statement T and append it to LIST_P. */
345 void
346 gimplify_and_add (tree t, tree *list_p)
348 gimplify_stmt (&t);
349 append_to_statement_list (t, list_p);
352 /* Strip off a legitimate source ending from the input string NAME of
353 length LEN. Rather than having to know the names used by all of
354 our front ends, we strip off an ending of a period followed by
355 up to five characters. (Java uses ".class".) */
357 static inline void
358 remove_suffix (char *name, int len)
360 int i;
362 for (i = 2; i < 8 && len > i; i++)
364 if (name[len - i] == '.')
366 name[len - i] = '\0';
367 break;
372 /* Create a nameless artificial label and put it in the current function
373 context. Returns the newly created label. */
375 tree
376 create_artificial_label (void)
378 tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node);
380 DECL_ARTIFICIAL (lab) = 1;
381 DECL_IGNORED_P (lab) = 1;
382 DECL_CONTEXT (lab) = current_function_decl;
383 return lab;
386 /* Subroutine for find_single_pointer_decl. */
388 static tree
389 find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
390 void *data)
392 tree *pdecl = (tree *) data;
394 if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp)))
396 if (*pdecl)
398 /* We already found a pointer decl; return anything other
399 than NULL_TREE to unwind from walk_tree signalling that
400 we have a duplicate. */
401 return *tp;
403 *pdecl = *tp;
406 return NULL_TREE;
409 /* Find the single DECL of pointer type in the tree T and return it.
410 If there are zero or more than one such DECLs, return NULL. */
412 static tree
413 find_single_pointer_decl (tree t)
415 tree decl = NULL_TREE;
417 if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL))
419 /* find_single_pointer_decl_1 returns a nonzero value, causing
420 walk_tree to return a nonzero value, to indicate that it
421 found more than one pointer DECL. */
422 return NULL_TREE;
425 return decl;
428 /* Create a new temporary name with PREFIX. Returns an identifier. */
430 static GTY(()) unsigned int tmp_var_id_num;
432 tree
433 create_tmp_var_name (const char *prefix)
435 char *tmp_name;
437 if (prefix)
439 char *preftmp = ASTRDUP (prefix);
441 remove_suffix (preftmp, strlen (preftmp));
442 prefix = preftmp;
445 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
446 return get_identifier (tmp_name);
450 /* Create a new temporary variable declaration of type TYPE.
451 Does NOT push it into the current binding. */
453 tree
454 create_tmp_var_raw (tree type, const char *prefix)
456 tree tmp_var;
457 tree new_type;
459 /* Make the type of the variable writable. */
460 new_type = build_type_variant (type, 0, 0);
461 TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
463 tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
464 type);
466 /* The variable was declared by the compiler. */
467 DECL_ARTIFICIAL (tmp_var) = 1;
468 /* And we don't want debug info for it. */
469 DECL_IGNORED_P (tmp_var) = 1;
471 /* Make the variable writable. */
472 TREE_READONLY (tmp_var) = 0;
474 DECL_EXTERNAL (tmp_var) = 0;
475 TREE_STATIC (tmp_var) = 0;
476 TREE_USED (tmp_var) = 1;
478 return tmp_var;
481 /* Create a new temporary variable declaration of type TYPE. DOES push the
482 variable into the current binding. Further, assume that this is called
483 only from gimplification or optimization, at which point the creation of
484 certain types are bugs. */
486 tree
487 create_tmp_var (tree type, const char *prefix)
489 tree tmp_var;
491 /* We don't allow types that are addressable (meaning we can't make copies),
492 or incomplete. We also used to reject every variable size objects here,
493 but now support those for which a constant upper bound can be obtained.
494 The processing for variable sizes is performed in gimple_add_tmp_var,
495 point at which it really matters and possibly reached via paths not going
496 through this function, e.g. after direct calls to create_tmp_var_raw. */
497 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
499 tmp_var = create_tmp_var_raw (type, prefix);
500 gimple_add_tmp_var (tmp_var);
501 return tmp_var;
504 /* Given a tree, try to return a useful variable name that we can use
505 to prefix a temporary that is being assigned the value of the tree.
506 I.E. given <temp> = &A, return A. */
508 const char *
509 get_name (const_tree t)
511 const_tree stripped_decl;
513 stripped_decl = t;
514 STRIP_NOPS (stripped_decl);
515 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
516 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
517 else
519 switch (TREE_CODE (stripped_decl))
521 case ADDR_EXPR:
522 return get_name (TREE_OPERAND (stripped_decl, 0));
523 default:
524 return NULL;
529 /* Create a temporary with a name derived from VAL. Subroutine of
530 lookup_tmp_var; nobody else should call this function. */
532 static inline tree
533 create_tmp_from_val (tree val)
535 return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val));
538 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
539 an existing expression temporary. */
541 static tree
542 lookup_tmp_var (tree val, bool is_formal)
544 tree ret;
546 /* If not optimizing, never really reuse a temporary. local-alloc
547 won't allocate any variable that is used in more than one basic
548 block, which means it will go into memory, causing much extra
549 work in reload and final and poorer code generation, outweighing
550 the extra memory allocation here. */
551 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
552 ret = create_tmp_from_val (val);
553 else
555 elt_t elt, *elt_p;
556 void **slot;
558 elt.val = val;
559 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
560 if (*slot == NULL)
562 elt_p = XNEW (elt_t);
563 elt_p->val = val;
564 elt_p->temp = ret = create_tmp_from_val (val);
565 *slot = (void *) elt_p;
567 else
569 elt_p = (elt_t *) *slot;
570 ret = elt_p->temp;
574 if (is_formal)
575 DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1;
577 return ret;
580 /* Returns a formal temporary variable initialized with VAL. PRE_P is as
581 in gimplify_expr. Only use this function if:
583 1) The value of the unfactored expression represented by VAL will not
584 change between the initialization and use of the temporary, and
585 2) The temporary will not be otherwise modified.
587 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
588 and #2 means it is inappropriate for && temps.
590 For other cases, use get_initialized_tmp_var instead. */
592 static tree
593 internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal)
595 tree t, mod;
597 gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_rhs, fb_rvalue);
599 t = lookup_tmp_var (val, is_formal);
601 if (is_formal)
603 tree u = find_single_pointer_decl (val);
605 if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u))
606 u = DECL_GET_RESTRICT_BASE (u);
607 if (u && TYPE_RESTRICT (TREE_TYPE (u)))
609 if (DECL_BASED_ON_RESTRICT_P (t))
610 gcc_assert (u == DECL_GET_RESTRICT_BASE (t));
611 else
613 DECL_BASED_ON_RESTRICT_P (t) = 1;
614 SET_DECL_RESTRICT_BASE (t, u);
619 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
620 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
621 DECL_GIMPLE_REG_P (t) = 1;
623 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
625 if (EXPR_HAS_LOCATION (val))
626 SET_EXPR_LOCUS (mod, EXPR_LOCUS (val));
627 else
628 SET_EXPR_LOCATION (mod, input_location);
630 /* gimplify_modify_expr might want to reduce this further. */
631 gimplify_and_add (mod, pre_p);
633 /* If we're gimplifying into ssa, gimplify_modify_expr will have
634 given our temporary an ssa name. Find and return it. */
635 if (gimplify_ctxp->into_ssa)
636 t = TREE_OPERAND (mod, 0);
638 return t;
641 /* Returns a formal temporary variable initialized with VAL. PRE_P
642 points to a statement list where side-effects needed to compute VAL
643 should be stored. */
645 tree
646 get_formal_tmp_var (tree val, tree *pre_p)
648 return internal_get_tmp_var (val, pre_p, NULL, true);
651 /* Returns a temporary variable initialized with VAL. PRE_P and POST_P
652 are as in gimplify_expr. */
654 tree
655 get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p)
657 return internal_get_tmp_var (val, pre_p, post_p, false);
660 /* Declares all the variables in VARS in SCOPE. If DEBUG_INFO is
661 true, generate debug info for them; otherwise don't. */
663 void
664 declare_vars (tree vars, tree scope, bool debug_info)
666 tree last = vars;
667 if (last)
669 tree temps, block;
671 /* C99 mode puts the default 'return 0;' for main outside the outer
672 braces. So drill down until we find an actual scope. */
673 while (TREE_CODE (scope) == COMPOUND_EXPR)
674 scope = TREE_OPERAND (scope, 0);
676 gcc_assert (TREE_CODE (scope) == BIND_EXPR);
678 temps = nreverse (last);
680 block = BIND_EXPR_BLOCK (scope);
681 if (!block || !debug_info)
683 TREE_CHAIN (last) = BIND_EXPR_VARS (scope);
684 BIND_EXPR_VARS (scope) = temps;
686 else
688 /* We need to attach the nodes both to the BIND_EXPR and to its
689 associated BLOCK for debugging purposes. The key point here
690 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
691 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
692 if (BLOCK_VARS (block))
693 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
694 else
696 BIND_EXPR_VARS (scope) = chainon (BIND_EXPR_VARS (scope), temps);
697 BLOCK_VARS (block) = temps;
703 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
704 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
705 no such upper bound can be obtained. */
707 static void
708 force_constant_size (tree var)
710 /* The only attempt we make is by querying the maximum size of objects
711 of the variable's type. */
713 HOST_WIDE_INT max_size;
715 gcc_assert (TREE_CODE (var) == VAR_DECL);
717 max_size = max_int_size_in_bytes (TREE_TYPE (var));
719 gcc_assert (max_size >= 0);
721 DECL_SIZE_UNIT (var)
722 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
723 DECL_SIZE (var)
724 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
727 void
728 gimple_add_tmp_var (tree tmp)
730 gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
732 /* Later processing assumes that the object size is constant, which might
733 not be true at this point. Force the use of a constant upper bound in
734 this case. */
735 if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
736 force_constant_size (tmp);
738 DECL_CONTEXT (tmp) = current_function_decl;
739 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
741 if (gimplify_ctxp)
743 TREE_CHAIN (tmp) = gimplify_ctxp->temps;
744 gimplify_ctxp->temps = tmp;
746 /* Mark temporaries local within the nearest enclosing parallel. */
747 if (gimplify_omp_ctxp)
749 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
750 while (ctx && !ctx->is_parallel)
751 ctx = ctx->outer_context;
752 if (ctx)
753 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
756 else if (cfun)
757 record_vars (tmp);
758 else
759 declare_vars (tmp, DECL_SAVED_TREE (current_function_decl), false);
762 /* Determines whether to assign a locus to the statement STMT. */
764 static bool
765 should_carry_locus_p (const_tree stmt)
767 /* Don't emit a line note for a label. We particularly don't want to
768 emit one for the break label, since it doesn't actually correspond
769 to the beginning of the loop/switch. */
770 if (TREE_CODE (stmt) == LABEL_EXPR)
771 return false;
773 /* Do not annotate empty statements, since it confuses gcov. */
774 if (!TREE_SIDE_EFFECTS (stmt))
775 return false;
777 return true;
780 static void
781 annotate_one_with_locus (tree t, location_t locus)
783 if (CAN_HAVE_LOCATION_P (t)
784 && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t))
785 SET_EXPR_LOCATION (t, locus);
788 void
789 annotate_all_with_locus (tree *stmt_p, location_t locus)
791 tree_stmt_iterator i;
793 if (!*stmt_p)
794 return;
796 for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i))
798 tree t = tsi_stmt (i);
800 /* Assuming we've already been gimplified, we shouldn't
801 see nested chaining constructs anymore. */
802 gcc_assert (TREE_CODE (t) != STATEMENT_LIST
803 && TREE_CODE (t) != COMPOUND_EXPR);
805 annotate_one_with_locus (t, locus);
809 /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
810 These nodes model computations that should only be done once. If we
811 were to unshare something like SAVE_EXPR(i++), the gimplification
812 process would create wrong code. */
814 static tree
815 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
817 enum tree_code code = TREE_CODE (*tp);
818 /* Don't unshare types, decls, constants and SAVE_EXPR nodes. */
819 if (TREE_CODE_CLASS (code) == tcc_type
820 || TREE_CODE_CLASS (code) == tcc_declaration
821 || TREE_CODE_CLASS (code) == tcc_constant
822 || code == SAVE_EXPR || code == TARGET_EXPR
823 /* We can't do anything sensible with a BLOCK used as an expression,
824 but we also can't just die when we see it because of non-expression
825 uses. So just avert our eyes and cross our fingers. Silly Java. */
826 || code == BLOCK)
827 *walk_subtrees = 0;
828 else
830 gcc_assert (code != BIND_EXPR);
831 copy_tree_r (tp, walk_subtrees, data);
834 return NULL_TREE;
837 /* Callback for walk_tree to unshare most of the shared trees rooted at
838 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
839 then *TP is deep copied by calling copy_tree_r.
841 This unshares the same trees as copy_tree_r with the exception of
842 SAVE_EXPR nodes. These nodes model computations that should only be
843 done once. If we were to unshare something like SAVE_EXPR(i++), the
844 gimplification process would create wrong code. */
846 static tree
847 copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
848 void *data ATTRIBUTE_UNUSED)
850 tree t = *tp;
851 enum tree_code code = TREE_CODE (t);
853 /* Skip types, decls, and constants. But we do want to look at their
854 types and the bounds of types. Mark them as visited so we properly
855 unmark their subtrees on the unmark pass. If we've already seen them,
856 don't look down further. */
857 if (TREE_CODE_CLASS (code) == tcc_type
858 || TREE_CODE_CLASS (code) == tcc_declaration
859 || TREE_CODE_CLASS (code) == tcc_constant)
861 if (TREE_VISITED (t))
862 *walk_subtrees = 0;
863 else
864 TREE_VISITED (t) = 1;
867 /* If this node has been visited already, unshare it and don't look
868 any deeper. */
869 else if (TREE_VISITED (t))
871 walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
872 *walk_subtrees = 0;
875 /* Otherwise, mark the tree as visited and keep looking. */
876 else
877 TREE_VISITED (t) = 1;
879 return NULL_TREE;
882 static tree
883 unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
884 void *data ATTRIBUTE_UNUSED)
886 if (TREE_VISITED (*tp))
887 TREE_VISITED (*tp) = 0;
888 else
889 *walk_subtrees = 0;
891 return NULL_TREE;
894 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
895 bodies of any nested functions if we are unsharing the entire body of
896 FNDECL. */
898 static void
899 unshare_body (tree *body_p, tree fndecl)
901 struct cgraph_node *cgn = cgraph_node (fndecl);
903 walk_tree (body_p, copy_if_shared_r, NULL, NULL);
904 if (body_p == &DECL_SAVED_TREE (fndecl))
905 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
906 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
909 /* Likewise, but mark all trees as not visited. */
911 static void
912 unvisit_body (tree *body_p, tree fndecl)
914 struct cgraph_node *cgn = cgraph_node (fndecl);
916 walk_tree (body_p, unmark_visited_r, NULL, NULL);
917 if (body_p == &DECL_SAVED_TREE (fndecl))
918 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
919 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
922 /* Unshare T and all the trees reached from T via TREE_CHAIN. */
924 static void
925 unshare_all_trees (tree t)
927 walk_tree (&t, copy_if_shared_r, NULL, NULL);
928 walk_tree (&t, unmark_visited_r, NULL, NULL);
931 /* Unconditionally make an unshared copy of EXPR. This is used when using
932 stored expressions which span multiple functions, such as BINFO_VTABLE,
933 as the normal unsharing process can't tell that they're shared. */
935 tree
936 unshare_expr (tree expr)
938 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
939 return expr;
942 /* A terser interface for building a representation of an exception
943 specification. */
945 tree
946 gimple_build_eh_filter (tree body, tree allowed, tree failure)
948 tree t;
950 /* FIXME should the allowed types go in TREE_TYPE? */
951 t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
952 append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
954 t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
955 append_to_statement_list (body, &TREE_OPERAND (t, 0));
957 return t;
961 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
962 contain statements and have a value. Assign its value to a temporary
963 and give it void_type_node. Returns the temporary, or NULL_TREE if
964 WRAPPER was already void. */
966 tree
967 voidify_wrapper_expr (tree wrapper, tree temp)
969 tree type = TREE_TYPE (wrapper);
970 if (type && !VOID_TYPE_P (type))
972 tree *p;
974 /* Set p to point to the body of the wrapper. Loop until we find
975 something that isn't a wrapper. */
976 for (p = &wrapper; p && *p; )
978 switch (TREE_CODE (*p))
980 case BIND_EXPR:
981 TREE_SIDE_EFFECTS (*p) = 1;
982 TREE_TYPE (*p) = void_type_node;
983 /* For a BIND_EXPR, the body is operand 1. */
984 p = &BIND_EXPR_BODY (*p);
985 break;
987 case CLEANUP_POINT_EXPR:
988 case TRY_FINALLY_EXPR:
989 case TRY_CATCH_EXPR:
990 TREE_SIDE_EFFECTS (*p) = 1;
991 TREE_TYPE (*p) = void_type_node;
992 p = &TREE_OPERAND (*p, 0);
993 break;
995 case STATEMENT_LIST:
997 tree_stmt_iterator i = tsi_last (*p);
998 TREE_SIDE_EFFECTS (*p) = 1;
999 TREE_TYPE (*p) = void_type_node;
1000 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1002 break;
1004 case COMPOUND_EXPR:
1005 /* Advance to the last statement. Set all container types to void. */
1006 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1008 TREE_SIDE_EFFECTS (*p) = 1;
1009 TREE_TYPE (*p) = void_type_node;
1011 break;
1013 default:
1014 goto out;
1018 out:
1019 if (p == NULL || IS_EMPTY_STMT (*p))
1020 temp = NULL_TREE;
1021 else if (temp)
1023 /* The wrapper is on the RHS of an assignment that we're pushing
1024 down. */
1025 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1026 || TREE_CODE (temp) == GIMPLE_MODIFY_STMT
1027 || TREE_CODE (temp) == MODIFY_EXPR);
1028 GENERIC_TREE_OPERAND (temp, 1) = *p;
1029 *p = temp;
1031 else
1033 temp = create_tmp_var (type, "retval");
1034 *p = build2 (INIT_EXPR, type, temp, *p);
1037 return temp;
1040 return NULL_TREE;
1043 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1044 a temporary through which they communicate. */
1046 static void
1047 build_stack_save_restore (tree *save, tree *restore)
1049 tree save_call, tmp_var;
1051 save_call =
1052 build_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 0);
1053 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1055 *save = build_gimple_modify_stmt (tmp_var, save_call);
1056 *restore =
1057 build_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
1058 1, tmp_var);
1061 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1063 static enum gimplify_status
1064 gimplify_bind_expr (tree *expr_p, tree *pre_p)
1066 tree bind_expr = *expr_p;
1067 bool old_save_stack = gimplify_ctxp->save_stack;
1068 tree t;
1070 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1072 /* Mark variables seen in this bind expr. */
1073 for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
1075 if (TREE_CODE (t) == VAR_DECL)
1077 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1079 /* Mark variable as local. */
1080 if (ctx && !is_global_var (t)
1081 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1082 || splay_tree_lookup (ctx->variables,
1083 (splay_tree_key) t) == NULL))
1084 omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1086 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1089 /* Preliminarily mark non-addressed complex variables as eligible
1090 for promotion to gimple registers. We'll transform their uses
1091 as we find them. */
1092 if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1093 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1094 && !TREE_THIS_VOLATILE (t)
1095 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1096 && !needs_to_live_in_memory (t))
1097 DECL_GIMPLE_REG_P (t) = 1;
1100 gimple_push_bind_expr (bind_expr);
1101 gimplify_ctxp->save_stack = false;
1103 gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr));
1105 if (gimplify_ctxp->save_stack)
1107 tree stack_save, stack_restore;
1109 /* Save stack on entry and restore it on exit. Add a try_finally
1110 block to achieve this. Note that mudflap depends on the
1111 format of the emitted code: see mx_register_decls(). */
1112 build_stack_save_restore (&stack_save, &stack_restore);
1114 t = build2 (TRY_FINALLY_EXPR, void_type_node,
1115 BIND_EXPR_BODY (bind_expr), NULL_TREE);
1116 append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1));
1118 BIND_EXPR_BODY (bind_expr) = NULL_TREE;
1119 append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr));
1120 append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr));
1123 gimplify_ctxp->save_stack = old_save_stack;
1124 gimple_pop_bind_expr ();
1126 if (temp)
1128 *expr_p = temp;
1129 append_to_statement_list (bind_expr, pre_p);
1130 return GS_OK;
1132 else
1133 return GS_ALL_DONE;
1136 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1137 GIMPLE value, it is assigned to a new temporary and the statement is
1138 re-written to return the temporary.
1140 PRE_P points to the list where side effects that must happen before
1141 STMT should be stored. */
1143 static enum gimplify_status
1144 gimplify_return_expr (tree stmt, tree *pre_p)
1146 tree ret_expr = TREE_OPERAND (stmt, 0);
1147 tree result_decl, result;
1149 if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL
1150 || ret_expr == error_mark_node)
1151 return GS_ALL_DONE;
1153 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1154 result_decl = NULL_TREE;
1155 else
1157 result_decl = GENERIC_TREE_OPERAND (ret_expr, 0);
1158 if (TREE_CODE (result_decl) == INDIRECT_REF)
1159 /* See through a return by reference. */
1160 result_decl = TREE_OPERAND (result_decl, 0);
1162 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1163 || TREE_CODE (ret_expr) == GIMPLE_MODIFY_STMT
1164 || TREE_CODE (ret_expr) == INIT_EXPR)
1165 && TREE_CODE (result_decl) == RESULT_DECL);
1168 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1169 Recall that aggregate_value_p is FALSE for any aggregate type that is
1170 returned in registers. If we're returning values in registers, then
1171 we don't want to extend the lifetime of the RESULT_DECL, particularly
1172 across another call. In addition, for those aggregates for which
1173 hard_function_value generates a PARALLEL, we'll die during normal
1174 expansion of structure assignments; there's special code in expand_return
1175 to handle this case that does not exist in expand_expr. */
1176 if (!result_decl
1177 || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1178 result = result_decl;
1179 else if (gimplify_ctxp->return_temp)
1180 result = gimplify_ctxp->return_temp;
1181 else
1183 result = create_tmp_var (TREE_TYPE (result_decl), NULL);
1184 if (TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1185 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1186 DECL_GIMPLE_REG_P (result) = 1;
1188 /* ??? With complex control flow (usually involving abnormal edges),
1189 we can wind up warning about an uninitialized value for this. Due
1190 to how this variable is constructed and initialized, this is never
1191 true. Give up and never warn. */
1192 TREE_NO_WARNING (result) = 1;
1194 gimplify_ctxp->return_temp = result;
1197 /* Smash the lhs of the GIMPLE_MODIFY_STMT to the temporary we plan to use.
1198 Then gimplify the whole thing. */
1199 if (result != result_decl)
1200 GENERIC_TREE_OPERAND (ret_expr, 0) = result;
1202 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1204 /* If we didn't use a temporary, then the result is just the result_decl.
1205 Otherwise we need a simple copy. This should already be gimple. */
1206 if (result == result_decl)
1207 ret_expr = result;
1208 else
1209 ret_expr = build_gimple_modify_stmt (result_decl, result);
1210 TREE_OPERAND (stmt, 0) = ret_expr;
1212 return GS_ALL_DONE;
1215 static void
1216 gimplify_vla_decl (tree decl, tree *stmt_p)
1218 /* This is a variable-sized decl. Simplify its size and mark it
1219 for deferred expansion. Note that mudflap depends on the format
1220 of the emitted code: see mx_register_decls(). */
1221 tree t, addr, ptr_type;
1223 gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p);
1224 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p);
1226 /* All occurrences of this decl in final gimplified code will be
1227 replaced by indirection. Setting DECL_VALUE_EXPR does two
1228 things: First, it lets the rest of the gimplifier know what
1229 replacement to use. Second, it lets the debug info know
1230 where to find the value. */
1231 ptr_type = build_pointer_type (TREE_TYPE (decl));
1232 addr = create_tmp_var (ptr_type, get_name (decl));
1233 DECL_IGNORED_P (addr) = 0;
1234 t = build_fold_indirect_ref (addr);
1235 SET_DECL_VALUE_EXPR (decl, t);
1236 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1238 t = built_in_decls[BUILT_IN_ALLOCA];
1239 t = build_call_expr (t, 1, DECL_SIZE_UNIT (decl));
1240 t = fold_convert (ptr_type, t);
1241 t = build_gimple_modify_stmt (addr, t);
1243 gimplify_and_add (t, stmt_p);
1245 /* Indicate that we need to restore the stack level when the
1246 enclosing BIND_EXPR is exited. */
1247 gimplify_ctxp->save_stack = true;
1250 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1251 and initialization explicit. */
1253 static enum gimplify_status
1254 gimplify_decl_expr (tree *stmt_p)
1256 tree stmt = *stmt_p;
1257 tree decl = DECL_EXPR_DECL (stmt);
1259 *stmt_p = NULL_TREE;
1261 if (TREE_TYPE (decl) == error_mark_node)
1262 return GS_ERROR;
1264 if ((TREE_CODE (decl) == TYPE_DECL
1265 || TREE_CODE (decl) == VAR_DECL)
1266 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1267 gimplify_type_sizes (TREE_TYPE (decl), stmt_p);
1269 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1271 tree init = DECL_INITIAL (decl);
1273 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
1274 gimplify_vla_decl (decl, stmt_p);
1276 if (init && init != error_mark_node)
1278 if (!TREE_STATIC (decl))
1280 DECL_INITIAL (decl) = NULL_TREE;
1281 init = build2 (INIT_EXPR, void_type_node, decl, init);
1282 gimplify_and_add (init, stmt_p);
1284 else
1285 /* We must still examine initializers for static variables
1286 as they may contain a label address. */
1287 walk_tree (&init, force_labels_r, NULL, NULL);
1290 /* Some front ends do not explicitly declare all anonymous
1291 artificial variables. We compensate here by declaring the
1292 variables, though it would be better if the front ends would
1293 explicitly declare them. */
1294 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1295 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1296 gimple_add_tmp_var (decl);
1299 return GS_ALL_DONE;
1302 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1303 and replacing the LOOP_EXPR with goto, but if the loop contains an
1304 EXIT_EXPR, we need to append a label for it to jump to. */
1306 static enum gimplify_status
1307 gimplify_loop_expr (tree *expr_p, tree *pre_p)
1309 tree saved_label = gimplify_ctxp->exit_label;
1310 tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
1311 tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label));
1313 append_to_statement_list (start_label, pre_p);
1315 gimplify_ctxp->exit_label = NULL_TREE;
1317 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1319 if (gimplify_ctxp->exit_label)
1321 append_to_statement_list (jump_stmt, pre_p);
1322 *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label);
1324 else
1325 *expr_p = jump_stmt;
1327 gimplify_ctxp->exit_label = saved_label;
1329 return GS_ALL_DONE;
1332 /* Compare two case labels. Because the front end should already have
1333 made sure that case ranges do not overlap, it is enough to only compare
1334 the CASE_LOW values of each case label. */
1336 static int
1337 compare_case_labels (const void *p1, const void *p2)
1339 const_tree const case1 = *(const_tree const*)p1;
1340 const_tree const case2 = *(const_tree const*)p2;
1342 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1345 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1347 void
1348 sort_case_labels (tree label_vec)
1350 size_t len = TREE_VEC_LENGTH (label_vec);
1351 tree default_case = TREE_VEC_ELT (label_vec, len - 1);
1353 if (CASE_LOW (default_case))
1355 size_t i;
1357 /* The last label in the vector should be the default case
1358 but it is not. */
1359 for (i = 0; i < len; ++i)
1361 tree t = TREE_VEC_ELT (label_vec, i);
1362 if (!CASE_LOW (t))
1364 default_case = t;
1365 TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1);
1366 TREE_VEC_ELT (label_vec, len - 1) = default_case;
1367 break;
1372 qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree),
1373 compare_case_labels);
1376 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1377 branch to. */
1379 static enum gimplify_status
1380 gimplify_switch_expr (tree *expr_p, tree *pre_p)
1382 tree switch_expr = *expr_p;
1383 enum gimplify_status ret;
1385 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL,
1386 is_gimple_val, fb_rvalue);
1388 if (SWITCH_BODY (switch_expr))
1390 VEC(tree,heap) *labels, *saved_labels;
1391 tree label_vec, default_case = NULL_TREE;
1392 size_t i, len;
1394 /* If someone can be bothered to fill in the labels, they can
1395 be bothered to null out the body too. */
1396 gcc_assert (!SWITCH_LABELS (switch_expr));
1398 saved_labels = gimplify_ctxp->case_labels;
1399 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1401 gimplify_to_stmt_list (&SWITCH_BODY (switch_expr));
1403 labels = gimplify_ctxp->case_labels;
1404 gimplify_ctxp->case_labels = saved_labels;
1406 i = 0;
1407 while (i < VEC_length (tree, labels))
1409 tree elt = VEC_index (tree, labels, i);
1410 tree low = CASE_LOW (elt);
1411 bool remove_element = FALSE;
1413 if (low)
1415 /* Discard empty ranges. */
1416 tree high = CASE_HIGH (elt);
1417 if (high && tree_int_cst_lt (high, low))
1418 remove_element = TRUE;
1420 else
1422 /* The default case must be the last label in the list. */
1423 gcc_assert (!default_case);
1424 default_case = elt;
1425 remove_element = TRUE;
1428 if (remove_element)
1429 VEC_ordered_remove (tree, labels, i);
1430 else
1431 i++;
1433 len = i;
1435 label_vec = make_tree_vec (len + 1);
1436 SWITCH_LABELS (*expr_p) = label_vec;
1437 append_to_statement_list (switch_expr, pre_p);
1439 if (! default_case)
1441 /* If the switch has no default label, add one, so that we jump
1442 around the switch body. */
1443 default_case = build3 (CASE_LABEL_EXPR, void_type_node, NULL_TREE,
1444 NULL_TREE, create_artificial_label ());
1445 append_to_statement_list (SWITCH_BODY (switch_expr), pre_p);
1446 *expr_p = build1 (LABEL_EXPR, void_type_node,
1447 CASE_LABEL (default_case));
1449 else
1450 *expr_p = SWITCH_BODY (switch_expr);
1452 for (i = 0; i < len; ++i)
1453 TREE_VEC_ELT (label_vec, i) = VEC_index (tree, labels, i);
1454 TREE_VEC_ELT (label_vec, len) = default_case;
1456 VEC_free (tree, heap, labels);
1458 sort_case_labels (label_vec);
1460 SWITCH_BODY (switch_expr) = NULL;
1462 else
1463 gcc_assert (SWITCH_LABELS (switch_expr));
1465 return ret;
1468 static enum gimplify_status
1469 gimplify_case_label_expr (tree *expr_p)
1471 tree expr = *expr_p;
1472 struct gimplify_ctx *ctxp;
1474 /* Invalid OpenMP programs can play Duff's Device type games with
1475 #pragma omp parallel. At least in the C front end, we don't
1476 detect such invalid branches until after gimplification. */
1477 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1478 if (ctxp->case_labels)
1479 break;
1481 VEC_safe_push (tree, heap, ctxp->case_labels, expr);
1482 *expr_p = build1 (LABEL_EXPR, void_type_node, CASE_LABEL (expr));
1483 return GS_ALL_DONE;
1486 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1487 if necessary. */
1489 tree
1490 build_and_jump (tree *label_p)
1492 if (label_p == NULL)
1493 /* If there's nowhere to jump, just fall through. */
1494 return NULL_TREE;
1496 if (*label_p == NULL_TREE)
1498 tree label = create_artificial_label ();
1499 *label_p = label;
1502 return build1 (GOTO_EXPR, void_type_node, *label_p);
1505 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1506 This also involves building a label to jump to and communicating it to
1507 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1509 static enum gimplify_status
1510 gimplify_exit_expr (tree *expr_p)
1512 tree cond = TREE_OPERAND (*expr_p, 0);
1513 tree expr;
1515 expr = build_and_jump (&gimplify_ctxp->exit_label);
1516 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1517 *expr_p = expr;
1519 return GS_OK;
1522 /* A helper function to be called via walk_tree. Mark all labels under *TP
1523 as being forced. To be called for DECL_INITIAL of static variables. */
1525 tree
1526 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1528 if (TYPE_P (*tp))
1529 *walk_subtrees = 0;
1530 if (TREE_CODE (*tp) == LABEL_DECL)
1531 FORCED_LABEL (*tp) = 1;
1533 return NULL_TREE;
1536 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1537 different from its canonical type, wrap the whole thing inside a
1538 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1539 type.
1541 The canonical type of a COMPONENT_REF is the type of the field being
1542 referenced--unless the field is a bit-field which can be read directly
1543 in a smaller mode, in which case the canonical type is the
1544 sign-appropriate type corresponding to that mode. */
1546 static void
1547 canonicalize_component_ref (tree *expr_p)
1549 tree expr = *expr_p;
1550 tree type;
1552 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1554 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1555 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1556 else
1557 type = TREE_TYPE (TREE_OPERAND (expr, 1));
1559 /* One could argue that all the stuff below is not necessary for
1560 the non-bitfield case and declare it a FE error if type
1561 adjustment would be needed. */
1562 if (TREE_TYPE (expr) != type)
1564 #ifdef ENABLE_TYPES_CHECKING
1565 tree old_type = TREE_TYPE (expr);
1566 #endif
1567 int type_quals;
1569 /* We need to preserve qualifiers and propagate them from
1570 operand 0. */
1571 type_quals = TYPE_QUALS (type)
1572 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1573 if (TYPE_QUALS (type) != type_quals)
1574 type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1576 /* Set the type of the COMPONENT_REF to the underlying type. */
1577 TREE_TYPE (expr) = type;
1579 #ifdef ENABLE_TYPES_CHECKING
1580 /* It is now a FE error, if the conversion from the canonical
1581 type to the original expression type is not useless. */
1582 gcc_assert (useless_type_conversion_p (old_type, type));
1583 #endif
1587 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1588 to foo, embed that change in the ADDR_EXPR by converting
1589 T array[U];
1590 (T *)&array
1592 &array[L]
1593 where L is the lower bound. For simplicity, only do this for constant
1594 lower bound.
1595 The constraint is that the type of &array[L] is trivially convertible
1596 to T *. */
1598 static void
1599 canonicalize_addr_expr (tree *expr_p)
1601 tree expr = *expr_p;
1602 tree addr_expr = TREE_OPERAND (expr, 0);
1603 tree datype, ddatype, pddatype;
1605 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1606 if (!POINTER_TYPE_P (TREE_TYPE (expr))
1607 || TREE_CODE (addr_expr) != ADDR_EXPR)
1608 return;
1610 /* The addr_expr type should be a pointer to an array. */
1611 datype = TREE_TYPE (TREE_TYPE (addr_expr));
1612 if (TREE_CODE (datype) != ARRAY_TYPE)
1613 return;
1615 /* The pointer to element type shall be trivially convertible to
1616 the expression pointer type. */
1617 ddatype = TREE_TYPE (datype);
1618 pddatype = build_pointer_type (ddatype);
1619 if (!useless_type_conversion_p (pddatype, ddatype))
1620 return;
1622 /* The lower bound and element sizes must be constant. */
1623 if (!TYPE_SIZE_UNIT (ddatype)
1624 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1625 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1626 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1627 return;
1629 /* All checks succeeded. Build a new node to merge the cast. */
1630 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1631 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1632 NULL_TREE, NULL_TREE);
1633 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1636 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1637 underneath as appropriate. */
1639 static enum gimplify_status
1640 gimplify_conversion (tree *expr_p)
1642 tree tem;
1643 gcc_assert (TREE_CODE (*expr_p) == NOP_EXPR
1644 || TREE_CODE (*expr_p) == CONVERT_EXPR);
1646 /* Then strip away all but the outermost conversion. */
1647 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1649 /* And remove the outermost conversion if it's useless. */
1650 if (tree_ssa_useless_type_conversion (*expr_p))
1651 *expr_p = TREE_OPERAND (*expr_p, 0);
1653 /* Attempt to avoid NOP_EXPR by producing reference to a subtype.
1654 For example this fold (subclass *)&A into &A->subclass avoiding
1655 a need for statement. */
1656 if (TREE_CODE (*expr_p) == NOP_EXPR
1657 && POINTER_TYPE_P (TREE_TYPE (*expr_p))
1658 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0)))
1659 && (tem = maybe_fold_offset_to_reference
1660 (TREE_OPERAND (*expr_p, 0),
1661 integer_zero_node, TREE_TYPE (TREE_TYPE (*expr_p)))))
1663 tree ptr_type = build_pointer_type (TREE_TYPE (tem));
1664 if (useless_type_conversion_p (TREE_TYPE (*expr_p), ptr_type))
1665 *expr_p = build_fold_addr_expr_with_type (tem, ptr_type);
1668 /* If we still have a conversion at the toplevel,
1669 then canonicalize some constructs. */
1670 if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR)
1672 tree sub = TREE_OPERAND (*expr_p, 0);
1674 /* If a NOP conversion is changing the type of a COMPONENT_REF
1675 expression, then canonicalize its type now in order to expose more
1676 redundant conversions. */
1677 if (TREE_CODE (sub) == COMPONENT_REF)
1678 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1680 /* If a NOP conversion is changing a pointer to array of foo
1681 to a pointer to foo, embed that change in the ADDR_EXPR. */
1682 else if (TREE_CODE (sub) == ADDR_EXPR)
1683 canonicalize_addr_expr (expr_p);
1686 return GS_OK;
1689 /* Gimplify a VAR_DECL or PARM_DECL. Returns GS_OK if we expanded a
1690 DECL_VALUE_EXPR, and it's worth re-examining things. */
1692 static enum gimplify_status
1693 gimplify_var_or_parm_decl (tree *expr_p)
1695 tree decl = *expr_p;
1697 /* ??? If this is a local variable, and it has not been seen in any
1698 outer BIND_EXPR, then it's probably the result of a duplicate
1699 declaration, for which we've already issued an error. It would
1700 be really nice if the front end wouldn't leak these at all.
1701 Currently the only known culprit is C++ destructors, as seen
1702 in g++.old-deja/g++.jason/binding.C. */
1703 if (TREE_CODE (decl) == VAR_DECL
1704 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1705 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1706 && decl_function_context (decl) == current_function_decl)
1708 gcc_assert (errorcount || sorrycount);
1709 return GS_ERROR;
1712 /* When within an OpenMP context, notice uses of variables. */
1713 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1714 return GS_ALL_DONE;
1716 /* If the decl is an alias for another expression, substitute it now. */
1717 if (DECL_HAS_VALUE_EXPR_P (decl))
1719 *expr_p = unshare_expr (DECL_VALUE_EXPR (decl));
1720 return GS_OK;
1723 return GS_ALL_DONE;
1727 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1728 node pointed to by EXPR_P.
1730 compound_lval
1731 : min_lval '[' val ']'
1732 | min_lval '.' ID
1733 | compound_lval '[' val ']'
1734 | compound_lval '.' ID
1736 This is not part of the original SIMPLE definition, which separates
1737 array and member references, but it seems reasonable to handle them
1738 together. Also, this way we don't run into problems with union
1739 aliasing; gcc requires that for accesses through a union to alias, the
1740 union reference must be explicit, which was not always the case when we
1741 were splitting up array and member refs.
1743 PRE_P points to the list where side effects that must happen before
1744 *EXPR_P should be stored.
1746 POST_P points to the list where side effects that must happen after
1747 *EXPR_P should be stored. */
1749 static enum gimplify_status
1750 gimplify_compound_lval (tree *expr_p, tree *pre_p,
1751 tree *post_p, fallback_t fallback)
1753 tree *p;
1754 VEC(tree,heap) *stack;
1755 enum gimplify_status ret = GS_OK, tret;
1756 int i;
1758 /* Create a stack of the subexpressions so later we can walk them in
1759 order from inner to outer. */
1760 stack = VEC_alloc (tree, heap, 10);
1762 /* We can handle anything that get_inner_reference can deal with. */
1763 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
1765 restart:
1766 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
1767 if (TREE_CODE (*p) == INDIRECT_REF)
1768 *p = fold_indirect_ref (*p);
1770 if (handled_component_p (*p))
1772 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
1773 additional COMPONENT_REFs. */
1774 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
1775 && gimplify_var_or_parm_decl (p) == GS_OK)
1776 goto restart;
1777 else
1778 break;
1780 VEC_safe_push (tree, heap, stack, *p);
1783 gcc_assert (VEC_length (tree, stack));
1785 /* Now STACK is a stack of pointers to all the refs we've walked through
1786 and P points to the innermost expression.
1788 Java requires that we elaborated nodes in source order. That
1789 means we must gimplify the inner expression followed by each of
1790 the indices, in order. But we can't gimplify the inner
1791 expression until we deal with any variable bounds, sizes, or
1792 positions in order to deal with PLACEHOLDER_EXPRs.
1794 So we do this in three steps. First we deal with the annotations
1795 for any variables in the components, then we gimplify the base,
1796 then we gimplify any indices, from left to right. */
1797 for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
1799 tree t = VEC_index (tree, stack, i);
1801 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1803 /* Gimplify the low bound and element type size and put them into
1804 the ARRAY_REF. If these values are set, they have already been
1805 gimplified. */
1806 if (!TREE_OPERAND (t, 2))
1808 tree low = unshare_expr (array_ref_low_bound (t));
1809 if (!is_gimple_min_invariant (low))
1811 TREE_OPERAND (t, 2) = low;
1812 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1813 is_gimple_formal_tmp_reg, fb_rvalue);
1814 ret = MIN (ret, tret);
1818 if (!TREE_OPERAND (t, 3))
1820 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1821 tree elmt_size = unshare_expr (array_ref_element_size (t));
1822 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
1824 /* Divide the element size by the alignment of the element
1825 type (above). */
1826 elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor);
1828 if (!is_gimple_min_invariant (elmt_size))
1830 TREE_OPERAND (t, 3) = elmt_size;
1831 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
1832 is_gimple_formal_tmp_reg, fb_rvalue);
1833 ret = MIN (ret, tret);
1837 else if (TREE_CODE (t) == COMPONENT_REF)
1839 /* Set the field offset into T and gimplify it. */
1840 if (!TREE_OPERAND (t, 2))
1842 tree offset = unshare_expr (component_ref_field_offset (t));
1843 tree field = TREE_OPERAND (t, 1);
1844 tree factor
1845 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
1847 /* Divide the offset by its alignment. */
1848 offset = size_binop (EXACT_DIV_EXPR, offset, factor);
1850 if (!is_gimple_min_invariant (offset))
1852 TREE_OPERAND (t, 2) = offset;
1853 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1854 is_gimple_formal_tmp_reg, fb_rvalue);
1855 ret = MIN (ret, tret);
1861 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
1862 so as to match the min_lval predicate. Failure to do so may result
1863 in the creation of large aggregate temporaries. */
1864 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
1865 fallback | fb_lvalue);
1866 ret = MIN (ret, tret);
1868 /* And finally, the indices and operands to BIT_FIELD_REF. During this
1869 loop we also remove any useless conversions. */
1870 for (; VEC_length (tree, stack) > 0; )
1872 tree t = VEC_pop (tree, stack);
1874 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1876 /* Gimplify the dimension.
1877 Temporary fix for gcc.c-torture/execute/20040313-1.c.
1878 Gimplify non-constant array indices into a temporary
1879 variable.
1880 FIXME - The real fix is to gimplify post-modify
1881 expressions into a minimal gimple lvalue. However, that
1882 exposes bugs in alias analysis. The alias analyzer does
1883 not handle &PTR->FIELD very well. Will fix after the
1884 branch is merged into mainline (dnovillo 2004-05-03). */
1885 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
1887 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1888 is_gimple_formal_tmp_reg, fb_rvalue);
1889 ret = MIN (ret, tret);
1892 else if (TREE_CODE (t) == BIT_FIELD_REF)
1894 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1895 is_gimple_val, fb_rvalue);
1896 ret = MIN (ret, tret);
1897 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1898 is_gimple_val, fb_rvalue);
1899 ret = MIN (ret, tret);
1902 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
1904 /* The innermost expression P may have originally had TREE_SIDE_EFFECTS
1905 set which would have caused all the outer expressions in EXPR_P
1906 leading to P to also have had TREE_SIDE_EFFECTS set. */
1907 recalculate_side_effects (t);
1910 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, fallback);
1911 ret = MIN (ret, tret);
1913 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
1914 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
1916 canonicalize_component_ref (expr_p);
1917 ret = MIN (ret, GS_OK);
1920 VEC_free (tree, heap, stack);
1922 return ret;
1925 /* Gimplify the self modifying expression pointed to by EXPR_P
1926 (++, --, +=, -=).
1928 PRE_P points to the list where side effects that must happen before
1929 *EXPR_P should be stored.
1931 POST_P points to the list where side effects that must happen after
1932 *EXPR_P should be stored.
1934 WANT_VALUE is nonzero iff we want to use the value of this expression
1935 in another expression. */
1937 static enum gimplify_status
1938 gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p,
1939 bool want_value)
1941 enum tree_code code;
1942 tree lhs, lvalue, rhs, t1, post = NULL, *orig_post_p = post_p;
1943 bool postfix;
1944 enum tree_code arith_code;
1945 enum gimplify_status ret;
1947 code = TREE_CODE (*expr_p);
1949 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
1950 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
1952 /* Prefix or postfix? */
1953 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1954 /* Faster to treat as prefix if result is not used. */
1955 postfix = want_value;
1956 else
1957 postfix = false;
1959 /* For postfix, make sure the inner expression's post side effects
1960 are executed after side effects from this expression. */
1961 if (postfix)
1962 post_p = &post;
1964 /* Add or subtract? */
1965 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
1966 arith_code = PLUS_EXPR;
1967 else
1968 arith_code = MINUS_EXPR;
1970 /* Gimplify the LHS into a GIMPLE lvalue. */
1971 lvalue = TREE_OPERAND (*expr_p, 0);
1972 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
1973 if (ret == GS_ERROR)
1974 return ret;
1976 /* Extract the operands to the arithmetic operation. */
1977 lhs = lvalue;
1978 rhs = TREE_OPERAND (*expr_p, 1);
1980 /* For postfix operator, we evaluate the LHS to an rvalue and then use
1981 that as the result value and in the postqueue operation. */
1982 if (postfix)
1984 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
1985 if (ret == GS_ERROR)
1986 return ret;
1989 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
1990 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
1992 rhs = fold_convert (sizetype, rhs);
1993 if (arith_code == MINUS_EXPR)
1994 rhs = fold_build1 (NEGATE_EXPR, TREE_TYPE (rhs), rhs);
1995 arith_code = POINTER_PLUS_EXPR;
1998 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
1999 t1 = build_gimple_modify_stmt (lvalue, t1);
2001 if (postfix)
2003 gimplify_and_add (t1, orig_post_p);
2004 append_to_statement_list (post, orig_post_p);
2005 *expr_p = lhs;
2006 return GS_ALL_DONE;
2008 else
2010 *expr_p = t1;
2011 return GS_OK;
2015 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2017 static void
2018 maybe_with_size_expr (tree *expr_p)
2020 tree expr = *expr_p;
2021 tree type = TREE_TYPE (expr);
2022 tree size;
2024 /* If we've already wrapped this or the type is error_mark_node, we can't do
2025 anything. */
2026 if (TREE_CODE (expr) == WITH_SIZE_EXPR
2027 || type == error_mark_node)
2028 return;
2030 /* If the size isn't known or is a constant, we have nothing to do. */
2031 size = TYPE_SIZE_UNIT (type);
2032 if (!size || TREE_CODE (size) == INTEGER_CST)
2033 return;
2035 /* Otherwise, make a WITH_SIZE_EXPR. */
2036 size = unshare_expr (size);
2037 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2038 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2041 /* Subroutine of gimplify_call_expr: Gimplify a single argument. */
2043 static enum gimplify_status
2044 gimplify_arg (tree *expr_p, tree *pre_p)
2046 bool (*test) (tree);
2047 fallback_t fb;
2049 /* In general, we allow lvalues for function arguments to avoid
2050 extra overhead of copying large aggregates out of even larger
2051 aggregates into temporaries only to copy the temporaries to
2052 the argument list. Make optimizers happy by pulling out to
2053 temporaries those types that fit in registers. */
2054 if (is_gimple_reg_type (TREE_TYPE (*expr_p)))
2055 test = is_gimple_val, fb = fb_rvalue;
2056 else
2057 test = is_gimple_lvalue, fb = fb_either;
2059 /* If this is a variable sized type, we must remember the size. */
2060 maybe_with_size_expr (expr_p);
2062 /* There is a sequence point before a function call. Side effects in
2063 the argument list must occur before the actual call. So, when
2064 gimplifying arguments, force gimplify_expr to use an internal
2065 post queue which is then appended to the end of PRE_P. */
2066 return gimplify_expr (expr_p, pre_p, NULL, test, fb);
2069 /* Gimplify the CALL_EXPR node pointed to by EXPR_P. PRE_P points to the
2070 list where side effects that must happen before *EXPR_P should be stored.
2071 WANT_VALUE is true if the result of the call is desired. */
2073 static enum gimplify_status
2074 gimplify_call_expr (tree *expr_p, tree *pre_p, bool want_value)
2076 tree decl, parms, p;
2077 enum gimplify_status ret;
2078 int i, nargs;
2080 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2082 /* For reliable diagnostics during inlining, it is necessary that
2083 every call_expr be annotated with file and line. */
2084 if (! EXPR_HAS_LOCATION (*expr_p))
2085 SET_EXPR_LOCATION (*expr_p, input_location);
2087 /* This may be a call to a builtin function.
2089 Builtin function calls may be transformed into different
2090 (and more efficient) builtin function calls under certain
2091 circumstances. Unfortunately, gimplification can muck things
2092 up enough that the builtin expanders are not aware that certain
2093 transformations are still valid.
2095 So we attempt transformation/gimplification of the call before
2096 we gimplify the CALL_EXPR. At this time we do not manage to
2097 transform all calls in the same manner as the expanders do, but
2098 we do transform most of them. */
2099 decl = get_callee_fndecl (*expr_p);
2100 if (decl && DECL_BUILT_IN (decl))
2102 tree new = fold_call_expr (*expr_p, !want_value);
2104 if (new && new != *expr_p)
2106 /* There was a transformation of this call which computes the
2107 same value, but in a more efficient way. Return and try
2108 again. */
2109 *expr_p = new;
2110 return GS_OK;
2113 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2114 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_START)
2116 if (call_expr_nargs (*expr_p) < 2)
2118 error ("too few arguments to function %<va_start%>");
2119 *expr_p = build_empty_stmt ();
2120 return GS_OK;
2123 if (fold_builtin_next_arg (*expr_p, true))
2125 *expr_p = build_empty_stmt ();
2126 return GS_OK;
2128 /* Avoid gimplifying the second argument to va_start, which needs
2129 to be the plain PARM_DECL. */
2130 return gimplify_arg (&CALL_EXPR_ARG (*expr_p, 0), pre_p);
2134 /* There is a sequence point before the call, so any side effects in
2135 the calling expression must occur before the actual call. Force
2136 gimplify_expr to use an internal post queue. */
2137 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2138 is_gimple_call_addr, fb_rvalue);
2140 nargs = call_expr_nargs (*expr_p);
2142 /* Get argument types for verification. */
2143 decl = get_callee_fndecl (*expr_p);
2144 parms = NULL_TREE;
2145 if (decl)
2146 parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
2147 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2148 parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2150 /* Verify if the type of the argument matches that of the function
2151 declaration. If we cannot verify this or there is a mismatch,
2152 mark the call expression so it doesn't get inlined later. */
2153 if (decl && DECL_ARGUMENTS (decl))
2155 for (i = 0, p = DECL_ARGUMENTS (decl); i < nargs;
2156 i++, p = TREE_CHAIN (p))
2158 /* We cannot distinguish a varargs function from the case
2159 of excess parameters, still deferring the inlining decision
2160 to the callee is possible. */
2161 if (!p)
2162 break;
2163 if (p == error_mark_node
2164 || CALL_EXPR_ARG (*expr_p, i) == error_mark_node
2165 || !fold_convertible_p (DECL_ARG_TYPE (p),
2166 CALL_EXPR_ARG (*expr_p, i)))
2168 CALL_CANNOT_INLINE_P (*expr_p) = 1;
2169 break;
2173 else if (parms)
2175 for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
2177 /* If this is a varargs function defer inlining decision
2178 to callee. */
2179 if (!p)
2180 break;
2181 if (TREE_VALUE (p) == error_mark_node
2182 || CALL_EXPR_ARG (*expr_p, i) == error_mark_node
2183 || TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
2184 || !fold_convertible_p (TREE_VALUE (p),
2185 CALL_EXPR_ARG (*expr_p, i)))
2187 CALL_CANNOT_INLINE_P (*expr_p) = 1;
2188 break;
2192 else
2194 if (nargs != 0)
2195 CALL_CANNOT_INLINE_P (*expr_p) = 1;
2196 i = 0;
2197 p = NULL_TREE;
2200 /* If the last argument is __builtin_va_arg_pack () and it is not
2201 passed as a named argument, decrease the number of CALL_EXPR
2202 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2203 if (!p
2204 && i < nargs
2205 && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2207 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2208 tree last_arg_fndecl = get_callee_fndecl (last_arg);
2210 if (last_arg_fndecl
2211 && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2212 && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2213 && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2215 tree call = *expr_p;
2217 --nargs;
2218 *expr_p = build_call_array (TREE_TYPE (call), CALL_EXPR_FN (call),
2219 nargs, CALL_EXPR_ARGP (call));
2220 /* Copy all CALL_EXPR flags, locus and block, except
2221 CALL_EXPR_VA_ARG_PACK flag. */
2222 CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2223 CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2224 CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2225 = CALL_EXPR_RETURN_SLOT_OPT (call);
2226 CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2227 CALL_CANNOT_INLINE_P (*expr_p)
2228 = CALL_CANNOT_INLINE_P (call);
2229 TREE_NOTHROW (*expr_p) = TREE_NOTHROW (call);
2230 SET_EXPR_LOCUS (*expr_p, EXPR_LOCUS (call));
2231 TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2232 /* Set CALL_EXPR_VA_ARG_PACK. */
2233 CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2237 /* Finally, gimplify the function arguments. */
2238 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2239 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2240 PUSH_ARGS_REVERSED ? i-- : i++)
2242 enum gimplify_status t;
2244 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p);
2246 if (t == GS_ERROR)
2247 ret = GS_ERROR;
2250 /* Try this again in case gimplification exposed something. */
2251 if (ret != GS_ERROR)
2253 tree new = fold_call_expr (*expr_p, !want_value);
2255 if (new && new != *expr_p)
2257 /* There was a transformation of this call which computes the
2258 same value, but in a more efficient way. Return and try
2259 again. */
2260 *expr_p = new;
2261 return GS_OK;
2265 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2266 decl. This allows us to eliminate redundant or useless
2267 calls to "const" functions. */
2268 if (TREE_CODE (*expr_p) == CALL_EXPR
2269 && (call_expr_flags (*expr_p) & (ECF_CONST | ECF_PURE)))
2270 TREE_SIDE_EFFECTS (*expr_p) = 0;
2272 return ret;
2275 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2276 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2278 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2279 condition is true or false, respectively. If null, we should generate
2280 our own to skip over the evaluation of this specific expression.
2282 This function is the tree equivalent of do_jump.
2284 shortcut_cond_r should only be called by shortcut_cond_expr. */
2286 static tree
2287 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p)
2289 tree local_label = NULL_TREE;
2290 tree t, expr = NULL;
2292 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2293 retain the shortcut semantics. Just insert the gotos here;
2294 shortcut_cond_expr will append the real blocks later. */
2295 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2297 /* Turn if (a && b) into
2299 if (a); else goto no;
2300 if (b) goto yes; else goto no;
2301 (no:) */
2303 if (false_label_p == NULL)
2304 false_label_p = &local_label;
2306 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p);
2307 append_to_statement_list (t, &expr);
2309 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2310 false_label_p);
2311 append_to_statement_list (t, &expr);
2313 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2315 /* Turn if (a || b) into
2317 if (a) goto yes;
2318 if (b) goto yes; else goto no;
2319 (yes:) */
2321 if (true_label_p == NULL)
2322 true_label_p = &local_label;
2324 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL);
2325 append_to_statement_list (t, &expr);
2327 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2328 false_label_p);
2329 append_to_statement_list (t, &expr);
2331 else if (TREE_CODE (pred) == COND_EXPR)
2333 /* As long as we're messing with gotos, turn if (a ? b : c) into
2334 if (a)
2335 if (b) goto yes; else goto no;
2336 else
2337 if (c) goto yes; else goto no; */
2338 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2339 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2340 false_label_p),
2341 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2342 false_label_p));
2344 else
2346 expr = build3 (COND_EXPR, void_type_node, pred,
2347 build_and_jump (true_label_p),
2348 build_and_jump (false_label_p));
2351 if (local_label)
2353 t = build1 (LABEL_EXPR, void_type_node, local_label);
2354 append_to_statement_list (t, &expr);
2357 return expr;
2360 static tree
2361 shortcut_cond_expr (tree expr)
2363 tree pred = TREE_OPERAND (expr, 0);
2364 tree then_ = TREE_OPERAND (expr, 1);
2365 tree else_ = TREE_OPERAND (expr, 2);
2366 tree true_label, false_label, end_label, t;
2367 tree *true_label_p;
2368 tree *false_label_p;
2369 bool emit_end, emit_false, jump_over_else;
2370 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2371 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2373 /* First do simple transformations. */
2374 if (!else_se)
2376 /* If there is no 'else', turn (a && b) into if (a) if (b). */
2377 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2379 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2380 then_ = shortcut_cond_expr (expr);
2381 then_se = then_ && TREE_SIDE_EFFECTS (then_);
2382 pred = TREE_OPERAND (pred, 0);
2383 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2386 if (!then_se)
2388 /* If there is no 'then', turn
2389 if (a || b); else d
2390 into
2391 if (a); else if (b); else d. */
2392 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2394 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2395 else_ = shortcut_cond_expr (expr);
2396 else_se = else_ && TREE_SIDE_EFFECTS (else_);
2397 pred = TREE_OPERAND (pred, 0);
2398 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2402 /* If we're done, great. */
2403 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2404 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2405 return expr;
2407 /* Otherwise we need to mess with gotos. Change
2408 if (a) c; else d;
2410 if (a); else goto no;
2411 c; goto end;
2412 no: d; end:
2413 and recursively gimplify the condition. */
2415 true_label = false_label = end_label = NULL_TREE;
2417 /* If our arms just jump somewhere, hijack those labels so we don't
2418 generate jumps to jumps. */
2420 if (then_
2421 && TREE_CODE (then_) == GOTO_EXPR
2422 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2424 true_label = GOTO_DESTINATION (then_);
2425 then_ = NULL;
2426 then_se = false;
2429 if (else_
2430 && TREE_CODE (else_) == GOTO_EXPR
2431 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2433 false_label = GOTO_DESTINATION (else_);
2434 else_ = NULL;
2435 else_se = false;
2438 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2439 if (true_label)
2440 true_label_p = &true_label;
2441 else
2442 true_label_p = NULL;
2444 /* The 'else' branch also needs a label if it contains interesting code. */
2445 if (false_label || else_se)
2446 false_label_p = &false_label;
2447 else
2448 false_label_p = NULL;
2450 /* If there was nothing else in our arms, just forward the label(s). */
2451 if (!then_se && !else_se)
2452 return shortcut_cond_r (pred, true_label_p, false_label_p);
2454 /* If our last subexpression already has a terminal label, reuse it. */
2455 if (else_se)
2456 expr = expr_last (else_);
2457 else if (then_se)
2458 expr = expr_last (then_);
2459 else
2460 expr = NULL;
2461 if (expr && TREE_CODE (expr) == LABEL_EXPR)
2462 end_label = LABEL_EXPR_LABEL (expr);
2464 /* If we don't care about jumping to the 'else' branch, jump to the end
2465 if the condition is false. */
2466 if (!false_label_p)
2467 false_label_p = &end_label;
2469 /* We only want to emit these labels if we aren't hijacking them. */
2470 emit_end = (end_label == NULL_TREE);
2471 emit_false = (false_label == NULL_TREE);
2473 /* We only emit the jump over the else clause if we have to--if the
2474 then clause may fall through. Otherwise we can wind up with a
2475 useless jump and a useless label at the end of gimplified code,
2476 which will cause us to think that this conditional as a whole
2477 falls through even if it doesn't. If we then inline a function
2478 which ends with such a condition, that can cause us to issue an
2479 inappropriate warning about control reaching the end of a
2480 non-void function. */
2481 jump_over_else = block_may_fallthru (then_);
2483 pred = shortcut_cond_r (pred, true_label_p, false_label_p);
2485 expr = NULL;
2486 append_to_statement_list (pred, &expr);
2488 append_to_statement_list (then_, &expr);
2489 if (else_se)
2491 if (jump_over_else)
2493 t = build_and_jump (&end_label);
2494 append_to_statement_list (t, &expr);
2496 if (emit_false)
2498 t = build1 (LABEL_EXPR, void_type_node, false_label);
2499 append_to_statement_list (t, &expr);
2501 append_to_statement_list (else_, &expr);
2503 if (emit_end && end_label)
2505 t = build1 (LABEL_EXPR, void_type_node, end_label);
2506 append_to_statement_list (t, &expr);
2509 return expr;
2512 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2514 tree
2515 gimple_boolify (tree expr)
2517 tree type = TREE_TYPE (expr);
2519 if (TREE_CODE (type) == BOOLEAN_TYPE)
2520 return expr;
2522 switch (TREE_CODE (expr))
2524 case TRUTH_AND_EXPR:
2525 case TRUTH_OR_EXPR:
2526 case TRUTH_XOR_EXPR:
2527 case TRUTH_ANDIF_EXPR:
2528 case TRUTH_ORIF_EXPR:
2529 /* Also boolify the arguments of truth exprs. */
2530 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2531 /* FALLTHRU */
2533 case TRUTH_NOT_EXPR:
2534 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2535 /* FALLTHRU */
2537 case EQ_EXPR: case NE_EXPR:
2538 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2539 /* These expressions always produce boolean results. */
2540 TREE_TYPE (expr) = boolean_type_node;
2541 return expr;
2543 default:
2544 /* Other expressions that get here must have boolean values, but
2545 might need to be converted to the appropriate mode. */
2546 return fold_convert (boolean_type_node, expr);
2550 /* Given a conditional expression *EXPR_P without side effects, gimplify
2551 its operands. New statements are inserted to PRE_P. */
2553 static enum gimplify_status
2554 gimplify_pure_cond_expr (tree *expr_p, tree *pre_p)
2556 tree expr = *expr_p, cond;
2557 enum gimplify_status ret, tret;
2558 enum tree_code code;
2560 cond = gimple_boolify (COND_EXPR_COND (expr));
2562 /* We need to handle && and || specially, as their gimplification
2563 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
2564 code = TREE_CODE (cond);
2565 if (code == TRUTH_ANDIF_EXPR)
2566 TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2567 else if (code == TRUTH_ORIF_EXPR)
2568 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2569 ret = gimplify_expr (&cond, pre_p, NULL,
2570 is_gimple_condexpr, fb_rvalue);
2571 COND_EXPR_COND (*expr_p) = cond;
2573 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2574 is_gimple_val, fb_rvalue);
2575 ret = MIN (ret, tret);
2576 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2577 is_gimple_val, fb_rvalue);
2579 return MIN (ret, tret);
2582 /* Returns true if evaluating EXPR could trap.
2583 EXPR is GENERIC, while tree_could_trap_p can be called
2584 only on GIMPLE. */
2586 static bool
2587 generic_expr_could_trap_p (tree expr)
2589 unsigned i, n;
2591 if (!expr || is_gimple_val (expr))
2592 return false;
2594 if (!EXPR_P (expr) || tree_could_trap_p (expr))
2595 return true;
2597 n = TREE_OPERAND_LENGTH (expr);
2598 for (i = 0; i < n; i++)
2599 if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
2600 return true;
2602 return false;
2605 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2606 into
2608 if (p) if (p)
2609 t1 = a; a;
2610 else or else
2611 t1 = b; b;
2614 The second form is used when *EXPR_P is of type void.
2616 TARGET is the tree for T1 above.
2618 PRE_P points to the list where side effects that must happen before
2619 *EXPR_P should be stored. */
2621 static enum gimplify_status
2622 gimplify_cond_expr (tree *expr_p, tree *pre_p, fallback_t fallback)
2624 tree expr = *expr_p;
2625 tree tmp, tmp2, type;
2626 enum gimplify_status ret;
2628 type = TREE_TYPE (expr);
2630 /* If this COND_EXPR has a value, copy the values into a temporary within
2631 the arms. */
2632 if (! VOID_TYPE_P (type))
2634 tree result;
2636 /* If an rvalue is ok or we do not require an lvalue, avoid creating
2637 an addressable temporary. */
2638 if (((fallback & fb_rvalue)
2639 || !(fallback & fb_lvalue))
2640 && !TREE_ADDRESSABLE (type))
2642 if (gimplify_ctxp->allow_rhs_cond_expr
2643 /* If either branch has side effects or could trap, it can't be
2644 evaluated unconditionally. */
2645 && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
2646 && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
2647 && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
2648 && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 2)))
2649 return gimplify_pure_cond_expr (expr_p, pre_p);
2651 result = tmp2 = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
2652 ret = GS_ALL_DONE;
2654 else
2656 tree type = build_pointer_type (TREE_TYPE (expr));
2658 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2659 TREE_OPERAND (expr, 1) =
2660 build_fold_addr_expr (TREE_OPERAND (expr, 1));
2662 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2663 TREE_OPERAND (expr, 2) =
2664 build_fold_addr_expr (TREE_OPERAND (expr, 2));
2666 tmp2 = tmp = create_tmp_var (type, "iftmp");
2668 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
2669 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
2671 result = build_fold_indirect_ref (tmp);
2672 ret = GS_ALL_DONE;
2675 /* Build the then clause, 't1 = a;'. But don't build an assignment
2676 if this branch is void; in C++ it can be, if it's a throw. */
2677 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2678 TREE_OPERAND (expr, 1)
2679 = build_gimple_modify_stmt (tmp, TREE_OPERAND (expr, 1));
2681 /* Build the else clause, 't1 = b;'. */
2682 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2683 TREE_OPERAND (expr, 2)
2684 = build_gimple_modify_stmt (tmp2, TREE_OPERAND (expr, 2));
2686 TREE_TYPE (expr) = void_type_node;
2687 recalculate_side_effects (expr);
2689 /* Move the COND_EXPR to the prequeue. */
2690 gimplify_and_add (expr, pre_p);
2692 *expr_p = result;
2693 return ret;
2696 /* Make sure the condition has BOOLEAN_TYPE. */
2697 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2699 /* Break apart && and || conditions. */
2700 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2701 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2703 expr = shortcut_cond_expr (expr);
2705 if (expr != *expr_p)
2707 *expr_p = expr;
2709 /* We can't rely on gimplify_expr to re-gimplify the expanded
2710 form properly, as cleanups might cause the target labels to be
2711 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
2712 set up a conditional context. */
2713 gimple_push_condition ();
2714 gimplify_stmt (expr_p);
2715 gimple_pop_condition (pre_p);
2717 return GS_ALL_DONE;
2721 /* Now do the normal gimplification. */
2722 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2723 is_gimple_condexpr, fb_rvalue);
2725 gimple_push_condition ();
2727 gimplify_to_stmt_list (&TREE_OPERAND (expr, 1));
2728 gimplify_to_stmt_list (&TREE_OPERAND (expr, 2));
2729 recalculate_side_effects (expr);
2731 gimple_pop_condition (pre_p);
2733 if (ret == GS_ERROR)
2735 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2736 ret = GS_ALL_DONE;
2737 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2)))
2738 /* Rewrite "if (a); else b" to "if (!a) b" */
2740 TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0));
2741 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2742 is_gimple_condexpr, fb_rvalue);
2744 tmp = TREE_OPERAND (expr, 1);
2745 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2);
2746 TREE_OPERAND (expr, 2) = tmp;
2748 else
2749 /* Both arms are empty; replace the COND_EXPR with its predicate. */
2750 expr = TREE_OPERAND (expr, 0);
2752 *expr_p = expr;
2753 return ret;
2756 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
2757 a call to __builtin_memcpy. */
2759 static enum gimplify_status
2760 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value)
2762 tree t, to, to_ptr, from, from_ptr;
2764 to = GENERIC_TREE_OPERAND (*expr_p, 0);
2765 from = GENERIC_TREE_OPERAND (*expr_p, 1);
2767 from_ptr = build_fold_addr_expr (from);
2769 to_ptr = build_fold_addr_expr (to);
2770 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
2771 t = build_call_expr (t, 3, to_ptr, from_ptr, size);
2773 if (want_value)
2775 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2776 t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2779 *expr_p = t;
2780 return GS_OK;
2783 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
2784 a call to __builtin_memset. In this case we know that the RHS is
2785 a CONSTRUCTOR with an empty element list. */
2787 static enum gimplify_status
2788 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value)
2790 tree t, to, to_ptr;
2792 to = GENERIC_TREE_OPERAND (*expr_p, 0);
2794 to_ptr = build_fold_addr_expr (to);
2795 t = implicit_built_in_decls[BUILT_IN_MEMSET];
2796 t = build_call_expr (t, 3, to_ptr, integer_zero_node, size);
2798 if (want_value)
2800 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2801 t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2804 *expr_p = t;
2805 return GS_OK;
2808 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
2809 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
2810 assignment. Returns non-null if we detect a potential overlap. */
2812 struct gimplify_init_ctor_preeval_data
2814 /* The base decl of the lhs object. May be NULL, in which case we
2815 have to assume the lhs is indirect. */
2816 tree lhs_base_decl;
2818 /* The alias set of the lhs object. */
2819 alias_set_type lhs_alias_set;
2822 static tree
2823 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
2825 struct gimplify_init_ctor_preeval_data *data
2826 = (struct gimplify_init_ctor_preeval_data *) xdata;
2827 tree t = *tp;
2829 /* If we find the base object, obviously we have overlap. */
2830 if (data->lhs_base_decl == t)
2831 return t;
2833 /* If the constructor component is indirect, determine if we have a
2834 potential overlap with the lhs. The only bits of information we
2835 have to go on at this point are addressability and alias sets. */
2836 if (TREE_CODE (t) == INDIRECT_REF
2837 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
2838 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
2839 return t;
2841 /* If the constructor component is a call, determine if it can hide a
2842 potential overlap with the lhs through an INDIRECT_REF like above. */
2843 if (TREE_CODE (t) == CALL_EXPR)
2845 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
2847 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
2848 if (POINTER_TYPE_P (TREE_VALUE (type))
2849 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
2850 && alias_sets_conflict_p (data->lhs_alias_set,
2851 get_alias_set
2852 (TREE_TYPE (TREE_VALUE (type)))))
2853 return t;
2856 if (IS_TYPE_OR_DECL_P (t))
2857 *walk_subtrees = 0;
2858 return NULL;
2861 /* A subroutine of gimplify_init_constructor. Pre-evaluate *EXPR_P,
2862 force values that overlap with the lhs (as described by *DATA)
2863 into temporaries. */
2865 static void
2866 gimplify_init_ctor_preeval (tree *expr_p, tree *pre_p, tree *post_p,
2867 struct gimplify_init_ctor_preeval_data *data)
2869 enum gimplify_status one;
2871 /* If the value is invariant, then there's nothing to pre-evaluate.
2872 But ensure it doesn't have any side-effects since a SAVE_EXPR is
2873 invariant but has side effects and might contain a reference to
2874 the object we're initializing. */
2875 if (TREE_INVARIANT (*expr_p) && !TREE_SIDE_EFFECTS (*expr_p))
2876 return;
2878 /* If the type has non-trivial constructors, we can't pre-evaluate. */
2879 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
2880 return;
2882 /* Recurse for nested constructors. */
2883 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
2885 unsigned HOST_WIDE_INT ix;
2886 constructor_elt *ce;
2887 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
2889 for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
2890 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
2891 return;
2894 /* If this is a variable sized type, we must remember the size. */
2895 maybe_with_size_expr (expr_p);
2897 /* Gimplify the constructor element to something appropriate for the rhs
2898 of a MODIFY_EXPR. Given that we know the lhs is an aggregate, we know
2899 the gimplifier will consider this a store to memory. Doing this
2900 gimplification now means that we won't have to deal with complicated
2901 language-specific trees, nor trees like SAVE_EXPR that can induce
2902 exponential search behavior. */
2903 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
2904 if (one == GS_ERROR)
2906 *expr_p = NULL;
2907 return;
2910 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
2911 with the lhs, since "a = { .x=a }" doesn't make sense. This will
2912 always be true for all scalars, since is_gimple_mem_rhs insists on a
2913 temporary variable for them. */
2914 if (DECL_P (*expr_p))
2915 return;
2917 /* If this is of variable size, we have no choice but to assume it doesn't
2918 overlap since we can't make a temporary for it. */
2919 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
2920 return;
2922 /* Otherwise, we must search for overlap ... */
2923 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
2924 return;
2926 /* ... and if found, force the value into a temporary. */
2927 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
2930 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
2931 a RANGE_EXPR in a CONSTRUCTOR for an array.
2933 var = lower;
2934 loop_entry:
2935 object[var] = value;
2936 if (var == upper)
2937 goto loop_exit;
2938 var = var + 1;
2939 goto loop_entry;
2940 loop_exit:
2942 We increment var _after_ the loop exit check because we might otherwise
2943 fail if upper == TYPE_MAX_VALUE (type for upper).
2945 Note that we never have to deal with SAVE_EXPRs here, because this has
2946 already been taken care of for us, in gimplify_init_ctor_preeval(). */
2948 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
2949 tree *, bool);
2951 static void
2952 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
2953 tree value, tree array_elt_type,
2954 tree *pre_p, bool cleared)
2956 tree loop_entry_label, loop_exit_label;
2957 tree var, var_type, cref, tmp;
2959 loop_entry_label = create_artificial_label ();
2960 loop_exit_label = create_artificial_label ();
2962 /* Create and initialize the index variable. */
2963 var_type = TREE_TYPE (upper);
2964 var = create_tmp_var (var_type, NULL);
2965 append_to_statement_list (build_gimple_modify_stmt (var, lower), pre_p);
2967 /* Add the loop entry label. */
2968 append_to_statement_list (build1 (LABEL_EXPR,
2969 void_type_node,
2970 loop_entry_label),
2971 pre_p);
2973 /* Build the reference. */
2974 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
2975 var, NULL_TREE, NULL_TREE);
2977 /* If we are a constructor, just call gimplify_init_ctor_eval to do
2978 the store. Otherwise just assign value to the reference. */
2980 if (TREE_CODE (value) == CONSTRUCTOR)
2981 /* NB we might have to call ourself recursively through
2982 gimplify_init_ctor_eval if the value is a constructor. */
2983 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2984 pre_p, cleared);
2985 else
2986 append_to_statement_list (build_gimple_modify_stmt (cref, value), pre_p);
2988 /* We exit the loop when the index var is equal to the upper bound. */
2989 gimplify_and_add (build3 (COND_EXPR, void_type_node,
2990 build2 (EQ_EXPR, boolean_type_node,
2991 var, upper),
2992 build1 (GOTO_EXPR,
2993 void_type_node,
2994 loop_exit_label),
2995 NULL_TREE),
2996 pre_p);
2998 /* Otherwise, increment the index var... */
2999 tmp = build2 (PLUS_EXPR, var_type, var,
3000 fold_convert (var_type, integer_one_node));
3001 append_to_statement_list (build_gimple_modify_stmt (var, tmp), pre_p);
3003 /* ...and jump back to the loop entry. */
3004 append_to_statement_list (build1 (GOTO_EXPR,
3005 void_type_node,
3006 loop_entry_label),
3007 pre_p);
3009 /* Add the loop exit label. */
3010 append_to_statement_list (build1 (LABEL_EXPR,
3011 void_type_node,
3012 loop_exit_label),
3013 pre_p);
3016 /* Return true if FDECL is accessing a field that is zero sized. */
3018 static bool
3019 zero_sized_field_decl (const_tree fdecl)
3021 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3022 && integer_zerop (DECL_SIZE (fdecl)))
3023 return true;
3024 return false;
3027 /* Return true if TYPE is zero sized. */
3029 static bool
3030 zero_sized_type (const_tree type)
3032 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3033 && integer_zerop (TYPE_SIZE (type)))
3034 return true;
3035 return false;
3038 /* A subroutine of gimplify_init_constructor. Generate individual
3039 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3040 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3041 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3042 zeroed first. */
3044 static void
3045 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3046 tree *pre_p, bool cleared)
3048 tree array_elt_type = NULL;
3049 unsigned HOST_WIDE_INT ix;
3050 tree purpose, value;
3052 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3053 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3055 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3057 tree cref, init;
3059 /* NULL values are created above for gimplification errors. */
3060 if (value == NULL)
3061 continue;
3063 if (cleared && initializer_zerop (value))
3064 continue;
3066 /* ??? Here's to hoping the front end fills in all of the indices,
3067 so we don't have to figure out what's missing ourselves. */
3068 gcc_assert (purpose);
3070 /* Skip zero-sized fields, unless value has side-effects. This can
3071 happen with calls to functions returning a zero-sized type, which
3072 we shouldn't discard. As a number of downstream passes don't
3073 expect sets of zero-sized fields, we rely on the gimplification of
3074 the MODIFY_EXPR we make below to drop the assignment statement. */
3075 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3076 continue;
3078 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3079 whole range. */
3080 if (TREE_CODE (purpose) == RANGE_EXPR)
3082 tree lower = TREE_OPERAND (purpose, 0);
3083 tree upper = TREE_OPERAND (purpose, 1);
3085 /* If the lower bound is equal to upper, just treat it as if
3086 upper was the index. */
3087 if (simple_cst_equal (lower, upper))
3088 purpose = upper;
3089 else
3091 gimplify_init_ctor_eval_range (object, lower, upper, value,
3092 array_elt_type, pre_p, cleared);
3093 continue;
3097 if (array_elt_type)
3099 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3100 purpose, NULL_TREE, NULL_TREE);
3102 else
3104 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3105 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3106 unshare_expr (object), purpose, NULL_TREE);
3109 if (TREE_CODE (value) == CONSTRUCTOR
3110 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3111 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3112 pre_p, cleared);
3113 else
3115 init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3116 gimplify_and_add (init, pre_p);
3121 /* A subroutine of gimplify_modify_expr. Break out elements of a
3122 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3124 Note that we still need to clear any elements that don't have explicit
3125 initializers, so if not all elements are initialized we keep the
3126 original MODIFY_EXPR, we just remove all of the constructor elements.
3128 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3129 GS_ERROR if we would have to create a temporary when gimplifying
3130 this constructor. Otherwise, return GS_OK.
3132 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3134 static enum gimplify_status
3135 gimplify_init_constructor (tree *expr_p, tree *pre_p,
3136 tree *post_p, bool want_value,
3137 bool notify_temp_creation)
3139 tree object;
3140 tree ctor = GENERIC_TREE_OPERAND (*expr_p, 1);
3141 tree type = TREE_TYPE (ctor);
3142 enum gimplify_status ret;
3143 VEC(constructor_elt,gc) *elts;
3145 if (TREE_CODE (ctor) != CONSTRUCTOR)
3146 return GS_UNHANDLED;
3148 if (!notify_temp_creation)
3150 ret = gimplify_expr (&GENERIC_TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3151 is_gimple_lvalue, fb_lvalue);
3152 if (ret == GS_ERROR)
3153 return ret;
3155 object = GENERIC_TREE_OPERAND (*expr_p, 0);
3157 elts = CONSTRUCTOR_ELTS (ctor);
3159 ret = GS_ALL_DONE;
3160 switch (TREE_CODE (type))
3162 case RECORD_TYPE:
3163 case UNION_TYPE:
3164 case QUAL_UNION_TYPE:
3165 case ARRAY_TYPE:
3167 struct gimplify_init_ctor_preeval_data preeval_data;
3168 HOST_WIDE_INT num_type_elements, num_ctor_elements;
3169 HOST_WIDE_INT num_nonzero_elements;
3170 bool cleared, valid_const_initializer;
3172 /* Aggregate types must lower constructors to initialization of
3173 individual elements. The exception is that a CONSTRUCTOR node
3174 with no elements indicates zero-initialization of the whole. */
3175 if (VEC_empty (constructor_elt, elts))
3177 if (notify_temp_creation)
3178 return GS_OK;
3179 break;
3182 /* Fetch information about the constructor to direct later processing.
3183 We might want to make static versions of it in various cases, and
3184 can only do so if it known to be a valid constant initializer. */
3185 valid_const_initializer
3186 = categorize_ctor_elements (ctor, &num_nonzero_elements,
3187 &num_ctor_elements, &cleared);
3189 /* If a const aggregate variable is being initialized, then it
3190 should never be a lose to promote the variable to be static. */
3191 if (valid_const_initializer
3192 && num_nonzero_elements > 1
3193 && TREE_READONLY (object)
3194 && TREE_CODE (object) == VAR_DECL)
3196 if (notify_temp_creation)
3197 return GS_ERROR;
3198 DECL_INITIAL (object) = ctor;
3199 TREE_STATIC (object) = 1;
3200 if (!DECL_NAME (object))
3201 DECL_NAME (object) = create_tmp_var_name ("C");
3202 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
3204 /* ??? C++ doesn't automatically append a .<number> to the
3205 assembler name, and even when it does, it looks a FE private
3206 data structures to figure out what that number should be,
3207 which are not set for this variable. I suppose this is
3208 important for local statics for inline functions, which aren't
3209 "local" in the object file sense. So in order to get a unique
3210 TU-local symbol, we must invoke the lhd version now. */
3211 lhd_set_decl_assembler_name (object);
3213 *expr_p = NULL_TREE;
3214 break;
3217 /* If there are "lots" of initialized elements, even discounting
3218 those that are not address constants (and thus *must* be
3219 computed at runtime), then partition the constructor into
3220 constant and non-constant parts. Block copy the constant
3221 parts in, then generate code for the non-constant parts. */
3222 /* TODO. There's code in cp/typeck.c to do this. */
3224 num_type_elements = count_type_elements (type, true);
3226 /* If count_type_elements could not determine number of type elements
3227 for a constant-sized object, assume clearing is needed.
3228 Don't do this for variable-sized objects, as store_constructor
3229 will ignore the clearing of variable-sized objects. */
3230 if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
3231 cleared = true;
3232 /* If there are "lots" of zeros, then block clear the object first. */
3233 else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO
3234 && num_nonzero_elements < num_type_elements/4)
3235 cleared = true;
3236 /* ??? This bit ought not be needed. For any element not present
3237 in the initializer, we should simply set them to zero. Except
3238 we'd need to *find* the elements that are not present, and that
3239 requires trickery to avoid quadratic compile-time behavior in
3240 large cases or excessive memory use in small cases. */
3241 else if (num_ctor_elements < num_type_elements)
3242 cleared = true;
3244 /* If there are "lots" of initialized elements, and all of them
3245 are valid address constants, then the entire initializer can
3246 be dropped to memory, and then memcpy'd out. Don't do this
3247 for sparse arrays, though, as it's more efficient to follow
3248 the standard CONSTRUCTOR behavior of memset followed by
3249 individual element initialization. */
3250 if (valid_const_initializer && !cleared)
3252 HOST_WIDE_INT size = int_size_in_bytes (type);
3253 unsigned int align;
3255 /* ??? We can still get unbounded array types, at least
3256 from the C++ front end. This seems wrong, but attempt
3257 to work around it for now. */
3258 if (size < 0)
3260 size = int_size_in_bytes (TREE_TYPE (object));
3261 if (size >= 0)
3262 TREE_TYPE (ctor) = type = TREE_TYPE (object);
3265 /* Find the maximum alignment we can assume for the object. */
3266 /* ??? Make use of DECL_OFFSET_ALIGN. */
3267 if (DECL_P (object))
3268 align = DECL_ALIGN (object);
3269 else
3270 align = TYPE_ALIGN (type);
3272 if (size > 0 && !can_move_by_pieces (size, align))
3274 tree new;
3276 if (notify_temp_creation)
3277 return GS_ERROR;
3279 new = create_tmp_var_raw (type, "C");
3281 gimple_add_tmp_var (new);
3282 TREE_STATIC (new) = 1;
3283 TREE_READONLY (new) = 1;
3284 DECL_INITIAL (new) = ctor;
3285 if (align > DECL_ALIGN (new))
3287 DECL_ALIGN (new) = align;
3288 DECL_USER_ALIGN (new) = 1;
3290 walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
3292 GENERIC_TREE_OPERAND (*expr_p, 1) = new;
3294 /* This is no longer an assignment of a CONSTRUCTOR, but
3295 we still may have processing to do on the LHS. So
3296 pretend we didn't do anything here to let that happen. */
3297 return GS_UNHANDLED;
3301 if (notify_temp_creation)
3302 return GS_OK;
3304 /* If there are nonzero elements, pre-evaluate to capture elements
3305 overlapping with the lhs into temporaries. We must do this before
3306 clearing to fetch the values before they are zeroed-out. */
3307 if (num_nonzero_elements > 0)
3309 preeval_data.lhs_base_decl = get_base_address (object);
3310 if (!DECL_P (preeval_data.lhs_base_decl))
3311 preeval_data.lhs_base_decl = NULL;
3312 preeval_data.lhs_alias_set = get_alias_set (object);
3314 gimplify_init_ctor_preeval (&GENERIC_TREE_OPERAND (*expr_p, 1),
3315 pre_p, post_p, &preeval_data);
3318 if (cleared)
3320 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3321 Note that we still have to gimplify, in order to handle the
3322 case of variable sized types. Avoid shared tree structures. */
3323 CONSTRUCTOR_ELTS (ctor) = NULL;
3324 object = unshare_expr (object);
3325 gimplify_stmt (expr_p);
3326 append_to_statement_list (*expr_p, pre_p);
3329 /* If we have not block cleared the object, or if there are nonzero
3330 elements in the constructor, add assignments to the individual
3331 scalar fields of the object. */
3332 if (!cleared || num_nonzero_elements > 0)
3333 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
3335 *expr_p = NULL_TREE;
3337 break;
3339 case COMPLEX_TYPE:
3341 tree r, i;
3343 if (notify_temp_creation)
3344 return GS_OK;
3346 /* Extract the real and imaginary parts out of the ctor. */
3347 gcc_assert (VEC_length (constructor_elt, elts) == 2);
3348 r = VEC_index (constructor_elt, elts, 0)->value;
3349 i = VEC_index (constructor_elt, elts, 1)->value;
3350 if (r == NULL || i == NULL)
3352 tree zero = fold_convert (TREE_TYPE (type), integer_zero_node);
3353 if (r == NULL)
3354 r = zero;
3355 if (i == NULL)
3356 i = zero;
3359 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
3360 represent creation of a complex value. */
3361 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
3363 ctor = build_complex (type, r, i);
3364 TREE_OPERAND (*expr_p, 1) = ctor;
3366 else
3368 ctor = build2 (COMPLEX_EXPR, type, r, i);
3369 TREE_OPERAND (*expr_p, 1) = ctor;
3370 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3371 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
3372 fb_rvalue);
3375 break;
3377 case VECTOR_TYPE:
3379 unsigned HOST_WIDE_INT ix;
3380 constructor_elt *ce;
3382 if (notify_temp_creation)
3383 return GS_OK;
3385 /* Go ahead and simplify constant constructors to VECTOR_CST. */
3386 if (TREE_CONSTANT (ctor))
3388 bool constant_p = true;
3389 tree value;
3391 /* Even when ctor is constant, it might contain non-*_CST
3392 elements, such as addresses or trapping values like
3393 1.0/0.0 - 1.0/0.0. Such expressions don't belong
3394 in VECTOR_CST nodes. */
3395 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
3396 if (!CONSTANT_CLASS_P (value))
3398 constant_p = false;
3399 break;
3402 if (constant_p)
3404 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
3405 break;
3408 /* Don't reduce an initializer constant even if we can't
3409 make a VECTOR_CST. It won't do anything for us, and it'll
3410 prevent us from representing it as a single constant. */
3411 if (initializer_constant_valid_p (ctor, type))
3412 break;
3414 TREE_CONSTANT (ctor) = 0;
3415 TREE_INVARIANT (ctor) = 0;
3418 /* Vector types use CONSTRUCTOR all the way through gimple
3419 compilation as a general initializer. */
3420 for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++)
3422 enum gimplify_status tret;
3423 tret = gimplify_expr (&ce->value, pre_p, post_p,
3424 is_gimple_val, fb_rvalue);
3425 if (tret == GS_ERROR)
3426 ret = GS_ERROR;
3428 if (!is_gimple_reg (GENERIC_TREE_OPERAND (*expr_p, 0)))
3429 GENERIC_TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
3431 break;
3433 default:
3434 /* So how did we get a CONSTRUCTOR for a scalar type? */
3435 gcc_unreachable ();
3438 if (ret == GS_ERROR)
3439 return GS_ERROR;
3440 else if (want_value)
3442 append_to_statement_list (*expr_p, pre_p);
3443 *expr_p = object;
3444 return GS_OK;
3446 else
3447 return GS_ALL_DONE;
3450 /* Given a pointer value OP0, return a simplified version of an
3451 indirection through OP0, or NULL_TREE if no simplification is
3452 possible. Note that the resulting type may be different from
3453 the type pointed to in the sense that it is still compatible
3454 from the langhooks point of view. */
3456 tree
3457 gimple_fold_indirect_ref (tree t)
3459 tree type = TREE_TYPE (TREE_TYPE (t));
3460 tree sub = t;
3461 tree subtype;
3463 STRIP_USELESS_TYPE_CONVERSION (sub);
3464 subtype = TREE_TYPE (sub);
3465 if (!POINTER_TYPE_P (subtype))
3466 return NULL_TREE;
3468 if (TREE_CODE (sub) == ADDR_EXPR)
3470 tree op = TREE_OPERAND (sub, 0);
3471 tree optype = TREE_TYPE (op);
3472 /* *&p => p */
3473 if (useless_type_conversion_p (type, optype))
3474 return op;
3476 /* *(foo *)&fooarray => fooarray[0] */
3477 if (TREE_CODE (optype) == ARRAY_TYPE
3478 && useless_type_conversion_p (type, TREE_TYPE (optype)))
3480 tree type_domain = TYPE_DOMAIN (optype);
3481 tree min_val = size_zero_node;
3482 if (type_domain && TYPE_MIN_VALUE (type_domain))
3483 min_val = TYPE_MIN_VALUE (type_domain);
3484 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
3488 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3489 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
3490 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (subtype))))
3492 tree type_domain;
3493 tree min_val = size_zero_node;
3494 tree osub = sub;
3495 sub = gimple_fold_indirect_ref (sub);
3496 if (! sub)
3497 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
3498 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
3499 if (type_domain && TYPE_MIN_VALUE (type_domain))
3500 min_val = TYPE_MIN_VALUE (type_domain);
3501 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
3504 return NULL_TREE;
3507 /* Given a pointer value OP0, return a simplified version of an
3508 indirection through OP0, or NULL_TREE if no simplification is
3509 possible. This may only be applied to a rhs of an expression.
3510 Note that the resulting type may be different from the type pointed
3511 to in the sense that it is still compatible from the langhooks
3512 point of view. */
3514 static tree
3515 gimple_fold_indirect_ref_rhs (tree t)
3517 return gimple_fold_indirect_ref (t);
3520 /* Subroutine of gimplify_modify_expr to do simplifications of
3521 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
3522 something changes. */
3524 static enum gimplify_status
3525 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
3526 tree *post_p, bool want_value)
3528 enum gimplify_status ret = GS_OK;
3530 while (ret != GS_UNHANDLED)
3531 switch (TREE_CODE (*from_p))
3533 case VAR_DECL:
3534 /* If we're assigning from a constant constructor, move the
3535 constructor expression to the RHS of the MODIFY_EXPR. */
3536 if (DECL_INITIAL (*from_p)
3537 && TYPE_READONLY (TREE_TYPE (*from_p))
3538 && !TREE_THIS_VOLATILE (*from_p)
3539 && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
3541 tree old_from = *from_p;
3543 /* Move the constructor into the RHS. */
3544 *from_p = unshare_expr (DECL_INITIAL (*from_p));
3546 /* Let's see if gimplify_init_constructor will need to put
3547 it in memory. If so, revert the change. */
3548 ret = gimplify_init_constructor (expr_p, NULL, NULL, false, true);
3549 if (ret == GS_ERROR)
3551 *from_p = old_from;
3552 /* Fall through. */
3554 else
3556 ret = GS_OK;
3557 break;
3560 ret = GS_UNHANDLED;
3561 break;
3562 case INDIRECT_REF:
3564 /* If we have code like
3566 *(const A*)(A*)&x
3568 where the type of "x" is a (possibly cv-qualified variant
3569 of "A"), treat the entire expression as identical to "x".
3570 This kind of code arises in C++ when an object is bound
3571 to a const reference, and if "x" is a TARGET_EXPR we want
3572 to take advantage of the optimization below. */
3573 tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
3574 if (t)
3576 *from_p = t;
3577 ret = GS_OK;
3579 else
3580 ret = GS_UNHANDLED;
3581 break;
3584 case TARGET_EXPR:
3586 /* If we are initializing something from a TARGET_EXPR, strip the
3587 TARGET_EXPR and initialize it directly, if possible. This can't
3588 be done if the initializer is void, since that implies that the
3589 temporary is set in some non-trivial way.
3591 ??? What about code that pulls out the temp and uses it
3592 elsewhere? I think that such code never uses the TARGET_EXPR as
3593 an initializer. If I'm wrong, we'll die because the temp won't
3594 have any RTL. In that case, I guess we'll need to replace
3595 references somehow. */
3596 tree init = TARGET_EXPR_INITIAL (*from_p);
3598 if (!VOID_TYPE_P (TREE_TYPE (init)))
3600 *from_p = init;
3601 ret = GS_OK;
3603 else
3604 ret = GS_UNHANDLED;
3606 break;
3608 case COMPOUND_EXPR:
3609 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
3610 caught. */
3611 gimplify_compound_expr (from_p, pre_p, true);
3612 ret = GS_OK;
3613 break;
3615 case CONSTRUCTOR:
3616 /* If we're initializing from a CONSTRUCTOR, break this into
3617 individual MODIFY_EXPRs. */
3618 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
3619 false);
3621 case COND_EXPR:
3622 /* If we're assigning to a non-register type, push the assignment
3623 down into the branches. This is mandatory for ADDRESSABLE types,
3624 since we cannot generate temporaries for such, but it saves a
3625 copy in other cases as well. */
3626 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
3628 /* This code should mirror the code in gimplify_cond_expr. */
3629 enum tree_code code = TREE_CODE (*expr_p);
3630 tree cond = *from_p;
3631 tree result = *to_p;
3633 ret = gimplify_expr (&result, pre_p, post_p,
3634 is_gimple_min_lval, fb_lvalue);
3635 if (ret != GS_ERROR)
3636 ret = GS_OK;
3638 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
3639 TREE_OPERAND (cond, 1)
3640 = build2 (code, void_type_node, result,
3641 TREE_OPERAND (cond, 1));
3642 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
3643 TREE_OPERAND (cond, 2)
3644 = build2 (code, void_type_node, unshare_expr (result),
3645 TREE_OPERAND (cond, 2));
3647 TREE_TYPE (cond) = void_type_node;
3648 recalculate_side_effects (cond);
3650 if (want_value)
3652 gimplify_and_add (cond, pre_p);
3653 *expr_p = unshare_expr (result);
3655 else
3656 *expr_p = cond;
3657 return ret;
3659 else
3660 ret = GS_UNHANDLED;
3661 break;
3663 case CALL_EXPR:
3664 /* For calls that return in memory, give *to_p as the CALL_EXPR's
3665 return slot so that we don't generate a temporary. */
3666 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
3667 && aggregate_value_p (*from_p, *from_p))
3669 bool use_target;
3671 if (!(rhs_predicate_for (*to_p))(*from_p))
3672 /* If we need a temporary, *to_p isn't accurate. */
3673 use_target = false;
3674 else if (TREE_CODE (*to_p) == RESULT_DECL
3675 && DECL_NAME (*to_p) == NULL_TREE
3676 && needs_to_live_in_memory (*to_p))
3677 /* It's OK to use the return slot directly unless it's an NRV. */
3678 use_target = true;
3679 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
3680 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
3681 /* Don't force regs into memory. */
3682 use_target = false;
3683 else if (TREE_CODE (*to_p) == VAR_DECL
3684 && DECL_GIMPLE_FORMAL_TEMP_P (*to_p))
3685 /* Don't use the original target if it's a formal temp; we
3686 don't want to take their addresses. */
3687 use_target = false;
3688 else if (TREE_CODE (*expr_p) == INIT_EXPR)
3689 /* It's OK to use the target directly if it's being
3690 initialized. */
3691 use_target = true;
3692 else if (!is_gimple_non_addressable (*to_p))
3693 /* Don't use the original target if it's already addressable;
3694 if its address escapes, and the called function uses the
3695 NRV optimization, a conforming program could see *to_p
3696 change before the called function returns; see c++/19317.
3697 When optimizing, the return_slot pass marks more functions
3698 as safe after we have escape info. */
3699 use_target = false;
3700 else
3701 use_target = true;
3703 if (use_target)
3705 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
3706 mark_addressable (*to_p);
3710 ret = GS_UNHANDLED;
3711 break;
3713 /* If we're initializing from a container, push the initialization
3714 inside it. */
3715 case CLEANUP_POINT_EXPR:
3716 case BIND_EXPR:
3717 case STATEMENT_LIST:
3719 tree wrap = *from_p;
3720 tree t;
3722 ret = gimplify_expr (to_p, pre_p, post_p,
3723 is_gimple_min_lval, fb_lvalue);
3724 if (ret != GS_ERROR)
3725 ret = GS_OK;
3727 t = voidify_wrapper_expr (wrap, *expr_p);
3728 gcc_assert (t == *expr_p);
3730 if (want_value)
3732 gimplify_and_add (wrap, pre_p);
3733 *expr_p = unshare_expr (*to_p);
3735 else
3736 *expr_p = wrap;
3737 return GS_OK;
3740 default:
3741 ret = GS_UNHANDLED;
3742 break;
3745 return ret;
3748 /* Destructively convert the TREE pointer in TP into a gimple tuple if
3749 appropriate. */
3751 static void
3752 tree_to_gimple_tuple (tree *tp)
3755 switch (TREE_CODE (*tp))
3757 case GIMPLE_MODIFY_STMT:
3758 return;
3759 case MODIFY_EXPR:
3761 struct gimple_stmt *gs;
3762 tree lhs = TREE_OPERAND (*tp, 0);
3763 bool def_stmt_self_p = false;
3765 if (TREE_CODE (lhs) == SSA_NAME)
3767 if (SSA_NAME_DEF_STMT (lhs) == *tp)
3768 def_stmt_self_p = true;
3771 gs = &make_node (GIMPLE_MODIFY_STMT)->gstmt;
3772 gs->base = (*tp)->base;
3773 /* The set to base above overwrites the CODE. */
3774 TREE_SET_CODE ((tree) gs, GIMPLE_MODIFY_STMT);
3776 SET_EXPR_LOCUS ((tree) gs, EXPR_LOCUS (*tp));
3777 gs->operands[0] = TREE_OPERAND (*tp, 0);
3778 gs->operands[1] = TREE_OPERAND (*tp, 1);
3779 gs->block = TREE_BLOCK (*tp);
3780 *tp = (tree)gs;
3782 /* If we re-gimplify a set to an SSA_NAME, we must change the
3783 SSA name's DEF_STMT link. */
3784 if (def_stmt_self_p)
3785 SSA_NAME_DEF_STMT (GIMPLE_STMT_OPERAND (*tp, 0)) = *tp;
3787 return;
3789 default:
3790 break;
3794 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
3795 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
3796 DECL_GIMPLE_REG_P set.
3798 IMPORTANT NOTE: This promotion is performed by introducing a load of the
3799 other, unmodified part of the complex object just before the total store.
3800 As a consequence, if the object is still uninitialized, an undefined value
3801 will be loaded into a register, which may result in a spurious exception
3802 if the register is floating-point and the value happens to be a signaling
3803 NaN for example. Then the fully-fledged complex operations lowering pass
3804 followed by a DCE pass are necessary in order to fix things up. */
3806 static enum gimplify_status
3807 gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
3809 enum tree_code code, ocode;
3810 tree lhs, rhs, new_rhs, other, realpart, imagpart;
3812 lhs = GENERIC_TREE_OPERAND (*expr_p, 0);
3813 rhs = GENERIC_TREE_OPERAND (*expr_p, 1);
3814 code = TREE_CODE (lhs);
3815 lhs = TREE_OPERAND (lhs, 0);
3817 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
3818 other = build1 (ocode, TREE_TYPE (rhs), lhs);
3819 other = get_formal_tmp_var (other, pre_p);
3821 realpart = code == REALPART_EXPR ? rhs : other;
3822 imagpart = code == REALPART_EXPR ? other : rhs;
3824 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
3825 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
3826 else
3827 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
3829 GENERIC_TREE_OPERAND (*expr_p, 0) = lhs;
3830 GENERIC_TREE_OPERAND (*expr_p, 1) = new_rhs;
3832 if (want_value)
3834 tree_to_gimple_tuple (expr_p);
3836 append_to_statement_list (*expr_p, pre_p);
3837 *expr_p = rhs;
3840 return GS_ALL_DONE;
3843 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
3845 modify_expr
3846 : varname '=' rhs
3847 | '*' ID '=' rhs
3849 PRE_P points to the list where side effects that must happen before
3850 *EXPR_P should be stored.
3852 POST_P points to the list where side effects that must happen after
3853 *EXPR_P should be stored.
3855 WANT_VALUE is nonzero iff we want to use the value of this expression
3856 in another expression. */
3858 static enum gimplify_status
3859 gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
3861 tree *from_p = &GENERIC_TREE_OPERAND (*expr_p, 1);
3862 tree *to_p = &GENERIC_TREE_OPERAND (*expr_p, 0);
3863 enum gimplify_status ret = GS_UNHANDLED;
3865 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
3866 || TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT
3867 || TREE_CODE (*expr_p) == INIT_EXPR);
3869 /* See if any simplifications can be done based on what the RHS is. */
3870 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3871 want_value);
3872 if (ret != GS_UNHANDLED)
3873 return ret;
3875 /* For zero sized types only gimplify the left hand side and right hand
3876 side as statements and throw away the assignment. Do this after
3877 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
3878 types properly. */
3879 if (zero_sized_type (TREE_TYPE (*from_p)))
3881 gimplify_stmt (from_p);
3882 gimplify_stmt (to_p);
3883 append_to_statement_list (*from_p, pre_p);
3884 append_to_statement_list (*to_p, pre_p);
3885 *expr_p = NULL_TREE;
3886 return GS_ALL_DONE;
3889 /* If the value being copied is of variable width, compute the length
3890 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
3891 before gimplifying any of the operands so that we can resolve any
3892 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
3893 the size of the expression to be copied, not of the destination, so
3894 that is what we must here. */
3895 maybe_with_size_expr (from_p);
3897 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
3898 if (ret == GS_ERROR)
3899 return ret;
3901 ret = gimplify_expr (from_p, pre_p, post_p,
3902 rhs_predicate_for (*to_p), fb_rvalue);
3903 if (ret == GS_ERROR)
3904 return ret;
3906 /* Now see if the above changed *from_p to something we handle specially. */
3907 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3908 want_value);
3909 if (ret != GS_UNHANDLED)
3910 return ret;
3912 /* If we've got a variable sized assignment between two lvalues (i.e. does
3913 not involve a call), then we can make things a bit more straightforward
3914 by converting the assignment to memcpy or memset. */
3915 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
3917 tree from = TREE_OPERAND (*from_p, 0);
3918 tree size = TREE_OPERAND (*from_p, 1);
3920 if (TREE_CODE (from) == CONSTRUCTOR)
3921 return gimplify_modify_expr_to_memset (expr_p, size, want_value);
3922 if (is_gimple_addressable (from))
3924 *from_p = from;
3925 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value);
3929 /* Transform partial stores to non-addressable complex variables into
3930 total stores. This allows us to use real instead of virtual operands
3931 for these variables, which improves optimization. */
3932 if ((TREE_CODE (*to_p) == REALPART_EXPR
3933 || TREE_CODE (*to_p) == IMAGPART_EXPR)
3934 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
3935 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
3937 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
3939 /* If we've somehow already got an SSA_NAME on the LHS, then
3940 we're probably modified it twice. Not good. */
3941 gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
3942 *to_p = make_ssa_name (*to_p, *expr_p);
3945 /* Try to alleviate the effects of the gimplification creating artificial
3946 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
3947 if (!gimplify_ctxp->into_ssa
3948 && DECL_P (*from_p) && DECL_IGNORED_P (*from_p)
3949 && DECL_P (*to_p) && !DECL_IGNORED_P (*to_p))
3951 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
3952 DECL_NAME (*from_p)
3953 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
3954 DECL_DEBUG_EXPR_IS_FROM (*from_p) = 1;
3955 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
3958 if (want_value)
3960 tree_to_gimple_tuple (expr_p);
3962 append_to_statement_list (*expr_p, pre_p);
3963 *expr_p = *to_p;
3964 return GS_OK;
3967 return GS_ALL_DONE;
3970 /* Gimplify a comparison between two variable-sized objects. Do this
3971 with a call to BUILT_IN_MEMCMP. */
3973 static enum gimplify_status
3974 gimplify_variable_sized_compare (tree *expr_p)
3976 tree op0 = TREE_OPERAND (*expr_p, 0);
3977 tree op1 = TREE_OPERAND (*expr_p, 1);
3978 tree t, arg, dest, src;
3980 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
3981 arg = unshare_expr (arg);
3982 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
3983 src = build_fold_addr_expr (op1);
3984 dest = build_fold_addr_expr (op0);
3985 t = implicit_built_in_decls[BUILT_IN_MEMCMP];
3986 t = build_call_expr (t, 3, dest, src, arg);
3987 *expr_p
3988 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
3990 return GS_OK;
3993 /* Gimplify a comparison between two aggregate objects of integral scalar
3994 mode as a comparison between the bitwise equivalent scalar values. */
3996 static enum gimplify_status
3997 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
3999 tree op0 = TREE_OPERAND (*expr_p, 0);
4000 tree op1 = TREE_OPERAND (*expr_p, 1);
4002 tree type = TREE_TYPE (op0);
4003 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
4005 op0 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op0);
4006 op1 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op1);
4008 *expr_p
4009 = fold_build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
4011 return GS_OK;
4014 /* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P
4015 points to the expression to gimplify.
4017 Expressions of the form 'a && b' are gimplified to:
4019 a && b ? true : false
4021 gimplify_cond_expr will do the rest.
4023 PRE_P points to the list where side effects that must happen before
4024 *EXPR_P should be stored. */
4026 static enum gimplify_status
4027 gimplify_boolean_expr (tree *expr_p)
4029 /* Preserve the original type of the expression. */
4030 tree type = TREE_TYPE (*expr_p);
4032 *expr_p = build3 (COND_EXPR, type, *expr_p,
4033 fold_convert (type, boolean_true_node),
4034 fold_convert (type, boolean_false_node));
4036 return GS_OK;
4039 /* Gimplifies an expression sequence. This function gimplifies each
4040 expression and re-writes the original expression with the last
4041 expression of the sequence in GIMPLE form.
4043 PRE_P points to the list where the side effects for all the
4044 expressions in the sequence will be emitted.
4046 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4047 /* ??? Should rearrange to share the pre-queue with all the indirect
4048 invocations of gimplify_expr. Would probably save on creations
4049 of statement_list nodes. */
4051 static enum gimplify_status
4052 gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value)
4054 tree t = *expr_p;
4058 tree *sub_p = &TREE_OPERAND (t, 0);
4060 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
4061 gimplify_compound_expr (sub_p, pre_p, false);
4062 else
4063 gimplify_stmt (sub_p);
4064 append_to_statement_list (*sub_p, pre_p);
4066 t = TREE_OPERAND (t, 1);
4068 while (TREE_CODE (t) == COMPOUND_EXPR);
4070 *expr_p = t;
4071 if (want_value)
4072 return GS_OK;
4073 else
4075 gimplify_stmt (expr_p);
4076 return GS_ALL_DONE;
4080 /* Gimplifies a statement list. These may be created either by an
4081 enlightened front-end, or by shortcut_cond_expr. */
4083 static enum gimplify_status
4084 gimplify_statement_list (tree *expr_p, tree *pre_p)
4086 tree temp = voidify_wrapper_expr (*expr_p, NULL);
4088 tree_stmt_iterator i = tsi_start (*expr_p);
4090 while (!tsi_end_p (i))
4092 tree t;
4094 gimplify_stmt (tsi_stmt_ptr (i));
4096 t = tsi_stmt (i);
4097 if (t == NULL)
4098 tsi_delink (&i);
4099 else if (TREE_CODE (t) == STATEMENT_LIST)
4101 tsi_link_before (&i, t, TSI_SAME_STMT);
4102 tsi_delink (&i);
4104 else
4105 tsi_next (&i);
4108 if (temp)
4110 append_to_statement_list (*expr_p, pre_p);
4111 *expr_p = temp;
4112 return GS_OK;
4115 return GS_ALL_DONE;
4118 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4119 gimplify. After gimplification, EXPR_P will point to a new temporary
4120 that holds the original value of the SAVE_EXPR node.
4122 PRE_P points to the list where side effects that must happen before
4123 *EXPR_P should be stored. */
4125 static enum gimplify_status
4126 gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p)
4128 enum gimplify_status ret = GS_ALL_DONE;
4129 tree val;
4131 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
4132 val = TREE_OPERAND (*expr_p, 0);
4134 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4135 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
4137 /* The operand may be a void-valued expression such as SAVE_EXPRs
4138 generated by the Java frontend for class initialization. It is
4139 being executed only for its side-effects. */
4140 if (TREE_TYPE (val) == void_type_node)
4142 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
4143 is_gimple_stmt, fb_none);
4144 append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p);
4145 val = NULL;
4147 else
4148 val = get_initialized_tmp_var (val, pre_p, post_p);
4150 TREE_OPERAND (*expr_p, 0) = val;
4151 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
4154 *expr_p = val;
4156 return ret;
4159 /* Re-write the ADDR_EXPR node pointed to by EXPR_P
4161 unary_expr
4162 : ...
4163 | '&' varname
4166 PRE_P points to the list where side effects that must happen before
4167 *EXPR_P should be stored.
4169 POST_P points to the list where side effects that must happen after
4170 *EXPR_P should be stored. */
4172 static enum gimplify_status
4173 gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
4175 tree expr = *expr_p;
4176 tree op0 = TREE_OPERAND (expr, 0);
4177 enum gimplify_status ret;
4179 switch (TREE_CODE (op0))
4181 case INDIRECT_REF:
4182 case MISALIGNED_INDIRECT_REF:
4183 do_indirect_ref:
4184 /* Check if we are dealing with an expression of the form '&*ptr'.
4185 While the front end folds away '&*ptr' into 'ptr', these
4186 expressions may be generated internally by the compiler (e.g.,
4187 builtins like __builtin_va_end). */
4188 /* Caution: the silent array decomposition semantics we allow for
4189 ADDR_EXPR means we can't always discard the pair. */
4190 /* Gimplification of the ADDR_EXPR operand may drop
4191 cv-qualification conversions, so make sure we add them if
4192 needed. */
4194 tree op00 = TREE_OPERAND (op0, 0);
4195 tree t_expr = TREE_TYPE (expr);
4196 tree t_op00 = TREE_TYPE (op00);
4198 if (!useless_type_conversion_p (t_expr, t_op00))
4199 op00 = fold_convert (TREE_TYPE (expr), op00);
4200 *expr_p = op00;
4201 ret = GS_OK;
4203 break;
4205 case VIEW_CONVERT_EXPR:
4206 /* Take the address of our operand and then convert it to the type of
4207 this ADDR_EXPR.
4209 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
4210 all clear. The impact of this transformation is even less clear. */
4212 /* If the operand is a useless conversion, look through it. Doing so
4213 guarantees that the ADDR_EXPR and its operand will remain of the
4214 same type. */
4215 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
4216 op0 = TREE_OPERAND (op0, 0);
4218 *expr_p = fold_convert (TREE_TYPE (expr),
4219 build_fold_addr_expr (TREE_OPERAND (op0, 0)));
4220 ret = GS_OK;
4221 break;
4223 default:
4224 /* We use fb_either here because the C frontend sometimes takes
4225 the address of a call that returns a struct; see
4226 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
4227 the implied temporary explicit. */
4229 /* Mark the RHS addressable. */
4230 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
4231 is_gimple_addressable, fb_either);
4232 if (ret != GS_ERROR)
4234 op0 = TREE_OPERAND (expr, 0);
4236 /* For various reasons, the gimplification of the expression
4237 may have made a new INDIRECT_REF. */
4238 if (TREE_CODE (op0) == INDIRECT_REF)
4239 goto do_indirect_ref;
4241 /* Make sure TREE_INVARIANT, TREE_CONSTANT, and TREE_SIDE_EFFECTS
4242 is set properly. */
4243 recompute_tree_invariant_for_addr_expr (expr);
4245 mark_addressable (TREE_OPERAND (expr, 0));
4247 break;
4250 return ret;
4253 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
4254 value; output operands should be a gimple lvalue. */
4256 static enum gimplify_status
4257 gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p)
4259 tree expr = *expr_p;
4260 int noutputs = list_length (ASM_OUTPUTS (expr));
4261 const char **oconstraints
4262 = (const char **) alloca ((noutputs) * sizeof (const char *));
4263 int i;
4264 tree link;
4265 const char *constraint;
4266 bool allows_mem, allows_reg, is_inout;
4267 enum gimplify_status ret, tret;
4269 ret = GS_ALL_DONE;
4270 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link))
4272 size_t constraint_len;
4273 oconstraints[i] = constraint
4274 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
4275 constraint_len = strlen (constraint);
4276 if (constraint_len == 0)
4277 continue;
4279 parse_output_constraint (&constraint, i, 0, 0,
4280 &allows_mem, &allows_reg, &is_inout);
4282 if (!allows_reg && allows_mem)
4283 mark_addressable (TREE_VALUE (link));
4285 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4286 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
4287 fb_lvalue | fb_mayfail);
4288 if (tret == GS_ERROR)
4290 error ("invalid lvalue in asm output %d", i);
4291 ret = tret;
4294 if (is_inout)
4296 /* An input/output operand. To give the optimizers more
4297 flexibility, split it into separate input and output
4298 operands. */
4299 tree input;
4300 char buf[10];
4302 /* Turn the in/out constraint into an output constraint. */
4303 char *p = xstrdup (constraint);
4304 p[0] = '=';
4305 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
4307 /* And add a matching input constraint. */
4308 if (allows_reg)
4310 sprintf (buf, "%d", i);
4312 /* If there are multiple alternatives in the constraint,
4313 handle each of them individually. Those that allow register
4314 will be replaced with operand number, the others will stay
4315 unchanged. */
4316 if (strchr (p, ',') != NULL)
4318 size_t len = 0, buflen = strlen (buf);
4319 char *beg, *end, *str, *dst;
4321 for (beg = p + 1;;)
4323 end = strchr (beg, ',');
4324 if (end == NULL)
4325 end = strchr (beg, '\0');
4326 if ((size_t) (end - beg) < buflen)
4327 len += buflen + 1;
4328 else
4329 len += end - beg + 1;
4330 if (*end)
4331 beg = end + 1;
4332 else
4333 break;
4336 str = (char *) alloca (len);
4337 for (beg = p + 1, dst = str;;)
4339 const char *tem;
4340 bool mem_p, reg_p, inout_p;
4342 end = strchr (beg, ',');
4343 if (end)
4344 *end = '\0';
4345 beg[-1] = '=';
4346 tem = beg - 1;
4347 parse_output_constraint (&tem, i, 0, 0,
4348 &mem_p, &reg_p, &inout_p);
4349 if (dst != str)
4350 *dst++ = ',';
4351 if (reg_p)
4353 memcpy (dst, buf, buflen);
4354 dst += buflen;
4356 else
4358 if (end)
4359 len = end - beg;
4360 else
4361 len = strlen (beg);
4362 memcpy (dst, beg, len);
4363 dst += len;
4365 if (end)
4366 beg = end + 1;
4367 else
4368 break;
4370 *dst = '\0';
4371 input = build_string (dst - str, str);
4373 else
4374 input = build_string (strlen (buf), buf);
4376 else
4377 input = build_string (constraint_len - 1, constraint + 1);
4379 free (p);
4381 input = build_tree_list (build_tree_list (NULL_TREE, input),
4382 unshare_expr (TREE_VALUE (link)));
4383 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
4387 for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link))
4389 constraint
4390 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
4391 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
4392 oconstraints, &allows_mem, &allows_reg);
4394 /* If we can't make copies, we can only accept memory. */
4395 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
4397 if (allows_mem)
4398 allows_reg = 0;
4399 else
4401 error ("impossible constraint in %<asm%>");
4402 error ("non-memory input %d must stay in memory", i);
4403 return GS_ERROR;
4407 /* If the operand is a memory input, it should be an lvalue. */
4408 if (!allows_reg && allows_mem)
4410 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4411 is_gimple_lvalue, fb_lvalue | fb_mayfail);
4412 mark_addressable (TREE_VALUE (link));
4413 if (tret == GS_ERROR)
4415 error ("memory input %d is not directly addressable", i);
4416 ret = tret;
4419 else
4421 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4422 is_gimple_asm_val, fb_rvalue);
4423 if (tret == GS_ERROR)
4424 ret = tret;
4428 return ret;
4431 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
4432 WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
4433 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
4434 return to this function.
4436 FIXME should we complexify the prequeue handling instead? Or use flags
4437 for all the cleanups and let the optimizer tighten them up? The current
4438 code seems pretty fragile; it will break on a cleanup within any
4439 non-conditional nesting. But any such nesting would be broken, anyway;
4440 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
4441 and continues out of it. We can do that at the RTL level, though, so
4442 having an optimizer to tighten up try/finally regions would be a Good
4443 Thing. */
4445 static enum gimplify_status
4446 gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p)
4448 tree_stmt_iterator iter;
4449 tree body;
4451 tree temp = voidify_wrapper_expr (*expr_p, NULL);
4453 /* We only care about the number of conditions between the innermost
4454 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
4455 any cleanups collected outside the CLEANUP_POINT_EXPR. */
4456 int old_conds = gimplify_ctxp->conditions;
4457 tree old_cleanups = gimplify_ctxp->conditional_cleanups;
4458 gimplify_ctxp->conditions = 0;
4459 gimplify_ctxp->conditional_cleanups = NULL_TREE;
4461 body = TREE_OPERAND (*expr_p, 0);
4462 gimplify_to_stmt_list (&body);
4464 gimplify_ctxp->conditions = old_conds;
4465 gimplify_ctxp->conditional_cleanups = old_cleanups;
4467 for (iter = tsi_start (body); !tsi_end_p (iter); )
4469 tree *wce_p = tsi_stmt_ptr (iter);
4470 tree wce = *wce_p;
4472 if (TREE_CODE (wce) == WITH_CLEANUP_EXPR)
4474 if (tsi_one_before_end_p (iter))
4476 tsi_link_before (&iter, TREE_OPERAND (wce, 0), TSI_SAME_STMT);
4477 tsi_delink (&iter);
4478 break;
4480 else
4482 tree sl, tfe;
4483 enum tree_code code;
4485 if (CLEANUP_EH_ONLY (wce))
4486 code = TRY_CATCH_EXPR;
4487 else
4488 code = TRY_FINALLY_EXPR;
4490 sl = tsi_split_statement_list_after (&iter);
4491 tfe = build2 (code, void_type_node, sl, NULL_TREE);
4492 append_to_statement_list (TREE_OPERAND (wce, 0),
4493 &TREE_OPERAND (tfe, 1));
4494 *wce_p = tfe;
4495 iter = tsi_start (sl);
4498 else
4499 tsi_next (&iter);
4502 if (temp)
4504 *expr_p = temp;
4505 append_to_statement_list (body, pre_p);
4506 return GS_OK;
4508 else
4510 *expr_p = body;
4511 return GS_ALL_DONE;
4515 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
4516 is the cleanup action required. */
4518 static void
4519 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p)
4521 tree wce;
4523 /* Errors can result in improperly nested cleanups. Which results in
4524 confusion when trying to resolve the WITH_CLEANUP_EXPR. */
4525 if (errorcount || sorrycount)
4526 return;
4528 if (gimple_conditional_context ())
4530 /* If we're in a conditional context, this is more complex. We only
4531 want to run the cleanup if we actually ran the initialization that
4532 necessitates it, but we want to run it after the end of the
4533 conditional context. So we wrap the try/finally around the
4534 condition and use a flag to determine whether or not to actually
4535 run the destructor. Thus
4537 test ? f(A()) : 0
4539 becomes (approximately)
4541 flag = 0;
4542 try {
4543 if (test) { A::A(temp); flag = 1; val = f(temp); }
4544 else { val = 0; }
4545 } finally {
4546 if (flag) A::~A(temp);
4551 tree flag = create_tmp_var (boolean_type_node, "cleanup");
4552 tree ffalse = build_gimple_modify_stmt (flag, boolean_false_node);
4553 tree ftrue = build_gimple_modify_stmt (flag, boolean_true_node);
4554 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
4555 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4556 append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups);
4557 append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups);
4558 append_to_statement_list (ftrue, pre_p);
4560 /* Because of this manipulation, and the EH edges that jump
4561 threading cannot redirect, the temporary (VAR) will appear
4562 to be used uninitialized. Don't warn. */
4563 TREE_NO_WARNING (var) = 1;
4565 else
4567 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4568 CLEANUP_EH_ONLY (wce) = eh_only;
4569 append_to_statement_list (wce, pre_p);
4572 gimplify_stmt (&TREE_OPERAND (wce, 0));
4575 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
4577 static enum gimplify_status
4578 gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p)
4580 tree targ = *expr_p;
4581 tree temp = TARGET_EXPR_SLOT (targ);
4582 tree init = TARGET_EXPR_INITIAL (targ);
4583 enum gimplify_status ret;
4585 if (init)
4587 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
4588 to the temps list. Handle also variable length TARGET_EXPRs. */
4589 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
4591 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
4592 gimplify_type_sizes (TREE_TYPE (temp), pre_p);
4593 gimplify_vla_decl (temp, pre_p);
4595 else
4596 gimple_add_tmp_var (temp);
4598 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
4599 expression is supposed to initialize the slot. */
4600 if (VOID_TYPE_P (TREE_TYPE (init)))
4601 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
4602 else
4604 init = build2 (INIT_EXPR, void_type_node, temp, init);
4605 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt,
4606 fb_none);
4608 if (ret == GS_ERROR)
4610 /* PR c++/28266 Make sure this is expanded only once. */
4611 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4612 return GS_ERROR;
4614 append_to_statement_list (init, pre_p);
4616 /* If needed, push the cleanup for the temp. */
4617 if (TARGET_EXPR_CLEANUP (targ))
4619 gimplify_stmt (&TARGET_EXPR_CLEANUP (targ));
4620 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
4621 CLEANUP_EH_ONLY (targ), pre_p);
4624 /* Only expand this once. */
4625 TREE_OPERAND (targ, 3) = init;
4626 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4628 else
4629 /* We should have expanded this before. */
4630 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
4632 *expr_p = temp;
4633 return GS_OK;
4636 /* Gimplification of expression trees. */
4638 /* Gimplify an expression which appears at statement context; usually, this
4639 means replacing it with a suitably gimple STATEMENT_LIST. */
4641 void
4642 gimplify_stmt (tree *stmt_p)
4644 gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none);
4647 /* Similarly, but force the result to be a STATEMENT_LIST. */
4649 void
4650 gimplify_to_stmt_list (tree *stmt_p)
4652 gimplify_stmt (stmt_p);
4653 if (!*stmt_p)
4654 *stmt_p = alloc_stmt_list ();
4655 else if (TREE_CODE (*stmt_p) != STATEMENT_LIST)
4657 tree t = *stmt_p;
4658 *stmt_p = alloc_stmt_list ();
4659 append_to_statement_list (t, stmt_p);
4664 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
4665 to CTX. If entries already exist, force them to be some flavor of private.
4666 If there is no enclosing parallel, do nothing. */
4668 void
4669 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
4671 splay_tree_node n;
4673 if (decl == NULL || !DECL_P (decl))
4674 return;
4678 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4679 if (n != NULL)
4681 if (n->value & GOVD_SHARED)
4682 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
4683 else
4684 return;
4686 else if (ctx->is_parallel)
4687 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
4689 ctx = ctx->outer_context;
4691 while (ctx);
4694 /* Similarly for each of the type sizes of TYPE. */
4696 static void
4697 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
4699 if (type == NULL || type == error_mark_node)
4700 return;
4701 type = TYPE_MAIN_VARIANT (type);
4703 if (pointer_set_insert (ctx->privatized_types, type))
4704 return;
4706 switch (TREE_CODE (type))
4708 case INTEGER_TYPE:
4709 case ENUMERAL_TYPE:
4710 case BOOLEAN_TYPE:
4711 case REAL_TYPE:
4712 case FIXED_POINT_TYPE:
4713 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
4714 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
4715 break;
4717 case ARRAY_TYPE:
4718 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4719 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
4720 break;
4722 case RECORD_TYPE:
4723 case UNION_TYPE:
4724 case QUAL_UNION_TYPE:
4726 tree field;
4727 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4728 if (TREE_CODE (field) == FIELD_DECL)
4730 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
4731 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
4734 break;
4736 case POINTER_TYPE:
4737 case REFERENCE_TYPE:
4738 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4739 break;
4741 default:
4742 break;
4745 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
4746 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
4747 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
4750 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
4752 static void
4753 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
4755 splay_tree_node n;
4756 unsigned int nflags;
4757 tree t;
4759 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4760 return;
4762 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
4763 there are constructors involved somewhere. */
4764 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
4765 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
4766 flags |= GOVD_SEEN;
4768 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4769 if (n != NULL)
4771 /* We shouldn't be re-adding the decl with the same data
4772 sharing class. */
4773 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
4774 /* The only combination of data sharing classes we should see is
4775 FIRSTPRIVATE and LASTPRIVATE. */
4776 nflags = n->value | flags;
4777 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
4778 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
4779 n->value = nflags;
4780 return;
4783 /* When adding a variable-sized variable, we have to handle all sorts
4784 of additional bits of data: the pointer replacement variable, and
4785 the parameters of the type. */
4786 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
4788 /* Add the pointer replacement variable as PRIVATE if the variable
4789 replacement is private, else FIRSTPRIVATE since we'll need the
4790 address of the original variable either for SHARED, or for the
4791 copy into or out of the context. */
4792 if (!(flags & GOVD_LOCAL))
4794 nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
4795 nflags |= flags & GOVD_SEEN;
4796 t = DECL_VALUE_EXPR (decl);
4797 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
4798 t = TREE_OPERAND (t, 0);
4799 gcc_assert (DECL_P (t));
4800 omp_add_variable (ctx, t, nflags);
4803 /* Add all of the variable and type parameters (which should have
4804 been gimplified to a formal temporary) as FIRSTPRIVATE. */
4805 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
4806 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
4807 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4809 /* The variable-sized variable itself is never SHARED, only some form
4810 of PRIVATE. The sharing would take place via the pointer variable
4811 which we remapped above. */
4812 if (flags & GOVD_SHARED)
4813 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
4814 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
4816 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
4817 alloca statement we generate for the variable, so make sure it
4818 is available. This isn't automatically needed for the SHARED
4819 case, since we won't be allocating local storage then.
4820 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
4821 in this case omp_notice_variable will be called later
4822 on when it is gimplified. */
4823 else if (! (flags & GOVD_LOCAL))
4824 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
4826 else if (lang_hooks.decls.omp_privatize_by_reference (decl))
4828 gcc_assert ((flags & GOVD_LOCAL) == 0);
4829 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4831 /* Similar to the direct variable sized case above, we'll need the
4832 size of references being privatized. */
4833 if ((flags & GOVD_SHARED) == 0)
4835 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
4836 if (TREE_CODE (t) != INTEGER_CST)
4837 omp_notice_variable (ctx, t, true);
4841 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
4844 /* Record the fact that DECL was used within the OpenMP context CTX.
4845 IN_CODE is true when real code uses DECL, and false when we should
4846 merely emit default(none) errors. Return true if DECL is going to
4847 be remapped and thus DECL shouldn't be gimplified into its
4848 DECL_VALUE_EXPR (if any). */
4850 static bool
4851 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
4853 splay_tree_node n;
4854 unsigned flags = in_code ? GOVD_SEEN : 0;
4855 bool ret = false, shared;
4857 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4858 return false;
4860 /* Threadprivate variables are predetermined. */
4861 if (is_global_var (decl))
4863 if (DECL_THREAD_LOCAL_P (decl))
4864 return false;
4866 if (DECL_HAS_VALUE_EXPR_P (decl))
4868 tree value = get_base_address (DECL_VALUE_EXPR (decl));
4870 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
4871 return false;
4875 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4876 if (n == NULL)
4878 enum omp_clause_default_kind default_kind, kind;
4880 if (!ctx->is_parallel)
4881 goto do_outer;
4883 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
4884 remapped firstprivate instead of shared. To some extent this is
4885 addressed in omp_firstprivatize_type_sizes, but not effectively. */
4886 default_kind = ctx->default_kind;
4887 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
4888 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
4889 default_kind = kind;
4891 switch (default_kind)
4893 case OMP_CLAUSE_DEFAULT_NONE:
4894 error ("%qs not specified in enclosing parallel",
4895 IDENTIFIER_POINTER (DECL_NAME (decl)));
4896 error ("%Henclosing parallel", &ctx->location);
4897 /* FALLTHRU */
4898 case OMP_CLAUSE_DEFAULT_SHARED:
4899 flags |= GOVD_SHARED;
4900 break;
4901 case OMP_CLAUSE_DEFAULT_PRIVATE:
4902 flags |= GOVD_PRIVATE;
4903 break;
4904 default:
4905 gcc_unreachable ();
4908 omp_add_variable (ctx, decl, flags);
4910 shared = (flags & GOVD_SHARED) != 0;
4911 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4912 goto do_outer;
4915 shared = ((flags | n->value) & GOVD_SHARED) != 0;
4916 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4918 /* If nothing changed, there's nothing left to do. */
4919 if ((n->value & flags) == flags)
4920 return ret;
4921 flags |= n->value;
4922 n->value = flags;
4924 do_outer:
4925 /* If the variable is private in the current context, then we don't
4926 need to propagate anything to an outer context. */
4927 if (flags & GOVD_PRIVATE)
4928 return ret;
4929 if (ctx->outer_context
4930 && omp_notice_variable (ctx->outer_context, decl, in_code))
4931 return true;
4932 return ret;
4935 /* Verify that DECL is private within CTX. If there's specific information
4936 to the contrary in the innermost scope, generate an error. */
4938 static bool
4939 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl)
4941 splay_tree_node n;
4943 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4944 if (n != NULL)
4946 if (n->value & GOVD_SHARED)
4948 if (ctx == gimplify_omp_ctxp)
4950 error ("iteration variable %qs should be private",
4951 IDENTIFIER_POINTER (DECL_NAME (decl)));
4952 n->value = GOVD_PRIVATE;
4953 return true;
4955 else
4956 return false;
4958 else if ((n->value & GOVD_EXPLICIT) != 0
4959 && (ctx == gimplify_omp_ctxp
4960 || (ctx->is_combined_parallel
4961 && gimplify_omp_ctxp->outer_context == ctx)))
4963 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
4964 error ("iteration variable %qs should not be firstprivate",
4965 IDENTIFIER_POINTER (DECL_NAME (decl)));
4966 else if ((n->value & GOVD_REDUCTION) != 0)
4967 error ("iteration variable %qs should not be reduction",
4968 IDENTIFIER_POINTER (DECL_NAME (decl)));
4970 return true;
4973 if (ctx->is_parallel)
4974 return false;
4975 else if (ctx->outer_context)
4976 return omp_is_private (ctx->outer_context, decl);
4977 else
4978 return !is_global_var (decl);
4981 /* Return true if DECL is private within a parallel region
4982 that binds to the current construct's context or in parallel
4983 region's REDUCTION clause. */
4985 static bool
4986 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl)
4988 splay_tree_node n;
4992 ctx = ctx->outer_context;
4993 if (ctx == NULL)
4994 return !(is_global_var (decl)
4995 /* References might be private, but might be shared too. */
4996 || lang_hooks.decls.omp_privatize_by_reference (decl));
4998 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4999 if (n != NULL)
5000 return (n->value & GOVD_SHARED) == 0;
5002 while (!ctx->is_parallel);
5003 return false;
5006 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
5007 and previous omp contexts. */
5009 static void
5010 gimplify_scan_omp_clauses (tree *list_p, tree *pre_p, bool in_parallel,
5011 bool in_combined_parallel)
5013 struct gimplify_omp_ctx *ctx, *outer_ctx;
5014 tree c;
5016 ctx = new_omp_context (in_parallel, in_combined_parallel);
5017 outer_ctx = ctx->outer_context;
5019 while ((c = *list_p) != NULL)
5021 enum gimplify_status gs;
5022 bool remove = false;
5023 bool notice_outer = true;
5024 const char *check_non_private = NULL;
5025 unsigned int flags;
5026 tree decl;
5028 switch (OMP_CLAUSE_CODE (c))
5030 case OMP_CLAUSE_PRIVATE:
5031 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
5032 notice_outer = false;
5033 goto do_add;
5034 case OMP_CLAUSE_SHARED:
5035 flags = GOVD_SHARED | GOVD_EXPLICIT;
5036 goto do_add;
5037 case OMP_CLAUSE_FIRSTPRIVATE:
5038 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
5039 check_non_private = "firstprivate";
5040 goto do_add;
5041 case OMP_CLAUSE_LASTPRIVATE:
5042 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
5043 check_non_private = "lastprivate";
5044 goto do_add;
5045 case OMP_CLAUSE_REDUCTION:
5046 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
5047 check_non_private = "reduction";
5048 goto do_add;
5050 do_add:
5051 decl = OMP_CLAUSE_DECL (c);
5052 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
5054 remove = true;
5055 break;
5057 omp_add_variable (ctx, decl, flags);
5058 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
5059 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
5061 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
5062 GOVD_LOCAL | GOVD_SEEN);
5063 gimplify_omp_ctxp = ctx;
5064 push_gimplify_context ();
5065 gimplify_stmt (&OMP_CLAUSE_REDUCTION_INIT (c));
5066 pop_gimplify_context (OMP_CLAUSE_REDUCTION_INIT (c));
5067 push_gimplify_context ();
5068 gimplify_stmt (&OMP_CLAUSE_REDUCTION_MERGE (c));
5069 pop_gimplify_context (OMP_CLAUSE_REDUCTION_MERGE (c));
5070 gimplify_omp_ctxp = outer_ctx;
5072 if (notice_outer)
5073 goto do_notice;
5074 break;
5076 case OMP_CLAUSE_COPYIN:
5077 case OMP_CLAUSE_COPYPRIVATE:
5078 decl = OMP_CLAUSE_DECL (c);
5079 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
5081 remove = true;
5082 break;
5084 do_notice:
5085 if (outer_ctx)
5086 omp_notice_variable (outer_ctx, decl, true);
5087 if (check_non_private
5088 && !in_parallel
5089 && omp_check_private (ctx, decl))
5091 error ("%s variable %qs is private in outer context",
5092 check_non_private, IDENTIFIER_POINTER (DECL_NAME (decl)));
5093 remove = true;
5095 break;
5097 case OMP_CLAUSE_IF:
5098 OMP_CLAUSE_OPERAND (c, 0)
5099 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
5100 /* Fall through. */
5102 case OMP_CLAUSE_SCHEDULE:
5103 case OMP_CLAUSE_NUM_THREADS:
5104 gs = gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
5105 is_gimple_val, fb_rvalue);
5106 if (gs == GS_ERROR)
5107 remove = true;
5108 break;
5110 case OMP_CLAUSE_NOWAIT:
5111 case OMP_CLAUSE_ORDERED:
5112 break;
5114 case OMP_CLAUSE_DEFAULT:
5115 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
5116 break;
5118 default:
5119 gcc_unreachable ();
5122 if (remove)
5123 *list_p = OMP_CLAUSE_CHAIN (c);
5124 else
5125 list_p = &OMP_CLAUSE_CHAIN (c);
5128 gimplify_omp_ctxp = ctx;
5131 /* For all variables that were not actually used within the context,
5132 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
5134 static int
5135 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
5137 tree *list_p = (tree *) data;
5138 tree decl = (tree) n->key;
5139 unsigned flags = n->value;
5140 enum omp_clause_code code;
5141 tree clause;
5142 bool private_debug;
5144 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
5145 return 0;
5146 if ((flags & GOVD_SEEN) == 0)
5147 return 0;
5148 if (flags & GOVD_DEBUG_PRIVATE)
5150 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
5151 private_debug = true;
5153 else
5154 private_debug
5155 = lang_hooks.decls.omp_private_debug_clause (decl,
5156 !!(flags & GOVD_SHARED));
5157 if (private_debug)
5158 code = OMP_CLAUSE_PRIVATE;
5159 else if (flags & GOVD_SHARED)
5161 if (is_global_var (decl))
5163 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
5164 while (ctx != NULL)
5166 splay_tree_node on
5167 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5168 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
5169 | GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
5170 break;
5171 ctx = ctx->outer_context;
5173 if (ctx == NULL)
5174 return 0;
5176 code = OMP_CLAUSE_SHARED;
5178 else if (flags & GOVD_PRIVATE)
5179 code = OMP_CLAUSE_PRIVATE;
5180 else if (flags & GOVD_FIRSTPRIVATE)
5181 code = OMP_CLAUSE_FIRSTPRIVATE;
5182 else
5183 gcc_unreachable ();
5185 clause = build_omp_clause (code);
5186 OMP_CLAUSE_DECL (clause) = decl;
5187 OMP_CLAUSE_CHAIN (clause) = *list_p;
5188 if (private_debug)
5189 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
5190 *list_p = clause;
5192 return 0;
5195 static void
5196 gimplify_adjust_omp_clauses (tree *list_p)
5198 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
5199 tree c, decl;
5201 while ((c = *list_p) != NULL)
5203 splay_tree_node n;
5204 bool remove = false;
5206 switch (OMP_CLAUSE_CODE (c))
5208 case OMP_CLAUSE_PRIVATE:
5209 case OMP_CLAUSE_SHARED:
5210 case OMP_CLAUSE_FIRSTPRIVATE:
5211 decl = OMP_CLAUSE_DECL (c);
5212 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5213 remove = !(n->value & GOVD_SEEN);
5214 if (! remove)
5216 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
5217 if ((n->value & GOVD_DEBUG_PRIVATE)
5218 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
5220 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
5221 || ((n->value & GOVD_DATA_SHARE_CLASS)
5222 == GOVD_PRIVATE));
5223 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
5224 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
5227 break;
5229 case OMP_CLAUSE_LASTPRIVATE:
5230 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
5231 accurately reflect the presence of a FIRSTPRIVATE clause. */
5232 decl = OMP_CLAUSE_DECL (c);
5233 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5234 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
5235 = (n->value & GOVD_FIRSTPRIVATE) != 0;
5236 break;
5238 case OMP_CLAUSE_REDUCTION:
5239 case OMP_CLAUSE_COPYIN:
5240 case OMP_CLAUSE_COPYPRIVATE:
5241 case OMP_CLAUSE_IF:
5242 case OMP_CLAUSE_NUM_THREADS:
5243 case OMP_CLAUSE_SCHEDULE:
5244 case OMP_CLAUSE_NOWAIT:
5245 case OMP_CLAUSE_ORDERED:
5246 case OMP_CLAUSE_DEFAULT:
5247 break;
5249 default:
5250 gcc_unreachable ();
5253 if (remove)
5254 *list_p = OMP_CLAUSE_CHAIN (c);
5255 else
5256 list_p = &OMP_CLAUSE_CHAIN (c);
5259 /* Add in any implicit data sharing. */
5260 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
5262 gimplify_omp_ctxp = ctx->outer_context;
5263 delete_omp_context (ctx);
5266 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
5267 gimplification of the body, as well as scanning the body for used
5268 variables. We need to do this scan now, because variable-sized
5269 decls will be decomposed during gimplification. */
5271 static enum gimplify_status
5272 gimplify_omp_parallel (tree *expr_p, tree *pre_p)
5274 tree expr = *expr_p;
5276 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p, true,
5277 OMP_PARALLEL_COMBINED (expr));
5279 push_gimplify_context ();
5281 gimplify_stmt (&OMP_PARALLEL_BODY (expr));
5283 if (TREE_CODE (OMP_PARALLEL_BODY (expr)) == BIND_EXPR)
5284 pop_gimplify_context (OMP_PARALLEL_BODY (expr));
5285 else
5286 pop_gimplify_context (NULL_TREE);
5288 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
5290 return GS_ALL_DONE;
5293 /* Gimplify the gross structure of an OMP_FOR statement. */
5295 static enum gimplify_status
5296 gimplify_omp_for (tree *expr_p, tree *pre_p)
5298 tree for_stmt, decl, var, t;
5299 enum gimplify_status ret = GS_OK;
5300 tree body, init_decl = NULL_TREE;
5302 for_stmt = *expr_p;
5304 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, false, false);
5306 t = OMP_FOR_INIT (for_stmt);
5307 gcc_assert (TREE_CODE (t) == MODIFY_EXPR
5308 || TREE_CODE (t) == GIMPLE_MODIFY_STMT);
5309 decl = GENERIC_TREE_OPERAND (t, 0);
5310 gcc_assert (DECL_P (decl));
5311 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl)));
5313 /* Make sure the iteration variable is private. */
5314 if (omp_is_private (gimplify_omp_ctxp, decl))
5315 omp_notice_variable (gimplify_omp_ctxp, decl, true);
5316 else
5317 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
5319 /* If DECL is not a gimple register, create a temporary variable to act as an
5320 iteration counter. This is valid, since DECL cannot be modified in the
5321 body of the loop. */
5322 if (!is_gimple_reg (decl))
5324 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
5325 GENERIC_TREE_OPERAND (t, 0) = var;
5327 init_decl = build_gimple_modify_stmt (decl, var);
5328 omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
5330 else
5331 var = decl;
5333 ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
5334 &OMP_FOR_PRE_BODY (for_stmt),
5335 NULL, is_gimple_val, fb_rvalue);
5337 tree_to_gimple_tuple (&OMP_FOR_INIT (for_stmt));
5339 t = OMP_FOR_COND (for_stmt);
5340 gcc_assert (COMPARISON_CLASS_P (t));
5341 gcc_assert (GENERIC_TREE_OPERAND (t, 0) == decl);
5342 TREE_OPERAND (t, 0) = var;
5344 ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
5345 &OMP_FOR_PRE_BODY (for_stmt),
5346 NULL, is_gimple_val, fb_rvalue);
5348 tree_to_gimple_tuple (&OMP_FOR_INCR (for_stmt));
5349 t = OMP_FOR_INCR (for_stmt);
5350 switch (TREE_CODE (t))
5352 case PREINCREMENT_EXPR:
5353 case POSTINCREMENT_EXPR:
5354 t = build_int_cst (TREE_TYPE (decl), 1);
5355 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
5356 t = build_gimple_modify_stmt (var, t);
5357 OMP_FOR_INCR (for_stmt) = t;
5358 break;
5360 case PREDECREMENT_EXPR:
5361 case POSTDECREMENT_EXPR:
5362 t = build_int_cst (TREE_TYPE (decl), -1);
5363 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
5364 t = build_gimple_modify_stmt (var, t);
5365 OMP_FOR_INCR (for_stmt) = t;
5366 break;
5368 case GIMPLE_MODIFY_STMT:
5369 gcc_assert (GIMPLE_STMT_OPERAND (t, 0) == decl);
5370 GIMPLE_STMT_OPERAND (t, 0) = var;
5372 t = GIMPLE_STMT_OPERAND (t, 1);
5373 switch (TREE_CODE (t))
5375 case PLUS_EXPR:
5376 if (TREE_OPERAND (t, 1) == decl)
5378 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
5379 TREE_OPERAND (t, 0) = var;
5380 break;
5383 /* Fallthru. */
5384 case MINUS_EXPR:
5385 gcc_assert (TREE_OPERAND (t, 0) == decl);
5386 TREE_OPERAND (t, 0) = var;
5387 break;
5388 default:
5389 gcc_unreachable ();
5392 ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
5393 NULL, is_gimple_val, fb_rvalue);
5394 break;
5396 default:
5397 gcc_unreachable ();
5400 body = OMP_FOR_BODY (for_stmt);
5401 gimplify_to_stmt_list (&body);
5402 t = alloc_stmt_list ();
5403 if (init_decl)
5404 append_to_statement_list (init_decl, &t);
5405 append_to_statement_list (body, &t);
5406 OMP_FOR_BODY (for_stmt) = t;
5407 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
5409 return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR;
5412 /* Gimplify the gross structure of other OpenMP worksharing constructs.
5413 In particular, OMP_SECTIONS and OMP_SINGLE. */
5415 static enum gimplify_status
5416 gimplify_omp_workshare (tree *expr_p, tree *pre_p)
5418 tree stmt = *expr_p;
5420 gimplify_scan_omp_clauses (&OMP_CLAUSES (stmt), pre_p, false, false);
5421 gimplify_to_stmt_list (&OMP_BODY (stmt));
5422 gimplify_adjust_omp_clauses (&OMP_CLAUSES (stmt));
5424 return GS_ALL_DONE;
5427 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
5428 stabilized the lhs of the atomic operation as *ADDR. Return true if
5429 EXPR is this stabilized form. */
5431 static bool
5432 goa_lhs_expr_p (tree expr, tree addr)
5434 /* Also include casts to other type variants. The C front end is fond
5435 of adding these for e.g. volatile variables. This is like
5436 STRIP_TYPE_NOPS but includes the main variant lookup. */
5437 while ((TREE_CODE (expr) == NOP_EXPR
5438 || TREE_CODE (expr) == CONVERT_EXPR
5439 || TREE_CODE (expr) == NON_LVALUE_EXPR)
5440 && TREE_OPERAND (expr, 0) != error_mark_node
5441 && (TYPE_MAIN_VARIANT (TREE_TYPE (expr))
5442 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (expr, 0)))))
5443 expr = TREE_OPERAND (expr, 0);
5445 if (TREE_CODE (expr) == INDIRECT_REF)
5447 expr = TREE_OPERAND (expr, 0);
5448 while (expr != addr
5449 && (TREE_CODE (expr) == NOP_EXPR
5450 || TREE_CODE (expr) == CONVERT_EXPR
5451 || TREE_CODE (expr) == NON_LVALUE_EXPR)
5452 && TREE_CODE (expr) == TREE_CODE (addr)
5453 && TYPE_MAIN_VARIANT (TREE_TYPE (expr))
5454 == TYPE_MAIN_VARIANT (TREE_TYPE (addr)))
5456 expr = TREE_OPERAND (expr, 0);
5457 addr = TREE_OPERAND (addr, 0);
5459 return expr == addr;
5461 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
5462 return true;
5463 return false;
5466 /* Walk *EXPR_P and replace
5467 appearances of *LHS_ADDR with LHS_VAR. If an expression does not involve
5468 the lhs, evaluate it into a temporary. Return 1 if the lhs appeared as
5469 a subexpression, 0 if it did not, or -1 if an error was encountered. */
5471 static int
5472 goa_stabilize_expr (tree *expr_p, tree *pre_p, tree lhs_addr, tree lhs_var)
5474 tree expr = *expr_p;
5475 int saw_lhs;
5477 if (goa_lhs_expr_p (expr, lhs_addr))
5479 *expr_p = lhs_var;
5480 return 1;
5482 if (is_gimple_val (expr))
5483 return 0;
5485 saw_lhs = 0;
5486 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
5488 case tcc_binary:
5489 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
5490 lhs_addr, lhs_var);
5491 case tcc_unary:
5492 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
5493 lhs_addr, lhs_var);
5494 break;
5495 default:
5496 break;
5499 if (saw_lhs == 0)
5501 enum gimplify_status gs;
5502 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
5503 if (gs != GS_ALL_DONE)
5504 saw_lhs = -1;
5507 return saw_lhs;
5510 /* Gimplify an OMP_ATOMIC statement. */
5512 static enum gimplify_status
5513 gimplify_omp_atomic (tree *expr_p, tree *pre_p)
5515 tree addr = TREE_OPERAND (*expr_p, 0);
5516 tree rhs = TREE_OPERAND (*expr_p, 1);
5517 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
5518 tree tmp_load, load, store;
5520 tmp_load = create_tmp_var (type, NULL);
5521 if (goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
5522 return GS_ERROR;
5524 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
5525 != GS_ALL_DONE)
5526 return GS_ERROR;
5528 load = build2 (OMP_ATOMIC_LOAD, void_type_node, tmp_load, addr);
5529 append_to_statement_list (load, pre_p);
5530 if (gimplify_expr (&rhs, pre_p, NULL, is_gimple_val, fb_rvalue)
5531 != GS_ALL_DONE)
5532 return GS_ERROR;
5533 store = build1 (OMP_ATOMIC_STORE, void_type_node, rhs);
5534 *expr_p = store;
5536 return GS_ALL_DONE;
5540 /* Gimplifies the expression tree pointed to by EXPR_P. Return 0 if
5541 gimplification failed.
5543 PRE_P points to the list where side effects that must happen before
5544 EXPR should be stored.
5546 POST_P points to the list where side effects that must happen after
5547 EXPR should be stored, or NULL if there is no suitable list. In
5548 that case, we copy the result to a temporary, emit the
5549 post-effects, and then return the temporary.
5551 GIMPLE_TEST_F points to a function that takes a tree T and
5552 returns nonzero if T is in the GIMPLE form requested by the
5553 caller. The GIMPLE predicates are in tree-gimple.c.
5555 This test is used twice. Before gimplification, the test is
5556 invoked to determine whether *EXPR_P is already gimple enough. If
5557 that fails, *EXPR_P is gimplified according to its code and
5558 GIMPLE_TEST_F is called again. If the test still fails, then a new
5559 temporary variable is created and assigned the value of the
5560 gimplified expression.
5562 FALLBACK tells the function what sort of a temporary we want. If the 1
5563 bit is set, an rvalue is OK. If the 2 bit is set, an lvalue is OK.
5564 If both are set, either is OK, but an lvalue is preferable.
5566 The return value is either GS_ERROR or GS_ALL_DONE, since this function
5567 iterates until solution. */
5569 enum gimplify_status
5570 gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
5571 bool (* gimple_test_f) (tree), fallback_t fallback)
5573 tree tmp;
5574 tree internal_pre = NULL_TREE;
5575 tree internal_post = NULL_TREE;
5576 tree save_expr;
5577 int is_statement = (pre_p == NULL);
5578 location_t saved_location;
5579 enum gimplify_status ret;
5581 save_expr = *expr_p;
5582 if (save_expr == NULL_TREE)
5583 return GS_ALL_DONE;
5585 /* We used to check the predicate here and return immediately if it
5586 succeeds. This is wrong; the design is for gimplification to be
5587 idempotent, and for the predicates to only test for valid forms, not
5588 whether they are fully simplified. */
5590 /* Set up our internal queues if needed. */
5591 if (pre_p == NULL)
5592 pre_p = &internal_pre;
5593 if (post_p == NULL)
5594 post_p = &internal_post;
5596 saved_location = input_location;
5597 if (save_expr != error_mark_node
5598 && EXPR_HAS_LOCATION (*expr_p))
5599 input_location = EXPR_LOCATION (*expr_p);
5601 /* Loop over the specific gimplifiers until the toplevel node
5602 remains the same. */
5605 /* Strip away as many useless type conversions as possible
5606 at the toplevel. */
5607 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
5609 /* Remember the expr. */
5610 save_expr = *expr_p;
5612 /* Die, die, die, my darling. */
5613 if (save_expr == error_mark_node
5614 || (!GIMPLE_STMT_P (save_expr)
5615 && TREE_TYPE (save_expr)
5616 && TREE_TYPE (save_expr) == error_mark_node))
5618 ret = GS_ERROR;
5619 break;
5622 /* Do any language-specific gimplification. */
5623 ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p);
5624 if (ret == GS_OK)
5626 if (*expr_p == NULL_TREE)
5627 break;
5628 if (*expr_p != save_expr)
5629 continue;
5631 else if (ret != GS_UNHANDLED)
5632 break;
5634 ret = GS_OK;
5635 switch (TREE_CODE (*expr_p))
5637 /* First deal with the special cases. */
5639 case POSTINCREMENT_EXPR:
5640 case POSTDECREMENT_EXPR:
5641 case PREINCREMENT_EXPR:
5642 case PREDECREMENT_EXPR:
5643 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
5644 fallback != fb_none);
5645 break;
5647 case ARRAY_REF:
5648 case ARRAY_RANGE_REF:
5649 case REALPART_EXPR:
5650 case IMAGPART_EXPR:
5651 case COMPONENT_REF:
5652 case VIEW_CONVERT_EXPR:
5653 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
5654 fallback ? fallback : fb_rvalue);
5655 break;
5657 case COND_EXPR:
5658 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
5659 /* C99 code may assign to an array in a structure value of a
5660 conditional expression, and this has undefined behavior
5661 only on execution, so create a temporary if an lvalue is
5662 required. */
5663 if (fallback == fb_lvalue)
5665 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5666 mark_addressable (*expr_p);
5668 break;
5670 case CALL_EXPR:
5671 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
5672 /* C99 code may assign to an array in a structure returned
5673 from a function, and this has undefined behavior only on
5674 execution, so create a temporary if an lvalue is
5675 required. */
5676 if (fallback == fb_lvalue)
5678 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5679 mark_addressable (*expr_p);
5681 break;
5683 case TREE_LIST:
5684 gcc_unreachable ();
5686 case COMPOUND_EXPR:
5687 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
5688 break;
5690 case MODIFY_EXPR:
5691 case GIMPLE_MODIFY_STMT:
5692 case INIT_EXPR:
5693 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
5694 fallback != fb_none);
5696 if (*expr_p)
5698 /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer
5699 useful. */
5700 if (TREE_CODE (*expr_p) == INIT_EXPR)
5701 TREE_SET_CODE (*expr_p, MODIFY_EXPR);
5703 /* Convert MODIFY_EXPR to GIMPLE_MODIFY_STMT. */
5704 if (TREE_CODE (*expr_p) == MODIFY_EXPR)
5705 tree_to_gimple_tuple (expr_p);
5708 break;
5710 case TRUTH_ANDIF_EXPR:
5711 case TRUTH_ORIF_EXPR:
5712 ret = gimplify_boolean_expr (expr_p);
5713 break;
5715 case TRUTH_NOT_EXPR:
5716 TREE_OPERAND (*expr_p, 0)
5717 = gimple_boolify (TREE_OPERAND (*expr_p, 0));
5718 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5719 is_gimple_val, fb_rvalue);
5720 recalculate_side_effects (*expr_p);
5721 break;
5723 case ADDR_EXPR:
5724 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
5725 break;
5727 case VA_ARG_EXPR:
5728 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
5729 break;
5731 case CONVERT_EXPR:
5732 case NOP_EXPR:
5733 if (IS_EMPTY_STMT (*expr_p))
5735 ret = GS_ALL_DONE;
5736 break;
5739 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
5740 || fallback == fb_none)
5742 /* Just strip a conversion to void (or in void context) and
5743 try again. */
5744 *expr_p = TREE_OPERAND (*expr_p, 0);
5745 break;
5748 ret = gimplify_conversion (expr_p);
5749 if (ret == GS_ERROR)
5750 break;
5751 if (*expr_p != save_expr)
5752 break;
5753 /* FALLTHRU */
5755 case FIX_TRUNC_EXPR:
5756 /* unary_expr: ... | '(' cast ')' val | ... */
5757 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5758 is_gimple_val, fb_rvalue);
5759 recalculate_side_effects (*expr_p);
5760 break;
5762 case INDIRECT_REF:
5763 *expr_p = fold_indirect_ref (*expr_p);
5764 if (*expr_p != save_expr)
5765 break;
5766 /* else fall through. */
5767 case ALIGN_INDIRECT_REF:
5768 case MISALIGNED_INDIRECT_REF:
5769 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5770 is_gimple_reg, fb_rvalue);
5771 recalculate_side_effects (*expr_p);
5772 break;
5774 /* Constants need not be gimplified. */
5775 case INTEGER_CST:
5776 case REAL_CST:
5777 case FIXED_CST:
5778 case STRING_CST:
5779 case COMPLEX_CST:
5780 case VECTOR_CST:
5781 ret = GS_ALL_DONE;
5782 break;
5784 case CONST_DECL:
5785 /* If we require an lvalue, such as for ADDR_EXPR, retain the
5786 CONST_DECL node. Otherwise the decl is replaceable by its
5787 value. */
5788 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
5789 if (fallback & fb_lvalue)
5790 ret = GS_ALL_DONE;
5791 else
5792 *expr_p = DECL_INITIAL (*expr_p);
5793 break;
5795 case DECL_EXPR:
5796 ret = gimplify_decl_expr (expr_p);
5797 break;
5799 case EXC_PTR_EXPR:
5800 /* FIXME make this a decl. */
5801 ret = GS_ALL_DONE;
5802 break;
5804 case BIND_EXPR:
5805 ret = gimplify_bind_expr (expr_p, pre_p);
5806 break;
5808 case LOOP_EXPR:
5809 ret = gimplify_loop_expr (expr_p, pre_p);
5810 break;
5812 case SWITCH_EXPR:
5813 ret = gimplify_switch_expr (expr_p, pre_p);
5814 break;
5816 case EXIT_EXPR:
5817 ret = gimplify_exit_expr (expr_p);
5818 break;
5820 case GOTO_EXPR:
5821 /* If the target is not LABEL, then it is a computed jump
5822 and the target needs to be gimplified. */
5823 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
5824 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
5825 NULL, is_gimple_val, fb_rvalue);
5826 break;
5828 case LABEL_EXPR:
5829 ret = GS_ALL_DONE;
5830 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
5831 == current_function_decl);
5832 break;
5834 case CASE_LABEL_EXPR:
5835 ret = gimplify_case_label_expr (expr_p);
5836 break;
5838 case RETURN_EXPR:
5839 ret = gimplify_return_expr (*expr_p, pre_p);
5840 break;
5842 case CONSTRUCTOR:
5843 /* Don't reduce this in place; let gimplify_init_constructor work its
5844 magic. Buf if we're just elaborating this for side effects, just
5845 gimplify any element that has side-effects. */
5846 if (fallback == fb_none)
5848 unsigned HOST_WIDE_INT ix;
5849 constructor_elt *ce;
5850 tree temp = NULL_TREE;
5851 for (ix = 0;
5852 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
5853 ix, ce);
5854 ix++)
5855 if (TREE_SIDE_EFFECTS (ce->value))
5856 append_to_statement_list (ce->value, &temp);
5858 *expr_p = temp;
5859 ret = GS_OK;
5861 /* C99 code may assign to an array in a constructed
5862 structure or union, and this has undefined behavior only
5863 on execution, so create a temporary if an lvalue is
5864 required. */
5865 else if (fallback == fb_lvalue)
5867 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5868 mark_addressable (*expr_p);
5870 else
5871 ret = GS_ALL_DONE;
5872 break;
5874 /* The following are special cases that are not handled by the
5875 original GIMPLE grammar. */
5877 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
5878 eliminated. */
5879 case SAVE_EXPR:
5880 ret = gimplify_save_expr (expr_p, pre_p, post_p);
5881 break;
5883 case BIT_FIELD_REF:
5885 enum gimplify_status r0, r1, r2;
5887 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5888 is_gimple_lvalue, fb_either);
5889 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5890 is_gimple_val, fb_rvalue);
5891 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p,
5892 is_gimple_val, fb_rvalue);
5893 recalculate_side_effects (*expr_p);
5895 ret = MIN (r0, MIN (r1, r2));
5897 break;
5899 case NON_LVALUE_EXPR:
5900 /* This should have been stripped above. */
5901 gcc_unreachable ();
5903 case ASM_EXPR:
5904 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
5905 break;
5907 case TRY_FINALLY_EXPR:
5908 case TRY_CATCH_EXPR:
5909 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0));
5910 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1));
5911 ret = GS_ALL_DONE;
5912 break;
5914 case CLEANUP_POINT_EXPR:
5915 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
5916 break;
5918 case TARGET_EXPR:
5919 ret = gimplify_target_expr (expr_p, pre_p, post_p);
5920 break;
5922 case CATCH_EXPR:
5923 gimplify_to_stmt_list (&CATCH_BODY (*expr_p));
5924 ret = GS_ALL_DONE;
5925 break;
5927 case EH_FILTER_EXPR:
5928 gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p));
5929 ret = GS_ALL_DONE;
5930 break;
5932 case CHANGE_DYNAMIC_TYPE_EXPR:
5933 ret = gimplify_expr (&CHANGE_DYNAMIC_TYPE_LOCATION (*expr_p),
5934 pre_p, post_p, is_gimple_reg, fb_lvalue);
5935 break;
5937 case OBJ_TYPE_REF:
5939 enum gimplify_status r0, r1;
5940 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p,
5941 is_gimple_val, fb_rvalue);
5942 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
5943 is_gimple_val, fb_rvalue);
5944 ret = MIN (r0, r1);
5946 break;
5948 case LABEL_DECL:
5949 /* We get here when taking the address of a label. We mark
5950 the label as "forced"; meaning it can never be removed and
5951 it is a potential target for any computed goto. */
5952 FORCED_LABEL (*expr_p) = 1;
5953 ret = GS_ALL_DONE;
5954 break;
5956 case STATEMENT_LIST:
5957 ret = gimplify_statement_list (expr_p, pre_p);
5958 break;
5960 case WITH_SIZE_EXPR:
5962 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5963 post_p == &internal_post ? NULL : post_p,
5964 gimple_test_f, fallback);
5965 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5966 is_gimple_val, fb_rvalue);
5968 break;
5970 case VAR_DECL:
5971 case PARM_DECL:
5972 ret = gimplify_var_or_parm_decl (expr_p);
5973 break;
5975 case RESULT_DECL:
5976 /* When within an OpenMP context, notice uses of variables. */
5977 if (gimplify_omp_ctxp)
5978 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
5979 ret = GS_ALL_DONE;
5980 break;
5982 case SSA_NAME:
5983 /* Allow callbacks into the gimplifier during optimization. */
5984 ret = GS_ALL_DONE;
5985 break;
5987 case OMP_PARALLEL:
5988 ret = gimplify_omp_parallel (expr_p, pre_p);
5989 break;
5991 case OMP_FOR:
5992 ret = gimplify_omp_for (expr_p, pre_p);
5993 break;
5995 case OMP_SECTIONS:
5996 case OMP_SINGLE:
5997 ret = gimplify_omp_workshare (expr_p, pre_p);
5998 break;
6000 case OMP_SECTION:
6001 case OMP_MASTER:
6002 case OMP_ORDERED:
6003 case OMP_CRITICAL:
6004 gimplify_to_stmt_list (&OMP_BODY (*expr_p));
6005 break;
6007 case OMP_ATOMIC:
6008 ret = gimplify_omp_atomic (expr_p, pre_p);
6009 break;
6011 case OMP_RETURN:
6012 case OMP_CONTINUE:
6013 case OMP_ATOMIC_LOAD:
6014 case OMP_ATOMIC_STORE:
6016 ret = GS_ALL_DONE;
6017 break;
6019 case POINTER_PLUS_EXPR:
6020 /* Convert ((type *)A)+offset into &A->field_of_type_and_offset.
6021 The second is gimple immediate saving a need for extra statement.
6023 if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
6024 && (tmp = maybe_fold_offset_to_reference
6025 (TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
6026 TREE_TYPE (TREE_TYPE (*expr_p)))))
6028 tree ptr_type = build_pointer_type (TREE_TYPE (tmp));
6029 if (useless_type_conversion_p (TREE_TYPE (*expr_p), ptr_type))
6031 *expr_p = build_fold_addr_expr_with_type (tmp, ptr_type);
6032 break;
6035 /* Convert (void *)&a + 4 into (void *)&a[1]. */
6036 if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
6037 && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
6038 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p,
6039 0),0)))
6040 && (tmp = maybe_fold_offset_to_reference
6041 (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
6042 TREE_OPERAND (*expr_p, 1),
6043 TREE_TYPE (TREE_TYPE
6044 (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
6045 0))))))
6047 tmp = build_fold_addr_expr (tmp);
6048 *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
6049 break;
6051 /* FALLTHRU */
6052 default:
6053 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
6055 case tcc_comparison:
6056 /* Handle comparison of objects of non scalar mode aggregates
6057 with a call to memcmp. It would be nice to only have to do
6058 this for variable-sized objects, but then we'd have to allow
6059 the same nest of reference nodes we allow for MODIFY_EXPR and
6060 that's too complex.
6062 Compare scalar mode aggregates as scalar mode values. Using
6063 memcmp for them would be very inefficient at best, and is
6064 plain wrong if bitfields are involved. */
6067 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
6069 if (!AGGREGATE_TYPE_P (type))
6070 goto expr_2;
6071 else if (TYPE_MODE (type) != BLKmode)
6072 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
6073 else
6074 ret = gimplify_variable_sized_compare (expr_p);
6076 break;
6079 /* If *EXPR_P does not need to be special-cased, handle it
6080 according to its class. */
6081 case tcc_unary:
6082 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
6083 post_p, is_gimple_val, fb_rvalue);
6084 break;
6086 case tcc_binary:
6087 expr_2:
6089 enum gimplify_status r0, r1;
6091 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
6092 post_p, is_gimple_val, fb_rvalue);
6093 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
6094 post_p, is_gimple_val, fb_rvalue);
6096 ret = MIN (r0, r1);
6097 break;
6100 case tcc_declaration:
6101 case tcc_constant:
6102 ret = GS_ALL_DONE;
6103 goto dont_recalculate;
6105 default:
6106 gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
6107 || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
6108 || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
6109 goto expr_2;
6112 recalculate_side_effects (*expr_p);
6113 dont_recalculate:
6114 break;
6117 /* If we replaced *expr_p, gimplify again. */
6118 if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
6119 ret = GS_ALL_DONE;
6121 while (ret == GS_OK);
6123 /* If we encountered an error_mark somewhere nested inside, either
6124 stub out the statement or propagate the error back out. */
6125 if (ret == GS_ERROR)
6127 if (is_statement)
6128 *expr_p = NULL;
6129 goto out;
6132 /* This was only valid as a return value from the langhook, which
6133 we handled. Make sure it doesn't escape from any other context. */
6134 gcc_assert (ret != GS_UNHANDLED);
6136 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
6138 /* We aren't looking for a value, and we don't have a valid
6139 statement. If it doesn't have side-effects, throw it away. */
6140 if (!TREE_SIDE_EFFECTS (*expr_p))
6141 *expr_p = NULL;
6142 else if (!TREE_THIS_VOLATILE (*expr_p))
6144 /* This is probably a _REF that contains something nested that
6145 has side effects. Recurse through the operands to find it. */
6146 enum tree_code code = TREE_CODE (*expr_p);
6148 switch (code)
6150 case COMPONENT_REF:
6151 case REALPART_EXPR:
6152 case IMAGPART_EXPR:
6153 case VIEW_CONVERT_EXPR:
6154 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
6155 gimple_test_f, fallback);
6156 break;
6158 case ARRAY_REF:
6159 case ARRAY_RANGE_REF:
6160 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
6161 gimple_test_f, fallback);
6162 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
6163 gimple_test_f, fallback);
6164 break;
6166 default:
6167 /* Anything else with side-effects must be converted to
6168 a valid statement before we get here. */
6169 gcc_unreachable ();
6172 *expr_p = NULL;
6174 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
6175 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
6177 /* Historically, the compiler has treated a bare reference
6178 to a non-BLKmode volatile lvalue as forcing a load. */
6179 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
6180 /* Normally, we do not want to create a temporary for a
6181 TREE_ADDRESSABLE type because such a type should not be
6182 copied by bitwise-assignment. However, we make an
6183 exception here, as all we are doing here is ensuring that
6184 we read the bytes that make up the type. We use
6185 create_tmp_var_raw because create_tmp_var will abort when
6186 given a TREE_ADDRESSABLE type. */
6187 tree tmp = create_tmp_var_raw (type, "vol");
6188 gimple_add_tmp_var (tmp);
6189 *expr_p = build_gimple_modify_stmt (tmp, *expr_p);
6191 else
6192 /* We can't do anything useful with a volatile reference to
6193 an incomplete type, so just throw it away. Likewise for
6194 a BLKmode type, since any implicit inner load should
6195 already have been turned into an explicit one by the
6196 gimplification process. */
6197 *expr_p = NULL;
6200 /* If we are gimplifying at the statement level, we're done. Tack
6201 everything together and replace the original statement with the
6202 gimplified form. */
6203 if (fallback == fb_none || is_statement)
6205 if (internal_pre || internal_post)
6207 append_to_statement_list (*expr_p, &internal_pre);
6208 append_to_statement_list (internal_post, &internal_pre);
6209 annotate_all_with_locus (&internal_pre, input_location);
6210 *expr_p = internal_pre;
6212 else if (!*expr_p)
6214 else if (TREE_CODE (*expr_p) == STATEMENT_LIST)
6215 annotate_all_with_locus (expr_p, input_location);
6216 else
6217 annotate_one_with_locus (*expr_p, input_location);
6218 goto out;
6221 /* Otherwise we're gimplifying a subexpression, so the resulting value is
6222 interesting. */
6224 /* If it's sufficiently simple already, we're done. Unless we are
6225 handling some post-effects internally; if that's the case, we need to
6226 copy into a temp before adding the post-effects to the tree. */
6227 if (!internal_post && (*gimple_test_f) (*expr_p))
6228 goto out;
6230 /* Otherwise, we need to create a new temporary for the gimplified
6231 expression. */
6233 /* We can't return an lvalue if we have an internal postqueue. The
6234 object the lvalue refers to would (probably) be modified by the
6235 postqueue; we need to copy the value out first, which means an
6236 rvalue. */
6237 if ((fallback & fb_lvalue) && !internal_post
6238 && is_gimple_addressable (*expr_p))
6240 /* An lvalue will do. Take the address of the expression, store it
6241 in a temporary, and replace the expression with an INDIRECT_REF of
6242 that temporary. */
6243 tmp = build_fold_addr_expr (*expr_p);
6244 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
6245 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
6247 else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_rhs (*expr_p))
6249 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
6251 /* An rvalue will do. Assign the gimplified expression into a new
6252 temporary TMP and replace the original expression with TMP. */
6254 if (internal_post || (fallback & fb_lvalue))
6255 /* The postqueue might change the value of the expression between
6256 the initialization and use of the temporary, so we can't use a
6257 formal temp. FIXME do we care? */
6258 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6259 else
6260 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
6262 if (TREE_CODE (*expr_p) != SSA_NAME)
6263 DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1;
6265 else
6267 #ifdef ENABLE_CHECKING
6268 if (!(fallback & fb_mayfail))
6270 fprintf (stderr, "gimplification failed:\n");
6271 print_generic_expr (stderr, *expr_p, 0);
6272 debug_tree (*expr_p);
6273 internal_error ("gimplification failed");
6275 #endif
6276 gcc_assert (fallback & fb_mayfail);
6277 /* If this is an asm statement, and the user asked for the
6278 impossible, don't die. Fail and let gimplify_asm_expr
6279 issue an error. */
6280 ret = GS_ERROR;
6281 goto out;
6284 /* Make sure the temporary matches our predicate. */
6285 gcc_assert ((*gimple_test_f) (*expr_p));
6287 if (internal_post)
6289 annotate_all_with_locus (&internal_post, input_location);
6290 append_to_statement_list (internal_post, pre_p);
6293 out:
6294 input_location = saved_location;
6295 return ret;
6298 /* Look through TYPE for variable-sized objects and gimplify each such
6299 size that we find. Add to LIST_P any statements generated. */
6301 void
6302 gimplify_type_sizes (tree type, tree *list_p)
6304 tree field, t;
6306 if (type == NULL || type == error_mark_node)
6307 return;
6309 /* We first do the main variant, then copy into any other variants. */
6310 type = TYPE_MAIN_VARIANT (type);
6312 /* Avoid infinite recursion. */
6313 if (TYPE_SIZES_GIMPLIFIED (type))
6314 return;
6316 TYPE_SIZES_GIMPLIFIED (type) = 1;
6318 switch (TREE_CODE (type))
6320 case INTEGER_TYPE:
6321 case ENUMERAL_TYPE:
6322 case BOOLEAN_TYPE:
6323 case REAL_TYPE:
6324 case FIXED_POINT_TYPE:
6325 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
6326 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
6328 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6330 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
6331 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
6333 break;
6335 case ARRAY_TYPE:
6336 /* These types may not have declarations, so handle them here. */
6337 gimplify_type_sizes (TREE_TYPE (type), list_p);
6338 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
6339 break;
6341 case RECORD_TYPE:
6342 case UNION_TYPE:
6343 case QUAL_UNION_TYPE:
6344 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6345 if (TREE_CODE (field) == FIELD_DECL)
6347 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
6348 gimplify_type_sizes (TREE_TYPE (field), list_p);
6350 break;
6352 case POINTER_TYPE:
6353 case REFERENCE_TYPE:
6354 /* We used to recurse on the pointed-to type here, which turned out to
6355 be incorrect because its definition might refer to variables not
6356 yet initialized at this point if a forward declaration is involved.
6358 It was actually useful for anonymous pointed-to types to ensure
6359 that the sizes evaluation dominates every possible later use of the
6360 values. Restricting to such types here would be safe since there
6361 is no possible forward declaration around, but would introduce an
6362 undesirable middle-end semantic to anonymity. We then defer to
6363 front-ends the responsibility of ensuring that the sizes are
6364 evaluated both early and late enough, e.g. by attaching artificial
6365 type declarations to the tree. */
6366 break;
6368 default:
6369 break;
6372 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
6373 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
6375 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6377 TYPE_SIZE (t) = TYPE_SIZE (type);
6378 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
6379 TYPE_SIZES_GIMPLIFIED (t) = 1;
6383 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
6384 a size or position, has had all of its SAVE_EXPRs evaluated.
6385 We add any required statements to STMT_P. */
6387 void
6388 gimplify_one_sizepos (tree *expr_p, tree *stmt_p)
6390 tree type, expr = *expr_p;
6392 /* We don't do anything if the value isn't there, is constant, or contains
6393 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
6394 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
6395 will want to replace it with a new variable, but that will cause problems
6396 if this type is from outside the function. It's OK to have that here. */
6397 if (expr == NULL_TREE || TREE_CONSTANT (expr)
6398 || TREE_CODE (expr) == VAR_DECL
6399 || CONTAINS_PLACEHOLDER_P (expr))
6400 return;
6402 type = TREE_TYPE (expr);
6403 *expr_p = unshare_expr (expr);
6405 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
6406 expr = *expr_p;
6408 /* Verify that we've an exact type match with the original expression.
6409 In particular, we do not wish to drop a "sizetype" in favour of a
6410 type of similar dimensions. We don't want to pollute the generic
6411 type-stripping code with this knowledge because it doesn't matter
6412 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
6413 and friends retain their "sizetype-ness". */
6414 if (TREE_TYPE (expr) != type
6415 && TREE_CODE (type) == INTEGER_TYPE
6416 && TYPE_IS_SIZETYPE (type))
6418 tree tmp;
6420 *expr_p = create_tmp_var (type, NULL);
6421 tmp = build1 (NOP_EXPR, type, expr);
6422 tmp = build_gimple_modify_stmt (*expr_p, tmp);
6423 if (EXPR_HAS_LOCATION (expr))
6424 SET_EXPR_LOCUS (tmp, EXPR_LOCUS (expr));
6425 else
6426 SET_EXPR_LOCATION (tmp, input_location);
6428 gimplify_and_add (tmp, stmt_p);
6433 /* Gimplify the body of statements pointed to by BODY_P. FNDECL is the
6434 function decl containing BODY. */
6436 void
6437 gimplify_body (tree *body_p, tree fndecl, bool do_parms)
6439 location_t saved_location = input_location;
6440 tree body, parm_stmts;
6442 timevar_push (TV_TREE_GIMPLIFY);
6444 gcc_assert (gimplify_ctxp == NULL);
6445 push_gimplify_context ();
6447 /* Unshare most shared trees in the body and in that of any nested functions.
6448 It would seem we don't have to do this for nested functions because
6449 they are supposed to be output and then the outer function gimplified
6450 first, but the g++ front end doesn't always do it that way. */
6451 unshare_body (body_p, fndecl);
6452 unvisit_body (body_p, fndecl);
6454 /* Make sure input_location isn't set to something wierd. */
6455 input_location = DECL_SOURCE_LOCATION (fndecl);
6457 /* Resolve callee-copies. This has to be done before processing
6458 the body so that DECL_VALUE_EXPR gets processed correctly. */
6459 parm_stmts = do_parms ? gimplify_parameters () : NULL;
6461 /* Gimplify the function's body. */
6462 gimplify_stmt (body_p);
6463 body = *body_p;
6465 if (!body)
6466 body = alloc_stmt_list ();
6467 else if (TREE_CODE (body) == STATEMENT_LIST)
6469 tree t = expr_only (*body_p);
6470 if (t)
6471 body = t;
6474 /* If there isn't an outer BIND_EXPR, add one. */
6475 if (TREE_CODE (body) != BIND_EXPR)
6477 tree b = build3 (BIND_EXPR, void_type_node, NULL_TREE,
6478 NULL_TREE, NULL_TREE);
6479 TREE_SIDE_EFFECTS (b) = 1;
6480 append_to_statement_list_force (body, &BIND_EXPR_BODY (b));
6481 body = b;
6484 /* If we had callee-copies statements, insert them at the beginning
6485 of the function. */
6486 if (parm_stmts)
6488 append_to_statement_list_force (BIND_EXPR_BODY (body), &parm_stmts);
6489 BIND_EXPR_BODY (body) = parm_stmts;
6492 /* Unshare again, in case gimplification was sloppy. */
6493 unshare_all_trees (body);
6495 *body_p = body;
6497 pop_gimplify_context (body);
6498 gcc_assert (gimplify_ctxp == NULL);
6500 #ifdef ENABLE_TYPES_CHECKING
6501 if (!errorcount && !sorrycount)
6502 verify_gimple_1 (BIND_EXPR_BODY (*body_p));
6503 #endif
6505 timevar_pop (TV_TREE_GIMPLIFY);
6506 input_location = saved_location;
6509 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
6510 node for the function we want to gimplify. */
6512 void
6513 gimplify_function_tree (tree fndecl)
6515 tree oldfn, parm, ret;
6517 oldfn = current_function_decl;
6518 current_function_decl = fndecl;
6519 if (DECL_STRUCT_FUNCTION (fndecl))
6520 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
6521 else
6522 push_struct_function (fndecl);
6524 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm))
6526 /* Preliminarily mark non-addressed complex variables as eligible
6527 for promotion to gimple registers. We'll transform their uses
6528 as we find them. */
6529 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
6530 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
6531 && !TREE_THIS_VOLATILE (parm)
6532 && !needs_to_live_in_memory (parm))
6533 DECL_GIMPLE_REG_P (parm) = 1;
6536 ret = DECL_RESULT (fndecl);
6537 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
6538 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
6539 && !needs_to_live_in_memory (ret))
6540 DECL_GIMPLE_REG_P (ret) = 1;
6542 gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true);
6544 /* If we're instrumenting function entry/exit, then prepend the call to
6545 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
6546 catch the exit hook. */
6547 /* ??? Add some way to ignore exceptions for this TFE. */
6548 if (flag_instrument_function_entry_exit
6549 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)
6550 && !flag_instrument_functions_exclude_p (fndecl))
6552 tree tf, x, bind;
6554 tf = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
6555 TREE_SIDE_EFFECTS (tf) = 1;
6556 x = DECL_SAVED_TREE (fndecl);
6557 append_to_statement_list (x, &TREE_OPERAND (tf, 0));
6558 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
6559 x = build_call_expr (x, 0);
6560 append_to_statement_list (x, &TREE_OPERAND (tf, 1));
6562 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
6563 TREE_SIDE_EFFECTS (bind) = 1;
6564 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
6565 x = build_call_expr (x, 0);
6566 append_to_statement_list (x, &BIND_EXPR_BODY (bind));
6567 append_to_statement_list (tf, &BIND_EXPR_BODY (bind));
6569 DECL_SAVED_TREE (fndecl) = bind;
6572 cfun->gimplified = true;
6573 current_function_decl = oldfn;
6574 pop_cfun ();
6577 /* Expands EXPR to list of gimple statements STMTS. If SIMPLE is true,
6578 force the result to be either ssa_name or an invariant, otherwise
6579 just force it to be a rhs expression. If VAR is not NULL, make the
6580 base variable of the final destination be VAR if suitable. */
6582 tree
6583 force_gimple_operand (tree expr, tree *stmts, bool simple, tree var)
6585 tree t;
6586 enum gimplify_status ret;
6587 gimple_predicate gimple_test_f;
6589 *stmts = NULL_TREE;
6591 if (is_gimple_val (expr))
6592 return expr;
6594 gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs;
6596 push_gimplify_context ();
6597 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
6598 gimplify_ctxp->allow_rhs_cond_expr = true;
6600 if (var)
6601 expr = build_gimple_modify_stmt (var, expr);
6603 if (TREE_CODE (expr) != GIMPLE_MODIFY_STMT
6604 && TREE_TYPE (expr) == void_type_node)
6606 gimplify_and_add (expr, stmts);
6607 expr = NULL_TREE;
6609 else
6611 ret = gimplify_expr (&expr, stmts, NULL,
6612 gimple_test_f, fb_rvalue);
6613 gcc_assert (ret != GS_ERROR);
6616 if (gimple_referenced_vars (cfun))
6618 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
6619 add_referenced_var (t);
6622 pop_gimplify_context (NULL);
6624 return expr;
6627 /* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR. If
6628 some statements are produced, emits them at BSI. If BEFORE is true.
6629 the statements are appended before BSI, otherwise they are appended after
6630 it. M specifies the way BSI moves after insertion (BSI_SAME_STMT or
6631 BSI_CONTINUE_LINKING are the usual values). */
6633 tree
6634 force_gimple_operand_bsi (block_stmt_iterator *bsi, tree expr,
6635 bool simple_p, tree var, bool before,
6636 enum bsi_iterator_update m)
6638 tree stmts;
6640 expr = force_gimple_operand (expr, &stmts, simple_p, var);
6641 if (stmts)
6643 if (gimple_in_ssa_p (cfun))
6645 tree_stmt_iterator tsi;
6647 for (tsi = tsi_start (stmts); !tsi_end_p (tsi); tsi_next (&tsi))
6648 mark_symbols_for_renaming (tsi_stmt (tsi));
6651 if (before)
6652 bsi_insert_before (bsi, stmts, m);
6653 else
6654 bsi_insert_after (bsi, stmts, m);
6657 return expr;
6660 #include "gt-gimplify.h"