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
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
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/>. */
26 #include "coretypes.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"
50 #include "pointer-set.h"
51 #include "splay-tree.h"
54 enum gimplify_omp_var_data
60 GOVD_FIRSTPRIVATE = 16,
61 GOVD_LASTPRIVATE = 32,
64 GOVD_DEBUG_PRIVATE = 256,
65 GOVD_PRIVATE_OUTER_REF = 512,
66 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
67 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
75 ORT_COMBINED_PARALLEL = 3
78 struct gimplify_omp_ctx
80 struct gimplify_omp_ctx *outer_context;
82 struct pointer_set_t *privatized_types;
84 enum omp_clause_default_kind default_kind;
85 enum omp_region_type region_type;
88 static struct gimplify_ctx *gimplify_ctxp;
89 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
93 /* Formal (expression) temporary table handling: Multiple occurrences of
94 the same scalar expression are evaluated into the same temporary. */
96 typedef struct gimple_temp_hash_elt
99 tree temp; /* Value */
102 /* Forward declarations. */
103 static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool);
105 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
106 form and we don't do any syntax checking. */
108 mark_addressable (tree x)
110 while (handled_component_p (x))
111 x = TREE_OPERAND (x, 0);
112 if (TREE_CODE (x) != VAR_DECL && TREE_CODE (x) != PARM_DECL)
114 TREE_ADDRESSABLE (x) = 1;
117 /* Return a hash value for a formal temporary table entry. */
120 gimple_tree_hash (const void *p)
122 tree t = ((const elt_t *) p)->val;
123 return iterative_hash_expr (t, 0);
126 /* Compare two formal temporary table entries. */
129 gimple_tree_eq (const void *p1, const void *p2)
131 tree t1 = ((const elt_t *) p1)->val;
132 tree t2 = ((const elt_t *) p2)->val;
133 enum tree_code code = TREE_CODE (t1);
135 if (TREE_CODE (t2) != code
136 || TREE_TYPE (t1) != TREE_TYPE (t2))
139 if (!operand_equal_p (t1, t2, 0))
142 /* Only allow them to compare equal if they also hash equal; otherwise
143 results are nondeterminate, and we fail bootstrap comparison. */
144 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
149 /* Set up a context for the gimplifier. */
152 push_gimplify_context (struct gimplify_ctx *c)
154 memset (c, '\0', sizeof (*c));
155 c->prev_context = gimplify_ctxp;
159 /* Tear down a context for the gimplifier. If BODY is non-null, then
160 put the temporaries into the outer BIND_EXPR. Otherwise, put them
161 in the local_decls. */
164 pop_gimplify_context (tree body)
166 struct gimplify_ctx *c = gimplify_ctxp;
169 gcc_assert (c && !c->current_bind_expr);
170 gimplify_ctxp = c->prev_context;
172 for (t = c->temps; t ; t = TREE_CHAIN (t))
173 DECL_GIMPLE_FORMAL_TEMP_P (t) = 0;
176 declare_vars (c->temps, body, false);
178 record_vars (c->temps);
181 htab_delete (c->temp_htab);
185 gimple_push_bind_expr (tree bind)
187 TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr;
188 gimplify_ctxp->current_bind_expr = bind;
192 gimple_pop_bind_expr (void)
194 gimplify_ctxp->current_bind_expr
195 = TREE_CHAIN (gimplify_ctxp->current_bind_expr);
199 gimple_current_bind_expr (void)
201 return gimplify_ctxp->current_bind_expr;
204 /* Returns true iff there is a COND_EXPR between us and the innermost
205 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
208 gimple_conditional_context (void)
210 return gimplify_ctxp->conditions > 0;
213 /* Note that we've entered a COND_EXPR. */
216 gimple_push_condition (void)
218 #ifdef ENABLE_CHECKING
219 if (gimplify_ctxp->conditions == 0)
220 gcc_assert (!gimplify_ctxp->conditional_cleanups);
222 ++(gimplify_ctxp->conditions);
225 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
226 now, add any conditional cleanups we've seen to the prequeue. */
229 gimple_pop_condition (tree *pre_p)
231 int conds = --(gimplify_ctxp->conditions);
233 gcc_assert (conds >= 0);
236 append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p);
237 gimplify_ctxp->conditional_cleanups = NULL_TREE;
241 /* A stable comparison routine for use with splay trees and DECLs. */
244 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
249 return DECL_UID (a) - DECL_UID (b);
252 /* Create a new omp construct that deals with variable remapping. */
254 static struct gimplify_omp_ctx *
255 new_omp_context (enum omp_region_type region_type)
257 struct gimplify_omp_ctx *c;
259 c = XCNEW (struct gimplify_omp_ctx);
260 c->outer_context = gimplify_omp_ctxp;
261 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
262 c->privatized_types = pointer_set_create ();
263 c->location = input_location;
264 c->region_type = region_type;
265 if (region_type != ORT_TASK)
266 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
268 c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
273 /* Destroy an omp construct that deals with variable remapping. */
276 delete_omp_context (struct gimplify_omp_ctx *c)
278 splay_tree_delete (c->variables);
279 pointer_set_destroy (c->privatized_types);
283 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
284 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
286 /* A subroutine of append_to_statement_list{,_force}. T is not NULL. */
289 append_to_statement_list_1 (tree t, tree *list_p)
292 tree_stmt_iterator i;
296 if (t && TREE_CODE (t) == STATEMENT_LIST)
301 *list_p = list = alloc_stmt_list ();
305 tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
308 /* Add T to the end of the list container pointed to by LIST_P.
309 If T is an expression with no effects, it is ignored. */
312 append_to_statement_list (tree t, tree *list_p)
314 if (t && TREE_SIDE_EFFECTS (t))
315 append_to_statement_list_1 (t, list_p);
318 /* Similar, but the statement is always added, regardless of side effects. */
321 append_to_statement_list_force (tree t, tree *list_p)
324 append_to_statement_list_1 (t, list_p);
327 /* Both gimplify the statement T and append it to LIST_P. */
330 gimplify_and_add (tree t, tree *list_p)
333 append_to_statement_list (t, list_p);
336 /* Strip off a legitimate source ending from the input string NAME of
337 length LEN. Rather than having to know the names used by all of
338 our front ends, we strip off an ending of a period followed by
339 up to five characters. (Java uses ".class".) */
342 remove_suffix (char *name, int len)
346 for (i = 2; i < 8 && len > i; i++)
348 if (name[len - i] == '.')
350 name[len - i] = '\0';
356 /* Create a nameless artificial label and put it in the current function
357 context. Returns the newly created label. */
360 create_artificial_label (void)
362 tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node);
364 DECL_ARTIFICIAL (lab) = 1;
365 DECL_IGNORED_P (lab) = 1;
366 DECL_CONTEXT (lab) = current_function_decl;
370 /* Subroutine for find_single_pointer_decl. */
373 find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
376 tree *pdecl = (tree *) data;
378 /* We are only looking for pointers at the same level as the
379 original tree; we must not look through any indirections.
380 Returning anything other than NULL_TREE will cause the caller to
382 if (REFERENCE_CLASS_P (*tp))
385 if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp)))
389 /* We already found a pointer decl; return anything other
390 than NULL_TREE to unwind from walk_tree signalling that
391 we have a duplicate. */
400 /* Find the single DECL of pointer type in the tree T, used directly
401 rather than via an indirection, and return it. If there are zero
402 or more than one such DECLs, return NULL. */
405 find_single_pointer_decl (tree t)
407 tree decl = NULL_TREE;
409 if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL))
411 /* find_single_pointer_decl_1 returns a nonzero value, causing
412 walk_tree to return a nonzero value, to indicate that it
413 found more than one pointer DECL or that it found an
421 /* Create a new temporary name with PREFIX. Returns an identifier. */
423 static GTY(()) unsigned int tmp_var_id_num;
426 create_tmp_var_name (const char *prefix)
432 char *preftmp = ASTRDUP (prefix);
434 remove_suffix (preftmp, strlen (preftmp));
438 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
439 return get_identifier (tmp_name);
443 /* Create a new temporary variable declaration of type TYPE.
444 Does NOT push it into the current binding. */
447 create_tmp_var_raw (tree type, const char *prefix)
452 /* Make the type of the variable writable. */
453 new_type = build_type_variant (type, 0, 0);
454 TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
456 tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
459 /* The variable was declared by the compiler. */
460 DECL_ARTIFICIAL (tmp_var) = 1;
461 /* And we don't want debug info for it. */
462 DECL_IGNORED_P (tmp_var) = 1;
464 /* Make the variable writable. */
465 TREE_READONLY (tmp_var) = 0;
467 DECL_EXTERNAL (tmp_var) = 0;
468 TREE_STATIC (tmp_var) = 0;
469 TREE_USED (tmp_var) = 1;
474 /* Create a new temporary variable declaration of type TYPE. DOES push the
475 variable into the current binding. Further, assume that this is called
476 only from gimplification or optimization, at which point the creation of
477 certain types are bugs. */
480 create_tmp_var (tree type, const char *prefix)
484 /* We don't allow types that are addressable (meaning we can't make copies),
485 or incomplete. We also used to reject every variable size objects here,
486 but now support those for which a constant upper bound can be obtained.
487 The processing for variable sizes is performed in gimple_add_tmp_var,
488 point at which it really matters and possibly reached via paths not going
489 through this function, e.g. after direct calls to create_tmp_var_raw. */
490 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
492 tmp_var = create_tmp_var_raw (type, prefix);
493 gimple_add_tmp_var (tmp_var);
497 /* Given a tree, try to return a useful variable name that we can use
498 to prefix a temporary that is being assigned the value of the tree.
499 I.E. given <temp> = &A, return A. */
502 get_name (const_tree t)
504 const_tree stripped_decl;
507 STRIP_NOPS (stripped_decl);
508 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
509 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
512 switch (TREE_CODE (stripped_decl))
515 return get_name (TREE_OPERAND (stripped_decl, 0));
522 /* Create a temporary with a name derived from VAL. Subroutine of
523 lookup_tmp_var; nobody else should call this function. */
526 create_tmp_from_val (tree val)
528 return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val));
531 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
532 an existing expression temporary. */
535 lookup_tmp_var (tree val, bool is_formal)
539 /* If not optimizing, never really reuse a temporary. local-alloc
540 won't allocate any variable that is used in more than one basic
541 block, which means it will go into memory, causing much extra
542 work in reload and final and poorer code generation, outweighing
543 the extra memory allocation here. */
544 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
545 ret = create_tmp_from_val (val);
552 if (gimplify_ctxp->temp_htab == NULL)
553 gimplify_ctxp->temp_htab
554 = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
555 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
558 elt_p = XNEW (elt_t);
560 elt_p->temp = ret = create_tmp_from_val (val);
561 *slot = (void *) elt_p;
565 elt_p = (elt_t *) *slot;
571 DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1;
576 /* Returns a formal temporary variable initialized with VAL. PRE_P is as
577 in gimplify_expr. Only use this function if:
579 1) The value of the unfactored expression represented by VAL will not
580 change between the initialization and use of the temporary, and
581 2) The temporary will not be otherwise modified.
583 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
584 and #2 means it is inappropriate for && temps.
586 For other cases, use get_initialized_tmp_var instead. */
589 internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal)
593 gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_rhs, fb_rvalue);
595 t = lookup_tmp_var (val, is_formal);
599 tree u = find_single_pointer_decl (val);
601 if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u))
602 u = DECL_GET_RESTRICT_BASE (u);
603 if (u && TYPE_RESTRICT (TREE_TYPE (u)))
605 if (DECL_BASED_ON_RESTRICT_P (t))
606 gcc_assert (u == DECL_GET_RESTRICT_BASE (t));
609 DECL_BASED_ON_RESTRICT_P (t) = 1;
610 SET_DECL_RESTRICT_BASE (t, u);
615 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
616 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
617 DECL_GIMPLE_REG_P (t) = 1;
619 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
621 if (EXPR_HAS_LOCATION (val))
622 SET_EXPR_LOCUS (mod, EXPR_LOCUS (val));
624 SET_EXPR_LOCATION (mod, input_location);
626 /* gimplify_modify_expr might want to reduce this further. */
627 gimplify_and_add (mod, pre_p);
629 /* If we're gimplifying into ssa, gimplify_modify_expr will have
630 given our temporary an ssa name. Find and return it. */
631 if (gimplify_ctxp->into_ssa)
632 t = TREE_OPERAND (mod, 0);
637 /* Returns a formal temporary variable initialized with VAL. PRE_P
638 points to a statement list where side-effects needed to compute VAL
642 get_formal_tmp_var (tree val, tree *pre_p)
644 return internal_get_tmp_var (val, pre_p, NULL, true);
647 /* Returns a temporary variable initialized with VAL. PRE_P and POST_P
648 are as in gimplify_expr. */
651 get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p)
653 return internal_get_tmp_var (val, pre_p, post_p, false);
656 /* Declares all the variables in VARS in SCOPE. If DEBUG_INFO is
657 true, generate debug info for them; otherwise don't. */
660 declare_vars (tree vars, tree scope, bool debug_info)
667 /* C99 mode puts the default 'return 0;' for main outside the outer
668 braces. So drill down until we find an actual scope. */
669 while (TREE_CODE (scope) == COMPOUND_EXPR)
670 scope = TREE_OPERAND (scope, 0);
672 gcc_assert (TREE_CODE (scope) == BIND_EXPR);
674 temps = nreverse (last);
676 block = BIND_EXPR_BLOCK (scope);
677 if (!block || !debug_info)
679 TREE_CHAIN (last) = BIND_EXPR_VARS (scope);
680 BIND_EXPR_VARS (scope) = temps;
684 /* We need to attach the nodes both to the BIND_EXPR and to its
685 associated BLOCK for debugging purposes. The key point here
686 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
687 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
688 if (BLOCK_VARS (block))
689 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
692 BIND_EXPR_VARS (scope) = chainon (BIND_EXPR_VARS (scope), temps);
693 BLOCK_VARS (block) = temps;
699 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
700 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
701 no such upper bound can be obtained. */
704 force_constant_size (tree var)
706 /* The only attempt we make is by querying the maximum size of objects
707 of the variable's type. */
709 HOST_WIDE_INT max_size;
711 gcc_assert (TREE_CODE (var) == VAR_DECL);
713 max_size = max_int_size_in_bytes (TREE_TYPE (var));
715 gcc_assert (max_size >= 0);
718 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
720 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
724 gimple_add_tmp_var (tree tmp)
726 gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
728 /* Later processing assumes that the object size is constant, which might
729 not be true at this point. Force the use of a constant upper bound in
731 if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
732 force_constant_size (tmp);
734 DECL_CONTEXT (tmp) = current_function_decl;
735 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
739 TREE_CHAIN (tmp) = gimplify_ctxp->temps;
740 gimplify_ctxp->temps = tmp;
742 /* Mark temporaries local within the nearest enclosing parallel. */
743 if (gimplify_omp_ctxp)
745 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
746 while (ctx && ctx->region_type == ORT_WORKSHARE)
747 ctx = ctx->outer_context;
749 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
755 declare_vars (tmp, DECL_SAVED_TREE (current_function_decl), false);
758 /* Determines whether to assign a locus to the statement STMT. */
761 should_carry_locus_p (const_tree stmt)
763 /* Don't emit a line note for a label. We particularly don't want to
764 emit one for the break label, since it doesn't actually correspond
765 to the beginning of the loop/switch. */
766 if (TREE_CODE (stmt) == LABEL_EXPR)
769 /* Do not annotate empty statements, since it confuses gcov. */
770 if (!TREE_SIDE_EFFECTS (stmt))
777 annotate_one_with_locus (tree t, location_t locus)
779 if (CAN_HAVE_LOCATION_P (t)
780 && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t))
781 SET_EXPR_LOCATION (t, locus);
785 annotate_all_with_locus (tree *stmt_p, location_t locus)
787 tree_stmt_iterator i;
792 for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i))
794 tree t = tsi_stmt (i);
796 /* Assuming we've already been gimplified, we shouldn't
797 see nested chaining constructs anymore. */
798 gcc_assert (TREE_CODE (t) != STATEMENT_LIST
799 && TREE_CODE (t) != COMPOUND_EXPR);
801 annotate_one_with_locus (t, locus);
805 /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
806 These nodes model computations that should only be done once. If we
807 were to unshare something like SAVE_EXPR(i++), the gimplification
808 process would create wrong code. */
811 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
813 enum tree_code code = TREE_CODE (*tp);
814 /* Don't unshare types, decls, constants and SAVE_EXPR nodes. */
815 if (TREE_CODE_CLASS (code) == tcc_type
816 || TREE_CODE_CLASS (code) == tcc_declaration
817 || TREE_CODE_CLASS (code) == tcc_constant
818 || code == SAVE_EXPR || code == TARGET_EXPR
819 /* We can't do anything sensible with a BLOCK used as an expression,
820 but we also can't just die when we see it because of non-expression
821 uses. So just avert our eyes and cross our fingers. Silly Java. */
826 gcc_assert (code != BIND_EXPR);
827 copy_tree_r (tp, walk_subtrees, data);
833 /* Callback for walk_tree to unshare most of the shared trees rooted at
834 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
835 then *TP is deep copied by calling copy_tree_r.
837 This unshares the same trees as copy_tree_r with the exception of
838 SAVE_EXPR nodes. These nodes model computations that should only be
839 done once. If we were to unshare something like SAVE_EXPR(i++), the
840 gimplification process would create wrong code. */
843 copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
844 void *data ATTRIBUTE_UNUSED)
847 enum tree_code code = TREE_CODE (t);
849 /* Skip types, decls, and constants. But we do want to look at their
850 types and the bounds of types. Mark them as visited so we properly
851 unmark their subtrees on the unmark pass. If we've already seen them,
852 don't look down further. */
853 if (TREE_CODE_CLASS (code) == tcc_type
854 || TREE_CODE_CLASS (code) == tcc_declaration
855 || TREE_CODE_CLASS (code) == tcc_constant)
857 if (TREE_VISITED (t))
860 TREE_VISITED (t) = 1;
863 /* If this node has been visited already, unshare it and don't look
865 else if (TREE_VISITED (t))
867 walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
871 /* Otherwise, mark the tree as visited and keep looking. */
873 TREE_VISITED (t) = 1;
879 unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
880 void *data ATTRIBUTE_UNUSED)
882 if (TREE_VISITED (*tp))
883 TREE_VISITED (*tp) = 0;
890 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
891 bodies of any nested functions if we are unsharing the entire body of
895 unshare_body (tree *body_p, tree fndecl)
897 struct cgraph_node *cgn = cgraph_node (fndecl);
899 walk_tree (body_p, copy_if_shared_r, NULL, NULL);
900 if (body_p == &DECL_SAVED_TREE (fndecl))
901 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
902 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
905 /* Likewise, but mark all trees as not visited. */
908 unvisit_body (tree *body_p, tree fndecl)
910 struct cgraph_node *cgn = cgraph_node (fndecl);
912 walk_tree (body_p, unmark_visited_r, NULL, NULL);
913 if (body_p == &DECL_SAVED_TREE (fndecl))
914 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
915 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
918 /* Unshare T and all the trees reached from T via TREE_CHAIN. */
921 unshare_all_trees (tree t)
923 walk_tree (&t, copy_if_shared_r, NULL, NULL);
924 walk_tree (&t, unmark_visited_r, NULL, NULL);
927 /* Unconditionally make an unshared copy of EXPR. This is used when using
928 stored expressions which span multiple functions, such as BINFO_VTABLE,
929 as the normal unsharing process can't tell that they're shared. */
932 unshare_expr (tree expr)
934 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
938 /* A terser interface for building a representation of an exception
942 gimple_build_eh_filter (tree body, tree allowed, tree failure)
946 /* FIXME should the allowed types go in TREE_TYPE? */
947 t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
948 append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
950 t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
951 append_to_statement_list (body, &TREE_OPERAND (t, 0));
957 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
958 contain statements and have a value. Assign its value to a temporary
959 and give it void_type_node. Returns the temporary, or NULL_TREE if
960 WRAPPER was already void. */
963 voidify_wrapper_expr (tree wrapper, tree temp)
965 tree type = TREE_TYPE (wrapper);
966 if (type && !VOID_TYPE_P (type))
970 /* Set p to point to the body of the wrapper. Loop until we find
971 something that isn't a wrapper. */
972 for (p = &wrapper; p && *p; )
974 switch (TREE_CODE (*p))
977 TREE_SIDE_EFFECTS (*p) = 1;
978 TREE_TYPE (*p) = void_type_node;
979 /* For a BIND_EXPR, the body is operand 1. */
980 p = &BIND_EXPR_BODY (*p);
983 case CLEANUP_POINT_EXPR:
984 case TRY_FINALLY_EXPR:
986 TREE_SIDE_EFFECTS (*p) = 1;
987 TREE_TYPE (*p) = void_type_node;
988 p = &TREE_OPERAND (*p, 0);
993 tree_stmt_iterator i = tsi_last (*p);
994 TREE_SIDE_EFFECTS (*p) = 1;
995 TREE_TYPE (*p) = void_type_node;
996 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1001 /* Advance to the last statement. Set all container types to void. */
1002 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1004 TREE_SIDE_EFFECTS (*p) = 1;
1005 TREE_TYPE (*p) = void_type_node;
1015 if (p == NULL || IS_EMPTY_STMT (*p))
1019 /* The wrapper is on the RHS of an assignment that we're pushing
1021 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1022 || TREE_CODE (temp) == GIMPLE_MODIFY_STMT
1023 || TREE_CODE (temp) == MODIFY_EXPR);
1024 GENERIC_TREE_OPERAND (temp, 1) = *p;
1029 temp = create_tmp_var (type, "retval");
1030 *p = build2 (INIT_EXPR, type, temp, *p);
1039 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1040 a temporary through which they communicate. */
1043 build_stack_save_restore (tree *save, tree *restore)
1045 tree save_call, tmp_var;
1048 build_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 0);
1049 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1051 *save = build_gimple_modify_stmt (tmp_var, save_call);
1053 build_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
1057 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1059 static enum gimplify_status
1060 gimplify_bind_expr (tree *expr_p, tree *pre_p)
1062 tree bind_expr = *expr_p;
1063 bool old_save_stack = gimplify_ctxp->save_stack;
1066 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1068 /* Mark variables seen in this bind expr. */
1069 for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
1071 if (TREE_CODE (t) == VAR_DECL)
1073 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1075 /* Mark variable as local. */
1076 if (ctx && !is_global_var (t)
1077 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1078 || splay_tree_lookup (ctx->variables,
1079 (splay_tree_key) t) == NULL))
1080 omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1082 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1085 /* Preliminarily mark non-addressed complex variables as eligible
1086 for promotion to gimple registers. We'll transform their uses
1088 if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1089 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1090 && !TREE_THIS_VOLATILE (t)
1091 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1092 && !needs_to_live_in_memory (t))
1093 DECL_GIMPLE_REG_P (t) = 1;
1096 gimple_push_bind_expr (bind_expr);
1097 gimplify_ctxp->save_stack = false;
1099 gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr));
1101 if (gimplify_ctxp->save_stack)
1103 tree stack_save, stack_restore;
1105 /* Save stack on entry and restore it on exit. Add a try_finally
1106 block to achieve this. Note that mudflap depends on the
1107 format of the emitted code: see mx_register_decls(). */
1108 build_stack_save_restore (&stack_save, &stack_restore);
1110 t = build2 (TRY_FINALLY_EXPR, void_type_node,
1111 BIND_EXPR_BODY (bind_expr), NULL_TREE);
1112 append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1));
1114 BIND_EXPR_BODY (bind_expr) = NULL_TREE;
1115 append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr));
1116 append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr));
1119 gimplify_ctxp->save_stack = old_save_stack;
1120 gimple_pop_bind_expr ();
1125 append_to_statement_list (bind_expr, pre_p);
1132 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1133 GIMPLE value, it is assigned to a new temporary and the statement is
1134 re-written to return the temporary.
1136 PRE_P points to the list where side effects that must happen before
1137 STMT should be stored. */
1139 static enum gimplify_status
1140 gimplify_return_expr (tree stmt, tree *pre_p)
1142 tree ret_expr = TREE_OPERAND (stmt, 0);
1143 tree result_decl, result;
1145 if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL
1146 || ret_expr == error_mark_node)
1149 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1150 result_decl = NULL_TREE;
1153 result_decl = GENERIC_TREE_OPERAND (ret_expr, 0);
1154 if (TREE_CODE (result_decl) == INDIRECT_REF)
1155 /* See through a return by reference. */
1156 result_decl = TREE_OPERAND (result_decl, 0);
1158 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1159 || TREE_CODE (ret_expr) == GIMPLE_MODIFY_STMT
1160 || TREE_CODE (ret_expr) == INIT_EXPR)
1161 && TREE_CODE (result_decl) == RESULT_DECL);
1164 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1165 Recall that aggregate_value_p is FALSE for any aggregate type that is
1166 returned in registers. If we're returning values in registers, then
1167 we don't want to extend the lifetime of the RESULT_DECL, particularly
1168 across another call. In addition, for those aggregates for which
1169 hard_function_value generates a PARALLEL, we'll die during normal
1170 expansion of structure assignments; there's special code in expand_return
1171 to handle this case that does not exist in expand_expr. */
1173 || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1174 result = result_decl;
1175 else if (gimplify_ctxp->return_temp)
1176 result = gimplify_ctxp->return_temp;
1179 result = create_tmp_var (TREE_TYPE (result_decl), NULL);
1180 if (TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1181 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1182 DECL_GIMPLE_REG_P (result) = 1;
1184 /* ??? With complex control flow (usually involving abnormal edges),
1185 we can wind up warning about an uninitialized value for this. Due
1186 to how this variable is constructed and initialized, this is never
1187 true. Give up and never warn. */
1188 TREE_NO_WARNING (result) = 1;
1190 gimplify_ctxp->return_temp = result;
1193 /* Smash the lhs of the GIMPLE_MODIFY_STMT to the temporary we plan to use.
1194 Then gimplify the whole thing. */
1195 if (result != result_decl)
1196 GENERIC_TREE_OPERAND (ret_expr, 0) = result;
1198 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1200 /* If we didn't use a temporary, then the result is just the result_decl.
1201 Otherwise we need a simple copy. This should already be gimple. */
1202 if (result == result_decl)
1205 ret_expr = build_gimple_modify_stmt (result_decl, result);
1206 TREE_OPERAND (stmt, 0) = ret_expr;
1212 gimplify_vla_decl (tree decl, tree *stmt_p)
1214 /* This is a variable-sized decl. Simplify its size and mark it
1215 for deferred expansion. Note that mudflap depends on the format
1216 of the emitted code: see mx_register_decls(). */
1217 tree t, addr, ptr_type;
1219 gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p);
1220 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p);
1222 /* All occurrences of this decl in final gimplified code will be
1223 replaced by indirection. Setting DECL_VALUE_EXPR does two
1224 things: First, it lets the rest of the gimplifier know what
1225 replacement to use. Second, it lets the debug info know
1226 where to find the value. */
1227 ptr_type = build_pointer_type (TREE_TYPE (decl));
1228 addr = create_tmp_var (ptr_type, get_name (decl));
1229 DECL_IGNORED_P (addr) = 0;
1230 t = build_fold_indirect_ref (addr);
1231 SET_DECL_VALUE_EXPR (decl, t);
1232 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1234 t = built_in_decls[BUILT_IN_ALLOCA];
1235 t = build_call_expr (t, 1, DECL_SIZE_UNIT (decl));
1236 t = fold_convert (ptr_type, t);
1237 t = build_gimple_modify_stmt (addr, t);
1239 gimplify_and_add (t, stmt_p);
1241 /* Indicate that we need to restore the stack level when the
1242 enclosing BIND_EXPR is exited. */
1243 gimplify_ctxp->save_stack = true;
1246 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1247 and initialization explicit. */
1249 static enum gimplify_status
1250 gimplify_decl_expr (tree *stmt_p)
1252 tree stmt = *stmt_p;
1253 tree decl = DECL_EXPR_DECL (stmt);
1255 *stmt_p = NULL_TREE;
1257 if (TREE_TYPE (decl) == error_mark_node)
1260 if ((TREE_CODE (decl) == TYPE_DECL
1261 || TREE_CODE (decl) == VAR_DECL)
1262 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1263 gimplify_type_sizes (TREE_TYPE (decl), stmt_p);
1265 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1267 tree init = DECL_INITIAL (decl);
1269 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
1270 gimplify_vla_decl (decl, stmt_p);
1272 if (init && init != error_mark_node)
1274 if (!TREE_STATIC (decl))
1276 DECL_INITIAL (decl) = NULL_TREE;
1277 init = build2 (INIT_EXPR, void_type_node, decl, init);
1278 gimplify_and_add (init, stmt_p);
1281 /* We must still examine initializers for static variables
1282 as they may contain a label address. */
1283 walk_tree (&init, force_labels_r, NULL, NULL);
1286 /* Some front ends do not explicitly declare all anonymous
1287 artificial variables. We compensate here by declaring the
1288 variables, though it would be better if the front ends would
1289 explicitly declare them. */
1290 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1291 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1292 gimple_add_tmp_var (decl);
1298 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1299 and replacing the LOOP_EXPR with goto, but if the loop contains an
1300 EXIT_EXPR, we need to append a label for it to jump to. */
1302 static enum gimplify_status
1303 gimplify_loop_expr (tree *expr_p, tree *pre_p)
1305 tree saved_label = gimplify_ctxp->exit_label;
1306 tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
1307 tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label));
1309 append_to_statement_list (start_label, pre_p);
1311 gimplify_ctxp->exit_label = NULL_TREE;
1313 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1315 if (gimplify_ctxp->exit_label)
1317 append_to_statement_list (jump_stmt, pre_p);
1318 *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label);
1321 *expr_p = jump_stmt;
1323 gimplify_ctxp->exit_label = saved_label;
1328 /* Compare two case labels. Because the front end should already have
1329 made sure that case ranges do not overlap, it is enough to only compare
1330 the CASE_LOW values of each case label. */
1333 compare_case_labels (const void *p1, const void *p2)
1335 const_tree const case1 = *(const_tree const*)p1;
1336 const_tree const case2 = *(const_tree const*)p2;
1338 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1341 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1344 sort_case_labels (tree label_vec)
1346 size_t len = TREE_VEC_LENGTH (label_vec);
1347 tree default_case = TREE_VEC_ELT (label_vec, len - 1);
1349 if (CASE_LOW (default_case))
1353 /* The last label in the vector should be the default case
1355 for (i = 0; i < len; ++i)
1357 tree t = TREE_VEC_ELT (label_vec, i);
1361 TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1);
1362 TREE_VEC_ELT (label_vec, len - 1) = default_case;
1368 qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree),
1369 compare_case_labels);
1372 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1375 static enum gimplify_status
1376 gimplify_switch_expr (tree *expr_p, tree *pre_p)
1378 tree switch_expr = *expr_p;
1379 enum gimplify_status ret;
1381 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL,
1382 is_gimple_val, fb_rvalue);
1384 if (SWITCH_BODY (switch_expr))
1386 VEC(tree,heap) *labels, *saved_labels;
1387 tree label_vec, default_case = NULL_TREE;
1390 /* If someone can be bothered to fill in the labels, they can
1391 be bothered to null out the body too. */
1392 gcc_assert (!SWITCH_LABELS (switch_expr));
1394 saved_labels = gimplify_ctxp->case_labels;
1395 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1397 gimplify_to_stmt_list (&SWITCH_BODY (switch_expr));
1399 labels = gimplify_ctxp->case_labels;
1400 gimplify_ctxp->case_labels = saved_labels;
1403 while (i < VEC_length (tree, labels))
1405 tree elt = VEC_index (tree, labels, i);
1406 tree low = CASE_LOW (elt);
1407 bool remove_element = FALSE;
1411 /* Discard empty ranges. */
1412 tree high = CASE_HIGH (elt);
1413 if (high && tree_int_cst_lt (high, low))
1414 remove_element = TRUE;
1418 /* The default case must be the last label in the list. */
1419 gcc_assert (!default_case);
1421 remove_element = TRUE;
1425 VEC_ordered_remove (tree, labels, i);
1431 label_vec = make_tree_vec (len + 1);
1432 SWITCH_LABELS (*expr_p) = label_vec;
1433 append_to_statement_list (switch_expr, pre_p);
1437 /* If the switch has no default label, add one, so that we jump
1438 around the switch body. */
1439 default_case = build3 (CASE_LABEL_EXPR, void_type_node, NULL_TREE,
1440 NULL_TREE, create_artificial_label ());
1441 append_to_statement_list (SWITCH_BODY (switch_expr), pre_p);
1442 *expr_p = build1 (LABEL_EXPR, void_type_node,
1443 CASE_LABEL (default_case));
1446 *expr_p = SWITCH_BODY (switch_expr);
1448 for (i = 0; i < len; ++i)
1449 TREE_VEC_ELT (label_vec, i) = VEC_index (tree, labels, i);
1450 TREE_VEC_ELT (label_vec, len) = default_case;
1452 VEC_free (tree, heap, labels);
1454 sort_case_labels (label_vec);
1456 SWITCH_BODY (switch_expr) = NULL;
1459 gcc_assert (SWITCH_LABELS (switch_expr));
1464 static enum gimplify_status
1465 gimplify_case_label_expr (tree *expr_p)
1467 tree expr = *expr_p;
1468 struct gimplify_ctx *ctxp;
1470 /* Invalid OpenMP programs can play Duff's Device type games with
1471 #pragma omp parallel. At least in the C front end, we don't
1472 detect such invalid branches until after gimplification. */
1473 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1474 if (ctxp->case_labels)
1477 VEC_safe_push (tree, heap, ctxp->case_labels, expr);
1478 *expr_p = build1 (LABEL_EXPR, void_type_node, CASE_LABEL (expr));
1482 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1486 build_and_jump (tree *label_p)
1488 if (label_p == NULL)
1489 /* If there's nowhere to jump, just fall through. */
1492 if (*label_p == NULL_TREE)
1494 tree label = create_artificial_label ();
1498 return build1 (GOTO_EXPR, void_type_node, *label_p);
1501 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1502 This also involves building a label to jump to and communicating it to
1503 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1505 static enum gimplify_status
1506 gimplify_exit_expr (tree *expr_p)
1508 tree cond = TREE_OPERAND (*expr_p, 0);
1511 expr = build_and_jump (&gimplify_ctxp->exit_label);
1512 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1518 /* A helper function to be called via walk_tree. Mark all labels under *TP
1519 as being forced. To be called for DECL_INITIAL of static variables. */
1522 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1526 if (TREE_CODE (*tp) == LABEL_DECL)
1527 FORCED_LABEL (*tp) = 1;
1532 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1533 different from its canonical type, wrap the whole thing inside a
1534 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1537 The canonical type of a COMPONENT_REF is the type of the field being
1538 referenced--unless the field is a bit-field which can be read directly
1539 in a smaller mode, in which case the canonical type is the
1540 sign-appropriate type corresponding to that mode. */
1543 canonicalize_component_ref (tree *expr_p)
1545 tree expr = *expr_p;
1548 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1550 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1551 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1553 type = TREE_TYPE (TREE_OPERAND (expr, 1));
1555 /* One could argue that all the stuff below is not necessary for
1556 the non-bitfield case and declare it a FE error if type
1557 adjustment would be needed. */
1558 if (TREE_TYPE (expr) != type)
1560 #ifdef ENABLE_TYPES_CHECKING
1561 tree old_type = TREE_TYPE (expr);
1565 /* We need to preserve qualifiers and propagate them from
1567 type_quals = TYPE_QUALS (type)
1568 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1569 if (TYPE_QUALS (type) != type_quals)
1570 type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1572 /* Set the type of the COMPONENT_REF to the underlying type. */
1573 TREE_TYPE (expr) = type;
1575 #ifdef ENABLE_TYPES_CHECKING
1576 /* It is now a FE error, if the conversion from the canonical
1577 type to the original expression type is not useless. */
1578 gcc_assert (useless_type_conversion_p (old_type, type));
1583 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1584 to foo, embed that change in the ADDR_EXPR by converting
1589 where L is the lower bound. For simplicity, only do this for constant
1591 The constraint is that the type of &array[L] is trivially convertible
1595 canonicalize_addr_expr (tree *expr_p)
1597 tree expr = *expr_p;
1598 tree addr_expr = TREE_OPERAND (expr, 0);
1599 tree datype, ddatype, pddatype;
1601 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1602 if (!POINTER_TYPE_P (TREE_TYPE (expr))
1603 || TREE_CODE (addr_expr) != ADDR_EXPR)
1606 /* The addr_expr type should be a pointer to an array. */
1607 datype = TREE_TYPE (TREE_TYPE (addr_expr));
1608 if (TREE_CODE (datype) != ARRAY_TYPE)
1611 /* The pointer to element type shall be trivially convertible to
1612 the expression pointer type. */
1613 ddatype = TREE_TYPE (datype);
1614 pddatype = build_pointer_type (ddatype);
1615 if (!useless_type_conversion_p (pddatype, ddatype))
1618 /* The lower bound and element sizes must be constant. */
1619 if (!TYPE_SIZE_UNIT (ddatype)
1620 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1621 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1622 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1625 /* All checks succeeded. Build a new node to merge the cast. */
1626 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1627 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1628 NULL_TREE, NULL_TREE);
1629 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1632 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1633 underneath as appropriate. */
1635 static enum gimplify_status
1636 gimplify_conversion (tree *expr_p)
1639 gcc_assert (CONVERT_EXPR_P (*expr_p));
1641 /* Then strip away all but the outermost conversion. */
1642 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1644 /* And remove the outermost conversion if it's useless. */
1645 if (tree_ssa_useless_type_conversion (*expr_p))
1646 *expr_p = TREE_OPERAND (*expr_p, 0);
1648 /* Attempt to avoid NOP_EXPR by producing reference to a subtype.
1649 For example this fold (subclass *)&A into &A->subclass avoiding
1650 a need for statement. */
1651 if (TREE_CODE (*expr_p) == NOP_EXPR
1652 && POINTER_TYPE_P (TREE_TYPE (*expr_p))
1653 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 0)))
1654 && (tem = maybe_fold_offset_to_reference
1655 (TREE_OPERAND (*expr_p, 0),
1656 integer_zero_node, TREE_TYPE (TREE_TYPE (*expr_p)))))
1658 tree ptr_type = build_pointer_type (TREE_TYPE (tem));
1659 if (useless_type_conversion_p (TREE_TYPE (*expr_p), ptr_type))
1660 *expr_p = build_fold_addr_expr_with_type (tem, ptr_type);
1663 /* If we still have a conversion at the toplevel,
1664 then canonicalize some constructs. */
1665 if (CONVERT_EXPR_P (*expr_p))
1667 tree sub = TREE_OPERAND (*expr_p, 0);
1669 /* If a NOP conversion is changing the type of a COMPONENT_REF
1670 expression, then canonicalize its type now in order to expose more
1671 redundant conversions. */
1672 if (TREE_CODE (sub) == COMPONENT_REF)
1673 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1675 /* If a NOP conversion is changing a pointer to array of foo
1676 to a pointer to foo, embed that change in the ADDR_EXPR. */
1677 else if (TREE_CODE (sub) == ADDR_EXPR)
1678 canonicalize_addr_expr (expr_p);
1684 /* Gimplify a VAR_DECL or PARM_DECL. Returns GS_OK if we expanded a
1685 DECL_VALUE_EXPR, and it's worth re-examining things. */
1687 static enum gimplify_status
1688 gimplify_var_or_parm_decl (tree *expr_p)
1690 tree decl = *expr_p;
1692 /* ??? If this is a local variable, and it has not been seen in any
1693 outer BIND_EXPR, then it's probably the result of a duplicate
1694 declaration, for which we've already issued an error. It would
1695 be really nice if the front end wouldn't leak these at all.
1696 Currently the only known culprit is C++ destructors, as seen
1697 in g++.old-deja/g++.jason/binding.C. */
1698 if (TREE_CODE (decl) == VAR_DECL
1699 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1700 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1701 && decl_function_context (decl) == current_function_decl)
1703 gcc_assert (errorcount || sorrycount);
1707 /* When within an OpenMP context, notice uses of variables. */
1708 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1711 /* If the decl is an alias for another expression, substitute it now. */
1712 if (DECL_HAS_VALUE_EXPR_P (decl))
1714 *expr_p = unshare_expr (DECL_VALUE_EXPR (decl));
1722 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1723 node pointed to by EXPR_P.
1726 : min_lval '[' val ']'
1728 | compound_lval '[' val ']'
1729 | compound_lval '.' ID
1731 This is not part of the original SIMPLE definition, which separates
1732 array and member references, but it seems reasonable to handle them
1733 together. Also, this way we don't run into problems with union
1734 aliasing; gcc requires that for accesses through a union to alias, the
1735 union reference must be explicit, which was not always the case when we
1736 were splitting up array and member refs.
1738 PRE_P points to the list where side effects that must happen before
1739 *EXPR_P should be stored.
1741 POST_P points to the list where side effects that must happen after
1742 *EXPR_P should be stored. */
1744 static enum gimplify_status
1745 gimplify_compound_lval (tree *expr_p, tree *pre_p,
1746 tree *post_p, fallback_t fallback)
1749 VEC(tree,heap) *stack;
1750 enum gimplify_status ret = GS_OK, tret;
1753 /* Create a stack of the subexpressions so later we can walk them in
1754 order from inner to outer. */
1755 stack = VEC_alloc (tree, heap, 10);
1757 /* We can handle anything that get_inner_reference can deal with. */
1758 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
1761 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
1762 if (TREE_CODE (*p) == INDIRECT_REF)
1763 *p = fold_indirect_ref (*p);
1765 if (handled_component_p (*p))
1767 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
1768 additional COMPONENT_REFs. */
1769 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
1770 && gimplify_var_or_parm_decl (p) == GS_OK)
1775 VEC_safe_push (tree, heap, stack, *p);
1778 gcc_assert (VEC_length (tree, stack));
1780 /* Now STACK is a stack of pointers to all the refs we've walked through
1781 and P points to the innermost expression.
1783 Java requires that we elaborated nodes in source order. That
1784 means we must gimplify the inner expression followed by each of
1785 the indices, in order. But we can't gimplify the inner
1786 expression until we deal with any variable bounds, sizes, or
1787 positions in order to deal with PLACEHOLDER_EXPRs.
1789 So we do this in three steps. First we deal with the annotations
1790 for any variables in the components, then we gimplify the base,
1791 then we gimplify any indices, from left to right. */
1792 for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
1794 tree t = VEC_index (tree, stack, i);
1796 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1798 /* Gimplify the low bound and element type size and put them into
1799 the ARRAY_REF. If these values are set, they have already been
1801 if (!TREE_OPERAND (t, 2))
1803 tree low = unshare_expr (array_ref_low_bound (t));
1804 if (!is_gimple_min_invariant (low))
1806 TREE_OPERAND (t, 2) = low;
1807 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1808 is_gimple_formal_tmp_reg, fb_rvalue);
1809 ret = MIN (ret, tret);
1813 if (!TREE_OPERAND (t, 3))
1815 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1816 tree elmt_size = unshare_expr (array_ref_element_size (t));
1817 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
1819 /* Divide the element size by the alignment of the element
1821 elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor);
1823 if (!is_gimple_min_invariant (elmt_size))
1825 TREE_OPERAND (t, 3) = elmt_size;
1826 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
1827 is_gimple_formal_tmp_reg, fb_rvalue);
1828 ret = MIN (ret, tret);
1832 else if (TREE_CODE (t) == COMPONENT_REF)
1834 /* Set the field offset into T and gimplify it. */
1835 if (!TREE_OPERAND (t, 2))
1837 tree offset = unshare_expr (component_ref_field_offset (t));
1838 tree field = TREE_OPERAND (t, 1);
1840 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
1842 /* Divide the offset by its alignment. */
1843 offset = size_binop (EXACT_DIV_EXPR, offset, factor);
1845 if (!is_gimple_min_invariant (offset))
1847 TREE_OPERAND (t, 2) = offset;
1848 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1849 is_gimple_formal_tmp_reg, fb_rvalue);
1850 ret = MIN (ret, tret);
1856 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
1857 so as to match the min_lval predicate. Failure to do so may result
1858 in the creation of large aggregate temporaries. */
1859 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
1860 fallback | fb_lvalue);
1861 ret = MIN (ret, tret);
1863 /* And finally, the indices and operands to BIT_FIELD_REF. During this
1864 loop we also remove any useless conversions. */
1865 for (; VEC_length (tree, stack) > 0; )
1867 tree t = VEC_pop (tree, stack);
1869 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1871 /* Gimplify the dimension.
1872 Temporary fix for gcc.c-torture/execute/20040313-1.c.
1873 Gimplify non-constant array indices into a temporary
1875 FIXME - The real fix is to gimplify post-modify
1876 expressions into a minimal gimple lvalue. However, that
1877 exposes bugs in alias analysis. The alias analyzer does
1878 not handle &PTR->FIELD very well. Will fix after the
1879 branch is merged into mainline (dnovillo 2004-05-03). */
1880 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
1882 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1883 is_gimple_formal_tmp_reg, fb_rvalue);
1884 ret = MIN (ret, tret);
1887 else if (TREE_CODE (t) == BIT_FIELD_REF)
1889 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1890 is_gimple_val, fb_rvalue);
1891 ret = MIN (ret, tret);
1892 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1893 is_gimple_val, fb_rvalue);
1894 ret = MIN (ret, tret);
1897 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
1899 /* The innermost expression P may have originally had TREE_SIDE_EFFECTS
1900 set which would have caused all the outer expressions in EXPR_P
1901 leading to P to also have had TREE_SIDE_EFFECTS set. */
1902 recalculate_side_effects (t);
1905 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, fallback);
1906 ret = MIN (ret, tret);
1908 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
1909 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
1911 canonicalize_component_ref (expr_p);
1912 ret = MIN (ret, GS_OK);
1915 VEC_free (tree, heap, stack);
1920 /* Gimplify the self modifying expression pointed to by EXPR_P
1923 PRE_P points to the list where side effects that must happen before
1924 *EXPR_P should be stored.
1926 POST_P points to the list where side effects that must happen after
1927 *EXPR_P should be stored.
1929 WANT_VALUE is nonzero iff we want to use the value of this expression
1930 in another expression. */
1932 static enum gimplify_status
1933 gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p,
1936 enum tree_code code;
1937 tree lhs, lvalue, rhs, t1, post = NULL, *orig_post_p = post_p;
1939 enum tree_code arith_code;
1940 enum gimplify_status ret;
1942 code = TREE_CODE (*expr_p);
1944 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
1945 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
1947 /* Prefix or postfix? */
1948 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1949 /* Faster to treat as prefix if result is not used. */
1950 postfix = want_value;
1954 /* For postfix, make sure the inner expression's post side effects
1955 are executed after side effects from this expression. */
1959 /* Add or subtract? */
1960 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
1961 arith_code = PLUS_EXPR;
1963 arith_code = MINUS_EXPR;
1965 /* Gimplify the LHS into a GIMPLE lvalue. */
1966 lvalue = TREE_OPERAND (*expr_p, 0);
1967 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
1968 if (ret == GS_ERROR)
1971 /* Extract the operands to the arithmetic operation. */
1973 rhs = TREE_OPERAND (*expr_p, 1);
1975 /* For postfix operator, we evaluate the LHS to an rvalue and then use
1976 that as the result value and in the postqueue operation. */
1979 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
1980 if (ret == GS_ERROR)
1984 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
1985 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
1987 rhs = fold_convert (sizetype, rhs);
1988 if (arith_code == MINUS_EXPR)
1989 rhs = fold_build1 (NEGATE_EXPR, TREE_TYPE (rhs), rhs);
1990 arith_code = POINTER_PLUS_EXPR;
1993 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
1994 t1 = build_gimple_modify_stmt (lvalue, t1);
1998 gimplify_and_add (t1, orig_post_p);
1999 append_to_statement_list (post, orig_post_p);
2010 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2013 maybe_with_size_expr (tree *expr_p)
2015 tree expr = *expr_p;
2016 tree type = TREE_TYPE (expr);
2019 /* If we've already wrapped this or the type is error_mark_node, we can't do
2021 if (TREE_CODE (expr) == WITH_SIZE_EXPR
2022 || type == error_mark_node)
2025 /* If the size isn't known or is a constant, we have nothing to do. */
2026 size = TYPE_SIZE_UNIT (type);
2027 if (!size || TREE_CODE (size) == INTEGER_CST)
2030 /* Otherwise, make a WITH_SIZE_EXPR. */
2031 size = unshare_expr (size);
2032 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2033 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2036 /* Subroutine of gimplify_call_expr: Gimplify a single argument. */
2038 static enum gimplify_status
2039 gimplify_arg (tree *expr_p, tree *pre_p)
2041 bool (*test) (tree);
2044 /* In general, we allow lvalues for function arguments to avoid
2045 extra overhead of copying large aggregates out of even larger
2046 aggregates into temporaries only to copy the temporaries to
2047 the argument list. Make optimizers happy by pulling out to
2048 temporaries those types that fit in registers. */
2049 if (is_gimple_reg_type (TREE_TYPE (*expr_p)))
2050 test = is_gimple_val, fb = fb_rvalue;
2052 test = is_gimple_lvalue, fb = fb_either;
2054 /* If this is a variable sized type, we must remember the size. */
2055 maybe_with_size_expr (expr_p);
2057 /* There is a sequence point before a function call. Side effects in
2058 the argument list must occur before the actual call. So, when
2059 gimplifying arguments, force gimplify_expr to use an internal
2060 post queue which is then appended to the end of PRE_P. */
2061 return gimplify_expr (expr_p, pre_p, NULL, test, fb);
2064 /* Gimplify the CALL_EXPR node pointed to by EXPR_P. PRE_P points to the
2065 list where side effects that must happen before *EXPR_P should be stored.
2066 WANT_VALUE is true if the result of the call is desired. */
2068 static enum gimplify_status
2069 gimplify_call_expr (tree *expr_p, tree *pre_p, bool want_value)
2071 tree decl, parms, p;
2072 enum gimplify_status ret;
2075 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2077 /* For reliable diagnostics during inlining, it is necessary that
2078 every call_expr be annotated with file and line. */
2079 if (! EXPR_HAS_LOCATION (*expr_p))
2080 SET_EXPR_LOCATION (*expr_p, input_location);
2082 /* This may be a call to a builtin function.
2084 Builtin function calls may be transformed into different
2085 (and more efficient) builtin function calls under certain
2086 circumstances. Unfortunately, gimplification can muck things
2087 up enough that the builtin expanders are not aware that certain
2088 transformations are still valid.
2090 So we attempt transformation/gimplification of the call before
2091 we gimplify the CALL_EXPR. At this time we do not manage to
2092 transform all calls in the same manner as the expanders do, but
2093 we do transform most of them. */
2094 decl = get_callee_fndecl (*expr_p);
2095 if (decl && DECL_BUILT_IN (decl))
2097 tree new = fold_call_expr (*expr_p, !want_value);
2099 if (new && new != *expr_p)
2101 /* There was a transformation of this call which computes the
2102 same value, but in a more efficient way. Return and try
2108 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2109 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_START)
2111 if (call_expr_nargs (*expr_p) < 2)
2113 error ("too few arguments to function %<va_start%>");
2114 *expr_p = build_empty_stmt ();
2118 if (fold_builtin_next_arg (*expr_p, true))
2120 *expr_p = build_empty_stmt ();
2123 /* Avoid gimplifying the second argument to va_start, which needs
2124 to be the plain PARM_DECL. */
2125 return gimplify_arg (&CALL_EXPR_ARG (*expr_p, 0), pre_p);
2129 /* There is a sequence point before the call, so any side effects in
2130 the calling expression must occur before the actual call. Force
2131 gimplify_expr to use an internal post queue. */
2132 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2133 is_gimple_call_addr, fb_rvalue);
2135 nargs = call_expr_nargs (*expr_p);
2137 /* Get argument types for verification. */
2138 decl = get_callee_fndecl (*expr_p);
2141 parms = TYPE_ARG_TYPES (TREE_TYPE (decl));
2142 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2143 parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2145 /* Verify if the type of the argument matches that of the function
2146 declaration. If we cannot verify this or there is a mismatch,
2147 mark the call expression so it doesn't get inlined later. */
2148 if (decl && DECL_ARGUMENTS (decl))
2150 for (i = 0, p = DECL_ARGUMENTS (decl); i < nargs;
2151 i++, p = TREE_CHAIN (p))
2153 /* We cannot distinguish a varargs function from the case
2154 of excess parameters, still deferring the inlining decision
2155 to the callee is possible. */
2158 if (p == error_mark_node
2159 || CALL_EXPR_ARG (*expr_p, i) == error_mark_node
2160 || !fold_convertible_p (DECL_ARG_TYPE (p),
2161 CALL_EXPR_ARG (*expr_p, i)))
2163 CALL_CANNOT_INLINE_P (*expr_p) = 1;
2170 for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
2172 /* If this is a varargs function defer inlining decision
2176 if (TREE_VALUE (p) == error_mark_node
2177 || CALL_EXPR_ARG (*expr_p, i) == error_mark_node
2178 || TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
2179 || !fold_convertible_p (TREE_VALUE (p),
2180 CALL_EXPR_ARG (*expr_p, i)))
2182 CALL_CANNOT_INLINE_P (*expr_p) = 1;
2190 CALL_CANNOT_INLINE_P (*expr_p) = 1;
2195 /* If the last argument is __builtin_va_arg_pack () and it is not
2196 passed as a named argument, decrease the number of CALL_EXPR
2197 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2200 && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2202 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2203 tree last_arg_fndecl = get_callee_fndecl (last_arg);
2206 && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2207 && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2208 && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2210 tree call = *expr_p;
2213 *expr_p = build_call_array (TREE_TYPE (call), CALL_EXPR_FN (call),
2214 nargs, CALL_EXPR_ARGP (call));
2215 /* Copy all CALL_EXPR flags, locus and block, except
2216 CALL_EXPR_VA_ARG_PACK flag. */
2217 CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2218 CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2219 CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2220 = CALL_EXPR_RETURN_SLOT_OPT (call);
2221 CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2222 CALL_CANNOT_INLINE_P (*expr_p)
2223 = CALL_CANNOT_INLINE_P (call);
2224 TREE_NOTHROW (*expr_p) = TREE_NOTHROW (call);
2225 SET_EXPR_LOCUS (*expr_p, EXPR_LOCUS (call));
2226 TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2227 /* Set CALL_EXPR_VA_ARG_PACK. */
2228 CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2232 /* Finally, gimplify the function arguments. */
2233 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2234 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2235 PUSH_ARGS_REVERSED ? i-- : i++)
2237 enum gimplify_status t;
2239 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p);
2245 /* Try this again in case gimplification exposed something. */
2246 if (ret != GS_ERROR)
2248 tree new = fold_call_expr (*expr_p, !want_value);
2250 if (new && new != *expr_p)
2252 /* There was a transformation of this call which computes the
2253 same value, but in a more efficient way. Return and try
2260 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2261 decl. This allows us to eliminate redundant or useless
2262 calls to "const" functions. */
2263 if (TREE_CODE (*expr_p) == CALL_EXPR)
2265 int flags = call_expr_flags (*expr_p);
2266 if (flags & (ECF_CONST | ECF_PURE)
2267 /* An infinite loop is considered a side effect. */
2268 && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2269 TREE_SIDE_EFFECTS (*expr_p) = 0;
2274 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2275 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2277 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2278 condition is true or false, respectively. If null, we should generate
2279 our own to skip over the evaluation of this specific expression.
2281 This function is the tree equivalent of do_jump.
2283 shortcut_cond_r should only be called by shortcut_cond_expr. */
2286 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p)
2288 tree local_label = NULL_TREE;
2289 tree t, expr = NULL;
2291 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2292 retain the shortcut semantics. Just insert the gotos here;
2293 shortcut_cond_expr will append the real blocks later. */
2294 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2296 /* Turn if (a && b) into
2298 if (a); else goto no;
2299 if (b) goto yes; else goto no;
2302 if (false_label_p == NULL)
2303 false_label_p = &local_label;
2305 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p);
2306 append_to_statement_list (t, &expr);
2308 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2310 append_to_statement_list (t, &expr);
2312 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2314 /* Turn if (a || b) into
2317 if (b) goto yes; else goto no;
2320 if (true_label_p == NULL)
2321 true_label_p = &local_label;
2323 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL);
2324 append_to_statement_list (t, &expr);
2326 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2328 append_to_statement_list (t, &expr);
2330 else if (TREE_CODE (pred) == COND_EXPR)
2332 /* As long as we're messing with gotos, turn if (a ? b : c) into
2334 if (b) goto yes; else goto no;
2336 if (c) goto yes; else goto no; */
2337 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2338 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2340 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2345 expr = build3 (COND_EXPR, void_type_node, pred,
2346 build_and_jump (true_label_p),
2347 build_and_jump (false_label_p));
2352 t = build1 (LABEL_EXPR, void_type_node, local_label);
2353 append_to_statement_list (t, &expr);
2360 shortcut_cond_expr (tree expr)
2362 tree pred = TREE_OPERAND (expr, 0);
2363 tree then_ = TREE_OPERAND (expr, 1);
2364 tree else_ = TREE_OPERAND (expr, 2);
2365 tree true_label, false_label, end_label, t;
2367 tree *false_label_p;
2368 bool emit_end, emit_false, jump_over_else;
2369 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2370 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2372 /* First do simple transformations. */
2375 /* If there is no 'else', turn (a && b) into if (a) if (b). */
2376 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2378 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2379 then_ = shortcut_cond_expr (expr);
2380 then_se = then_ && TREE_SIDE_EFFECTS (then_);
2381 pred = TREE_OPERAND (pred, 0);
2382 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2387 /* If there is no 'then', turn
2390 if (a); else if (b); else d. */
2391 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2393 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2394 else_ = shortcut_cond_expr (expr);
2395 else_se = else_ && TREE_SIDE_EFFECTS (else_);
2396 pred = TREE_OPERAND (pred, 0);
2397 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2401 /* If we're done, great. */
2402 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2403 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2406 /* Otherwise we need to mess with gotos. Change
2409 if (a); else goto no;
2412 and recursively gimplify the condition. */
2414 true_label = false_label = end_label = NULL_TREE;
2416 /* If our arms just jump somewhere, hijack those labels so we don't
2417 generate jumps to jumps. */
2420 && TREE_CODE (then_) == GOTO_EXPR
2421 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2423 true_label = GOTO_DESTINATION (then_);
2429 && TREE_CODE (else_) == GOTO_EXPR
2430 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2432 false_label = GOTO_DESTINATION (else_);
2437 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2439 true_label_p = &true_label;
2441 true_label_p = NULL;
2443 /* The 'else' branch also needs a label if it contains interesting code. */
2444 if (false_label || else_se)
2445 false_label_p = &false_label;
2447 false_label_p = NULL;
2449 /* If there was nothing else in our arms, just forward the label(s). */
2450 if (!then_se && !else_se)
2451 return shortcut_cond_r (pred, true_label_p, false_label_p);
2453 /* If our last subexpression already has a terminal label, reuse it. */
2455 expr = expr_last (else_);
2457 expr = expr_last (then_);
2460 if (expr && TREE_CODE (expr) == LABEL_EXPR)
2461 end_label = LABEL_EXPR_LABEL (expr);
2463 /* If we don't care about jumping to the 'else' branch, jump to the end
2464 if the condition is false. */
2466 false_label_p = &end_label;
2468 /* We only want to emit these labels if we aren't hijacking them. */
2469 emit_end = (end_label == NULL_TREE);
2470 emit_false = (false_label == NULL_TREE);
2472 /* We only emit the jump over the else clause if we have to--if the
2473 then clause may fall through. Otherwise we can wind up with a
2474 useless jump and a useless label at the end of gimplified code,
2475 which will cause us to think that this conditional as a whole
2476 falls through even if it doesn't. If we then inline a function
2477 which ends with such a condition, that can cause us to issue an
2478 inappropriate warning about control reaching the end of a
2479 non-void function. */
2480 jump_over_else = block_may_fallthru (then_);
2482 pred = shortcut_cond_r (pred, true_label_p, false_label_p);
2485 append_to_statement_list (pred, &expr);
2487 append_to_statement_list (then_, &expr);
2492 t = build_and_jump (&end_label);
2493 append_to_statement_list (t, &expr);
2497 t = build1 (LABEL_EXPR, void_type_node, false_label);
2498 append_to_statement_list (t, &expr);
2500 append_to_statement_list (else_, &expr);
2502 if (emit_end && end_label)
2504 t = build1 (LABEL_EXPR, void_type_node, end_label);
2505 append_to_statement_list (t, &expr);
2511 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2514 gimple_boolify (tree expr)
2516 tree type = TREE_TYPE (expr);
2518 if (TREE_CODE (type) == BOOLEAN_TYPE)
2521 switch (TREE_CODE (expr))
2523 case TRUTH_AND_EXPR:
2525 case TRUTH_XOR_EXPR:
2526 case TRUTH_ANDIF_EXPR:
2527 case TRUTH_ORIF_EXPR:
2528 /* Also boolify the arguments of truth exprs. */
2529 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2532 case TRUTH_NOT_EXPR:
2533 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2536 case EQ_EXPR: case NE_EXPR:
2537 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2538 /* These expressions always produce boolean results. */
2539 TREE_TYPE (expr) = boolean_type_node;
2543 /* Other expressions that get here must have boolean values, but
2544 might need to be converted to the appropriate mode. */
2545 return fold_convert (boolean_type_node, expr);
2549 /* Given a conditional expression *EXPR_P without side effects, gimplify
2550 its operands. New statements are inserted to PRE_P. */
2552 static enum gimplify_status
2553 gimplify_pure_cond_expr (tree *expr_p, tree *pre_p)
2555 tree expr = *expr_p, cond;
2556 enum gimplify_status ret, tret;
2557 enum tree_code code;
2559 cond = gimple_boolify (COND_EXPR_COND (expr));
2561 /* We need to handle && and || specially, as their gimplification
2562 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
2563 code = TREE_CODE (cond);
2564 if (code == TRUTH_ANDIF_EXPR)
2565 TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2566 else if (code == TRUTH_ORIF_EXPR)
2567 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2568 ret = gimplify_expr (&cond, pre_p, NULL,
2569 is_gimple_condexpr, fb_rvalue);
2570 COND_EXPR_COND (*expr_p) = cond;
2572 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2573 is_gimple_val, fb_rvalue);
2574 ret = MIN (ret, tret);
2575 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2576 is_gimple_val, fb_rvalue);
2578 return MIN (ret, tret);
2581 /* Returns true if evaluating EXPR could trap.
2582 EXPR is GENERIC, while tree_could_trap_p can be called
2586 generic_expr_could_trap_p (tree expr)
2590 if (!expr || is_gimple_val (expr))
2593 if (!EXPR_P (expr) || tree_could_trap_p (expr))
2596 n = TREE_OPERAND_LENGTH (expr);
2597 for (i = 0; i < n; i++)
2598 if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
2604 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2613 The second form is used when *EXPR_P is of type void.
2615 TARGET is the tree for T1 above.
2617 PRE_P points to the list where side effects that must happen before
2618 *EXPR_P should be stored. */
2620 static enum gimplify_status
2621 gimplify_cond_expr (tree *expr_p, tree *pre_p, fallback_t fallback)
2623 tree expr = *expr_p;
2624 tree tmp, tmp2, type;
2625 enum gimplify_status ret;
2627 type = TREE_TYPE (expr);
2629 /* If this COND_EXPR has a value, copy the values into a temporary within
2631 if (! VOID_TYPE_P (type))
2635 /* If an rvalue is ok or we do not require an lvalue, avoid creating
2636 an addressable temporary. */
2637 if (((fallback & fb_rvalue)
2638 || !(fallback & fb_lvalue))
2639 && !TREE_ADDRESSABLE (type))
2641 if (gimplify_ctxp->allow_rhs_cond_expr
2642 /* If either branch has side effects or could trap, it can't be
2643 evaluated unconditionally. */
2644 && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 1))
2645 && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 1))
2646 && !TREE_SIDE_EFFECTS (TREE_OPERAND (*expr_p, 2))
2647 && !generic_expr_could_trap_p (TREE_OPERAND (*expr_p, 2)))
2648 return gimplify_pure_cond_expr (expr_p, pre_p);
2650 result = tmp2 = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
2655 tree type = build_pointer_type (TREE_TYPE (expr));
2657 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2658 TREE_OPERAND (expr, 1) =
2659 build_fold_addr_expr (TREE_OPERAND (expr, 1));
2661 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2662 TREE_OPERAND (expr, 2) =
2663 build_fold_addr_expr (TREE_OPERAND (expr, 2));
2665 tmp2 = tmp = create_tmp_var (type, "iftmp");
2667 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
2668 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
2670 result = build_fold_indirect_ref (tmp);
2674 /* Build the then clause, 't1 = a;'. But don't build an assignment
2675 if this branch is void; in C++ it can be, if it's a throw. */
2676 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2677 TREE_OPERAND (expr, 1)
2678 = build_gimple_modify_stmt (tmp, TREE_OPERAND (expr, 1));
2680 /* Build the else clause, 't1 = b;'. */
2681 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2682 TREE_OPERAND (expr, 2)
2683 = build_gimple_modify_stmt (tmp2, TREE_OPERAND (expr, 2));
2685 TREE_TYPE (expr) = void_type_node;
2686 recalculate_side_effects (expr);
2688 /* Move the COND_EXPR to the prequeue. */
2689 gimplify_and_add (expr, pre_p);
2695 /* Make sure the condition has BOOLEAN_TYPE. */
2696 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2698 /* Break apart && and || conditions. */
2699 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2700 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2702 expr = shortcut_cond_expr (expr);
2704 if (expr != *expr_p)
2708 /* We can't rely on gimplify_expr to re-gimplify the expanded
2709 form properly, as cleanups might cause the target labels to be
2710 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
2711 set up a conditional context. */
2712 gimple_push_condition ();
2713 gimplify_stmt (expr_p);
2714 gimple_pop_condition (pre_p);
2720 /* Now do the normal gimplification. */
2721 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2722 is_gimple_condexpr, fb_rvalue);
2724 gimple_push_condition ();
2726 gimplify_to_stmt_list (&TREE_OPERAND (expr, 1));
2727 gimplify_to_stmt_list (&TREE_OPERAND (expr, 2));
2728 recalculate_side_effects (expr);
2730 gimple_pop_condition (pre_p);
2732 if (ret == GS_ERROR)
2734 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2736 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2)))
2737 /* Rewrite "if (a); else b" to "if (!a) b" */
2739 TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0));
2740 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2741 is_gimple_condexpr, fb_rvalue);
2743 tmp = TREE_OPERAND (expr, 1);
2744 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2);
2745 TREE_OPERAND (expr, 2) = tmp;
2748 /* Both arms are empty; replace the COND_EXPR with its predicate. */
2749 expr = TREE_OPERAND (expr, 0);
2755 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
2756 a call to __builtin_memcpy. */
2758 static enum gimplify_status
2759 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value)
2761 tree t, to, to_ptr, from, from_ptr;
2763 to = GENERIC_TREE_OPERAND (*expr_p, 0);
2764 from = GENERIC_TREE_OPERAND (*expr_p, 1);
2766 from_ptr = build_fold_addr_expr (from);
2768 to_ptr = build_fold_addr_expr (to);
2769 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
2770 t = build_call_expr (t, 3, to_ptr, from_ptr, size);
2774 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2775 t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2782 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
2783 a call to __builtin_memset. In this case we know that the RHS is
2784 a CONSTRUCTOR with an empty element list. */
2786 static enum gimplify_status
2787 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value)
2789 tree t, from, to, to_ptr;
2791 /* Assert our assumptions, to abort instead of producing wrong code
2792 silently if they are not met. Beware that the RHS CONSTRUCTOR might
2793 not be immediately exposed. */
2794 from = GENERIC_TREE_OPERAND (*expr_p, 1);
2795 if (TREE_CODE (from) == WITH_SIZE_EXPR)
2796 from = TREE_OPERAND (from, 0);
2798 gcc_assert (TREE_CODE (from) == CONSTRUCTOR
2799 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
2802 to = GENERIC_TREE_OPERAND (*expr_p, 0);
2804 to_ptr = build_fold_addr_expr (to);
2805 t = implicit_built_in_decls[BUILT_IN_MEMSET];
2806 t = build_call_expr (t, 3, to_ptr, integer_zero_node, size);
2810 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2811 t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2818 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
2819 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
2820 assignment. Returns non-null if we detect a potential overlap. */
2822 struct gimplify_init_ctor_preeval_data
2824 /* The base decl of the lhs object. May be NULL, in which case we
2825 have to assume the lhs is indirect. */
2828 /* The alias set of the lhs object. */
2829 alias_set_type lhs_alias_set;
2833 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
2835 struct gimplify_init_ctor_preeval_data *data
2836 = (struct gimplify_init_ctor_preeval_data *) xdata;
2839 /* If we find the base object, obviously we have overlap. */
2840 if (data->lhs_base_decl == t)
2843 /* If the constructor component is indirect, determine if we have a
2844 potential overlap with the lhs. The only bits of information we
2845 have to go on at this point are addressability and alias sets. */
2846 if (TREE_CODE (t) == INDIRECT_REF
2847 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
2848 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
2851 /* If the constructor component is a call, determine if it can hide a
2852 potential overlap with the lhs through an INDIRECT_REF like above. */
2853 if (TREE_CODE (t) == CALL_EXPR)
2855 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
2857 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
2858 if (POINTER_TYPE_P (TREE_VALUE (type))
2859 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
2860 && alias_sets_conflict_p (data->lhs_alias_set,
2862 (TREE_TYPE (TREE_VALUE (type)))))
2866 if (IS_TYPE_OR_DECL_P (t))
2871 /* A subroutine of gimplify_init_constructor. Pre-evaluate *EXPR_P,
2872 force values that overlap with the lhs (as described by *DATA)
2873 into temporaries. */
2876 gimplify_init_ctor_preeval (tree *expr_p, tree *pre_p, tree *post_p,
2877 struct gimplify_init_ctor_preeval_data *data)
2879 enum gimplify_status one;
2881 /* If the value is constant, then there's nothing to pre-evaluate. */
2882 if (TREE_CONSTANT (*expr_p))
2884 /* Ensure it does not have side effects, it might contain a reference to
2885 the object we're initializing. */
2886 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
2890 /* If the type has non-trivial constructors, we can't pre-evaluate. */
2891 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
2894 /* Recurse for nested constructors. */
2895 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
2897 unsigned HOST_WIDE_INT ix;
2898 constructor_elt *ce;
2899 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
2901 for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
2902 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
2906 /* If this is a variable sized type, we must remember the size. */
2907 maybe_with_size_expr (expr_p);
2909 /* Gimplify the constructor element to something appropriate for the rhs
2910 of a MODIFY_EXPR. Given that we know the lhs is an aggregate, we know
2911 the gimplifier will consider this a store to memory. Doing this
2912 gimplification now means that we won't have to deal with complicated
2913 language-specific trees, nor trees like SAVE_EXPR that can induce
2914 exponential search behavior. */
2915 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
2916 if (one == GS_ERROR)
2922 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
2923 with the lhs, since "a = { .x=a }" doesn't make sense. This will
2924 always be true for all scalars, since is_gimple_mem_rhs insists on a
2925 temporary variable for them. */
2926 if (DECL_P (*expr_p))
2929 /* If this is of variable size, we have no choice but to assume it doesn't
2930 overlap since we can't make a temporary for it. */
2931 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
2934 /* Otherwise, we must search for overlap ... */
2935 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
2938 /* ... and if found, force the value into a temporary. */
2939 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
2942 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
2943 a RANGE_EXPR in a CONSTRUCTOR for an array.
2947 object[var] = value;
2954 We increment var _after_ the loop exit check because we might otherwise
2955 fail if upper == TYPE_MAX_VALUE (type for upper).
2957 Note that we never have to deal with SAVE_EXPRs here, because this has
2958 already been taken care of for us, in gimplify_init_ctor_preeval(). */
2960 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
2964 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
2965 tree value, tree array_elt_type,
2966 tree *pre_p, bool cleared)
2968 tree loop_entry_label, loop_exit_label;
2969 tree var, var_type, cref, tmp;
2971 loop_entry_label = create_artificial_label ();
2972 loop_exit_label = create_artificial_label ();
2974 /* Create and initialize the index variable. */
2975 var_type = TREE_TYPE (upper);
2976 var = create_tmp_var (var_type, NULL);
2977 append_to_statement_list (build_gimple_modify_stmt (var, lower), pre_p);
2979 /* Add the loop entry label. */
2980 append_to_statement_list (build1 (LABEL_EXPR,
2985 /* Build the reference. */
2986 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
2987 var, NULL_TREE, NULL_TREE);
2989 /* If we are a constructor, just call gimplify_init_ctor_eval to do
2990 the store. Otherwise just assign value to the reference. */
2992 if (TREE_CODE (value) == CONSTRUCTOR)
2993 /* NB we might have to call ourself recursively through
2994 gimplify_init_ctor_eval if the value is a constructor. */
2995 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2998 append_to_statement_list (build_gimple_modify_stmt (cref, value), pre_p);
3000 /* We exit the loop when the index var is equal to the upper bound. */
3001 gimplify_and_add (build3 (COND_EXPR, void_type_node,
3002 build2 (EQ_EXPR, boolean_type_node,
3010 /* Otherwise, increment the index var... */
3011 tmp = build2 (PLUS_EXPR, var_type, var,
3012 fold_convert (var_type, integer_one_node));
3013 append_to_statement_list (build_gimple_modify_stmt (var, tmp), pre_p);
3015 /* ...and jump back to the loop entry. */
3016 append_to_statement_list (build1 (GOTO_EXPR,
3021 /* Add the loop exit label. */
3022 append_to_statement_list (build1 (LABEL_EXPR,
3028 /* Return true if FDECL is accessing a field that is zero sized. */
3031 zero_sized_field_decl (const_tree fdecl)
3033 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3034 && integer_zerop (DECL_SIZE (fdecl)))
3039 /* Return true if TYPE is zero sized. */
3042 zero_sized_type (const_tree type)
3044 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3045 && integer_zerop (TYPE_SIZE (type)))
3050 /* A subroutine of gimplify_init_constructor. Generate individual
3051 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3052 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3053 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3057 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3058 tree *pre_p, bool cleared)
3060 tree array_elt_type = NULL;
3061 unsigned HOST_WIDE_INT ix;
3062 tree purpose, value;
3064 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3065 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3067 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3071 /* NULL values are created above for gimplification errors. */
3075 if (cleared && initializer_zerop (value))
3078 /* ??? Here's to hoping the front end fills in all of the indices,
3079 so we don't have to figure out what's missing ourselves. */
3080 gcc_assert (purpose);
3082 /* Skip zero-sized fields, unless value has side-effects. This can
3083 happen with calls to functions returning a zero-sized type, which
3084 we shouldn't discard. As a number of downstream passes don't
3085 expect sets of zero-sized fields, we rely on the gimplification of
3086 the MODIFY_EXPR we make below to drop the assignment statement. */
3087 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3090 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3092 if (TREE_CODE (purpose) == RANGE_EXPR)
3094 tree lower = TREE_OPERAND (purpose, 0);
3095 tree upper = TREE_OPERAND (purpose, 1);
3097 /* If the lower bound is equal to upper, just treat it as if
3098 upper was the index. */
3099 if (simple_cst_equal (lower, upper))
3103 gimplify_init_ctor_eval_range (object, lower, upper, value,
3104 array_elt_type, pre_p, cleared);
3111 /* Do not use bitsizetype for ARRAY_REF indices. */
3112 if (TYPE_DOMAIN (TREE_TYPE (object)))
3113 purpose = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3115 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3116 purpose, NULL_TREE, NULL_TREE);
3120 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3121 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3122 unshare_expr (object), purpose, NULL_TREE);
3125 if (TREE_CODE (value) == CONSTRUCTOR
3126 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3127 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3131 init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3132 gimplify_and_add (init, pre_p);
3137 /* A subroutine of gimplify_modify_expr. Break out elements of a
3138 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3140 Note that we still need to clear any elements that don't have explicit
3141 initializers, so if not all elements are initialized we keep the
3142 original MODIFY_EXPR, we just remove all of the constructor elements.
3144 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3145 GS_ERROR if we would have to create a temporary when gimplifying
3146 this constructor. Otherwise, return GS_OK.
3148 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3150 static enum gimplify_status
3151 gimplify_init_constructor (tree *expr_p, tree *pre_p,
3152 tree *post_p, bool want_value,
3153 bool notify_temp_creation)
3156 tree ctor = GENERIC_TREE_OPERAND (*expr_p, 1);
3157 tree type = TREE_TYPE (ctor);
3158 enum gimplify_status ret;
3159 VEC(constructor_elt,gc) *elts;
3161 if (TREE_CODE (ctor) != CONSTRUCTOR)
3162 return GS_UNHANDLED;
3164 if (!notify_temp_creation)
3166 ret = gimplify_expr (&GENERIC_TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3167 is_gimple_lvalue, fb_lvalue);
3168 if (ret == GS_ERROR)
3171 object = GENERIC_TREE_OPERAND (*expr_p, 0);
3173 elts = CONSTRUCTOR_ELTS (ctor);
3176 switch (TREE_CODE (type))
3180 case QUAL_UNION_TYPE:
3183 struct gimplify_init_ctor_preeval_data preeval_data;
3184 HOST_WIDE_INT num_type_elements, num_ctor_elements;
3185 HOST_WIDE_INT num_nonzero_elements;
3186 bool cleared, valid_const_initializer;
3188 /* Aggregate types must lower constructors to initialization of
3189 individual elements. The exception is that a CONSTRUCTOR node
3190 with no elements indicates zero-initialization of the whole. */
3191 if (VEC_empty (constructor_elt, elts))
3193 if (notify_temp_creation)
3198 /* Fetch information about the constructor to direct later processing.
3199 We might want to make static versions of it in various cases, and
3200 can only do so if it known to be a valid constant initializer. */
3201 valid_const_initializer
3202 = categorize_ctor_elements (ctor, &num_nonzero_elements,
3203 &num_ctor_elements, &cleared);
3205 /* If a const aggregate variable is being initialized, then it
3206 should never be a lose to promote the variable to be static. */
3207 if (valid_const_initializer
3208 && num_nonzero_elements > 1
3209 && TREE_READONLY (object)
3210 && TREE_CODE (object) == VAR_DECL)
3212 if (notify_temp_creation)
3214 DECL_INITIAL (object) = ctor;
3215 TREE_STATIC (object) = 1;
3216 if (!DECL_NAME (object))
3217 DECL_NAME (object) = create_tmp_var_name ("C");
3218 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
3220 /* ??? C++ doesn't automatically append a .<number> to the
3221 assembler name, and even when it does, it looks a FE private
3222 data structures to figure out what that number should be,
3223 which are not set for this variable. I suppose this is
3224 important for local statics for inline functions, which aren't
3225 "local" in the object file sense. So in order to get a unique
3226 TU-local symbol, we must invoke the lhd version now. */
3227 lhd_set_decl_assembler_name (object);
3229 *expr_p = NULL_TREE;
3233 /* If there are "lots" of initialized elements, even discounting
3234 those that are not address constants (and thus *must* be
3235 computed at runtime), then partition the constructor into
3236 constant and non-constant parts. Block copy the constant
3237 parts in, then generate code for the non-constant parts. */
3238 /* TODO. There's code in cp/typeck.c to do this. */
3240 num_type_elements = count_type_elements (type, true);
3242 /* If count_type_elements could not determine number of type elements
3243 for a constant-sized object, assume clearing is needed.
3244 Don't do this for variable-sized objects, as store_constructor
3245 will ignore the clearing of variable-sized objects. */
3246 if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
3248 /* If there are "lots" of zeros, then block clear the object first. */
3249 else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO
3250 && num_nonzero_elements < num_type_elements/4)
3252 /* ??? This bit ought not be needed. For any element not present
3253 in the initializer, we should simply set them to zero. Except
3254 we'd need to *find* the elements that are not present, and that
3255 requires trickery to avoid quadratic compile-time behavior in
3256 large cases or excessive memory use in small cases. */
3257 else if (num_ctor_elements < num_type_elements)
3260 /* If there are "lots" of initialized elements, and all of them
3261 are valid address constants, then the entire initializer can
3262 be dropped to memory, and then memcpy'd out. Don't do this
3263 for sparse arrays, though, as it's more efficient to follow
3264 the standard CONSTRUCTOR behavior of memset followed by
3265 individual element initialization. */
3266 if (valid_const_initializer && !cleared)
3268 HOST_WIDE_INT size = int_size_in_bytes (type);
3271 /* ??? We can still get unbounded array types, at least
3272 from the C++ front end. This seems wrong, but attempt
3273 to work around it for now. */
3276 size = int_size_in_bytes (TREE_TYPE (object));
3278 TREE_TYPE (ctor) = type = TREE_TYPE (object);
3281 /* Find the maximum alignment we can assume for the object. */
3282 /* ??? Make use of DECL_OFFSET_ALIGN. */
3283 if (DECL_P (object))
3284 align = DECL_ALIGN (object);
3286 align = TYPE_ALIGN (type);
3288 if (size > 0 && !can_move_by_pieces (size, align))
3292 if (notify_temp_creation)
3295 new = create_tmp_var_raw (type, "C");
3297 gimple_add_tmp_var (new);
3298 TREE_STATIC (new) = 1;
3299 TREE_READONLY (new) = 1;
3300 DECL_INITIAL (new) = ctor;
3301 if (align > DECL_ALIGN (new))
3303 DECL_ALIGN (new) = align;
3304 DECL_USER_ALIGN (new) = 1;
3306 walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
3308 GENERIC_TREE_OPERAND (*expr_p, 1) = new;
3310 /* This is no longer an assignment of a CONSTRUCTOR, but
3311 we still may have processing to do on the LHS. So
3312 pretend we didn't do anything here to let that happen. */
3313 return GS_UNHANDLED;
3317 if (notify_temp_creation)
3320 /* If there are nonzero elements, pre-evaluate to capture elements
3321 overlapping with the lhs into temporaries. We must do this before
3322 clearing to fetch the values before they are zeroed-out. */
3323 if (num_nonzero_elements > 0)
3325 preeval_data.lhs_base_decl = get_base_address (object);
3326 if (!DECL_P (preeval_data.lhs_base_decl))
3327 preeval_data.lhs_base_decl = NULL;
3328 preeval_data.lhs_alias_set = get_alias_set (object);
3330 gimplify_init_ctor_preeval (&GENERIC_TREE_OPERAND (*expr_p, 1),
3331 pre_p, post_p, &preeval_data);
3336 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3337 Note that we still have to gimplify, in order to handle the
3338 case of variable sized types. Avoid shared tree structures. */
3339 CONSTRUCTOR_ELTS (ctor) = NULL;
3340 object = unshare_expr (object);
3341 gimplify_stmt (expr_p);
3342 append_to_statement_list (*expr_p, pre_p);
3345 /* If we have not block cleared the object, or if there are nonzero
3346 elements in the constructor, add assignments to the individual
3347 scalar fields of the object. */
3348 if (!cleared || num_nonzero_elements > 0)
3349 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
3351 *expr_p = NULL_TREE;
3359 if (notify_temp_creation)
3362 /* Extract the real and imaginary parts out of the ctor. */
3363 gcc_assert (VEC_length (constructor_elt, elts) == 2);
3364 r = VEC_index (constructor_elt, elts, 0)->value;
3365 i = VEC_index (constructor_elt, elts, 1)->value;
3366 if (r == NULL || i == NULL)
3368 tree zero = fold_convert (TREE_TYPE (type), integer_zero_node);
3375 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
3376 represent creation of a complex value. */
3377 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
3379 ctor = build_complex (type, r, i);
3380 TREE_OPERAND (*expr_p, 1) = ctor;
3384 ctor = build2 (COMPLEX_EXPR, type, r, i);
3385 TREE_OPERAND (*expr_p, 1) = ctor;
3386 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3387 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
3395 unsigned HOST_WIDE_INT ix;
3396 constructor_elt *ce;
3398 if (notify_temp_creation)
3401 /* Go ahead and simplify constant constructors to VECTOR_CST. */
3402 if (TREE_CONSTANT (ctor))
3404 bool constant_p = true;
3407 /* Even when ctor is constant, it might contain non-*_CST
3408 elements, such as addresses or trapping values like
3409 1.0/0.0 - 1.0/0.0. Such expressions don't belong
3410 in VECTOR_CST nodes. */
3411 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
3412 if (!CONSTANT_CLASS_P (value))
3420 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
3424 /* Don't reduce an initializer constant even if we can't
3425 make a VECTOR_CST. It won't do anything for us, and it'll
3426 prevent us from representing it as a single constant. */
3427 if (initializer_constant_valid_p (ctor, type))
3430 TREE_CONSTANT (ctor) = 0;
3433 /* Vector types use CONSTRUCTOR all the way through gimple
3434 compilation as a general initializer. */
3435 for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++)
3437 enum gimplify_status tret;
3438 tret = gimplify_expr (&ce->value, pre_p, post_p,
3439 is_gimple_val, fb_rvalue);
3440 if (tret == GS_ERROR)
3443 if (!is_gimple_reg (GENERIC_TREE_OPERAND (*expr_p, 0)))
3444 GENERIC_TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
3449 /* So how did we get a CONSTRUCTOR for a scalar type? */
3453 if (ret == GS_ERROR)
3455 else if (want_value)
3457 append_to_statement_list (*expr_p, pre_p);
3465 /* Given a pointer value OP0, return a simplified version of an
3466 indirection through OP0, or NULL_TREE if no simplification is
3467 possible. Note that the resulting type may be different from
3468 the type pointed to in the sense that it is still compatible
3469 from the langhooks point of view. */
3472 gimple_fold_indirect_ref (tree t)
3474 tree type = TREE_TYPE (TREE_TYPE (t));
3478 STRIP_USELESS_TYPE_CONVERSION (sub);
3479 subtype = TREE_TYPE (sub);
3480 if (!POINTER_TYPE_P (subtype))
3483 if (TREE_CODE (sub) == ADDR_EXPR)
3485 tree op = TREE_OPERAND (sub, 0);
3486 tree optype = TREE_TYPE (op);
3488 if (useless_type_conversion_p (type, optype))
3491 /* *(foo *)&fooarray => fooarray[0] */
3492 if (TREE_CODE (optype) == ARRAY_TYPE
3493 && useless_type_conversion_p (type, TREE_TYPE (optype)))
3495 tree type_domain = TYPE_DOMAIN (optype);
3496 tree min_val = size_zero_node;
3497 if (type_domain && TYPE_MIN_VALUE (type_domain))
3498 min_val = TYPE_MIN_VALUE (type_domain);
3499 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
3503 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3504 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
3505 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (subtype))))
3508 tree min_val = size_zero_node;
3510 sub = gimple_fold_indirect_ref (sub);
3512 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
3513 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
3514 if (type_domain && TYPE_MIN_VALUE (type_domain))
3515 min_val = TYPE_MIN_VALUE (type_domain);
3516 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
3522 /* Given a pointer value OP0, return a simplified version of an
3523 indirection through OP0, or NULL_TREE if no simplification is
3524 possible. This may only be applied to a rhs of an expression.
3525 Note that the resulting type may be different from the type pointed
3526 to in the sense that it is still compatible from the langhooks
3530 gimple_fold_indirect_ref_rhs (tree t)
3532 return gimple_fold_indirect_ref (t);
3535 /* Subroutine of gimplify_modify_expr to do simplifications of
3536 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
3537 something changes. */
3539 static enum gimplify_status
3540 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
3541 tree *post_p, bool want_value)
3543 enum gimplify_status ret = GS_OK;
3545 while (ret != GS_UNHANDLED)
3546 switch (TREE_CODE (*from_p))
3549 /* If we're assigning from a constant constructor, move the
3550 constructor expression to the RHS of the MODIFY_EXPR. */
3551 if (DECL_INITIAL (*from_p)
3552 && TYPE_READONLY (TREE_TYPE (*from_p))
3553 && !TREE_THIS_VOLATILE (*from_p)
3554 && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
3556 tree old_from = *from_p;
3558 /* Move the constructor into the RHS. */
3559 *from_p = unshare_expr (DECL_INITIAL (*from_p));
3561 /* Let's see if gimplify_init_constructor will need to put
3562 it in memory. If so, revert the change. */
3563 ret = gimplify_init_constructor (expr_p, NULL, NULL, false, true);
3564 if (ret == GS_ERROR)
3579 /* If we have code like
3583 where the type of "x" is a (possibly cv-qualified variant
3584 of "A"), treat the entire expression as identical to "x".
3585 This kind of code arises in C++ when an object is bound
3586 to a const reference, and if "x" is a TARGET_EXPR we want
3587 to take advantage of the optimization below. */
3588 tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
3601 /* If we are initializing something from a TARGET_EXPR, strip the
3602 TARGET_EXPR and initialize it directly, if possible. This can't
3603 be done if the initializer is void, since that implies that the
3604 temporary is set in some non-trivial way.
3606 ??? What about code that pulls out the temp and uses it
3607 elsewhere? I think that such code never uses the TARGET_EXPR as
3608 an initializer. If I'm wrong, we'll die because the temp won't
3609 have any RTL. In that case, I guess we'll need to replace
3610 references somehow. */
3611 tree init = TARGET_EXPR_INITIAL (*from_p);
3614 && !VOID_TYPE_P (TREE_TYPE (init)))
3625 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
3627 gimplify_compound_expr (from_p, pre_p, true);
3632 /* If we're initializing from a CONSTRUCTOR, break this into
3633 individual MODIFY_EXPRs. */
3634 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
3638 /* If we're assigning to a non-register type, push the assignment
3639 down into the branches. This is mandatory for ADDRESSABLE types,
3640 since we cannot generate temporaries for such, but it saves a
3641 copy in other cases as well. */
3642 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
3644 /* This code should mirror the code in gimplify_cond_expr. */
3645 enum tree_code code = TREE_CODE (*expr_p);
3646 tree cond = *from_p;
3647 tree result = *to_p;
3649 ret = gimplify_expr (&result, pre_p, post_p,
3650 is_gimple_lvalue, fb_lvalue);
3651 if (ret != GS_ERROR)
3654 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
3655 TREE_OPERAND (cond, 1)
3656 = build2 (code, void_type_node, result,
3657 TREE_OPERAND (cond, 1));
3658 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
3659 TREE_OPERAND (cond, 2)
3660 = build2 (code, void_type_node, unshare_expr (result),
3661 TREE_OPERAND (cond, 2));
3663 TREE_TYPE (cond) = void_type_node;
3664 recalculate_side_effects (cond);
3668 gimplify_and_add (cond, pre_p);
3669 *expr_p = unshare_expr (result);
3680 /* For calls that return in memory, give *to_p as the CALL_EXPR's
3681 return slot so that we don't generate a temporary. */
3682 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
3683 && aggregate_value_p (*from_p, *from_p))
3687 if (!(rhs_predicate_for (*to_p))(*from_p))
3688 /* If we need a temporary, *to_p isn't accurate. */
3690 else if (TREE_CODE (*to_p) == RESULT_DECL
3691 && DECL_NAME (*to_p) == NULL_TREE
3692 && needs_to_live_in_memory (*to_p))
3693 /* It's OK to use the return slot directly unless it's an NRV. */
3695 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
3696 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
3697 /* Don't force regs into memory. */
3699 else if (TREE_CODE (*to_p) == VAR_DECL
3700 && DECL_GIMPLE_FORMAL_TEMP_P (*to_p))
3701 /* Don't use the original target if it's a formal temp; we
3702 don't want to take their addresses. */
3704 else if (TREE_CODE (*expr_p) == INIT_EXPR)
3705 /* It's OK to use the target directly if it's being
3708 else if (!is_gimple_non_addressable (*to_p))
3709 /* Don't use the original target if it's already addressable;
3710 if its address escapes, and the called function uses the
3711 NRV optimization, a conforming program could see *to_p
3712 change before the called function returns; see c++/19317.
3713 When optimizing, the return_slot pass marks more functions
3714 as safe after we have escape info. */
3721 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
3722 mark_addressable (*to_p);
3729 /* If we're initializing from a container, push the initialization
3731 case CLEANUP_POINT_EXPR:
3733 case STATEMENT_LIST:
3735 tree wrap = *from_p;
3738 ret = gimplify_expr (to_p, pre_p, post_p,
3739 is_gimple_min_lval, fb_lvalue);
3740 if (ret != GS_ERROR)
3743 t = voidify_wrapper_expr (wrap, *expr_p);
3744 gcc_assert (t == *expr_p);
3748 gimplify_and_add (wrap, pre_p);
3749 *expr_p = unshare_expr (*to_p);
3764 /* Destructively convert the TREE pointer in TP into a gimple tuple if
3768 tree_to_gimple_tuple (tree *tp)
3771 switch (TREE_CODE (*tp))
3773 case GIMPLE_MODIFY_STMT:
3777 struct gimple_stmt *gs;
3778 tree lhs = TREE_OPERAND (*tp, 0);
3779 bool def_stmt_self_p = false;
3781 if (TREE_CODE (lhs) == SSA_NAME)
3783 if (SSA_NAME_DEF_STMT (lhs) == *tp)
3784 def_stmt_self_p = true;
3787 gs = &make_node (GIMPLE_MODIFY_STMT)->gstmt;
3788 gs->base = (*tp)->base;
3789 /* The set to base above overwrites the CODE. */
3790 TREE_SET_CODE ((tree) gs, GIMPLE_MODIFY_STMT);
3792 SET_EXPR_LOCUS ((tree) gs, EXPR_LOCUS (*tp));
3793 gs->operands[0] = TREE_OPERAND (*tp, 0);
3794 gs->operands[1] = TREE_OPERAND (*tp, 1);
3795 gs->block = TREE_BLOCK (*tp);
3798 /* If we re-gimplify a set to an SSA_NAME, we must change the
3799 SSA name's DEF_STMT link. */
3800 if (def_stmt_self_p)
3801 SSA_NAME_DEF_STMT (GIMPLE_STMT_OPERAND (*tp, 0)) = *tp;
3810 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
3811 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
3812 DECL_GIMPLE_REG_P set.
3814 IMPORTANT NOTE: This promotion is performed by introducing a load of the
3815 other, unmodified part of the complex object just before the total store.
3816 As a consequence, if the object is still uninitialized, an undefined value
3817 will be loaded into a register, which may result in a spurious exception
3818 if the register is floating-point and the value happens to be a signaling
3819 NaN for example. Then the fully-fledged complex operations lowering pass
3820 followed by a DCE pass are necessary in order to fix things up. */
3822 static enum gimplify_status
3823 gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
3825 enum tree_code code, ocode;
3826 tree lhs, rhs, new_rhs, other, realpart, imagpart;
3828 lhs = GENERIC_TREE_OPERAND (*expr_p, 0);
3829 rhs = GENERIC_TREE_OPERAND (*expr_p, 1);
3830 code = TREE_CODE (lhs);
3831 lhs = TREE_OPERAND (lhs, 0);
3833 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
3834 other = build1 (ocode, TREE_TYPE (rhs), lhs);
3835 other = get_formal_tmp_var (other, pre_p);
3837 realpart = code == REALPART_EXPR ? rhs : other;
3838 imagpart = code == REALPART_EXPR ? other : rhs;
3840 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
3841 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
3843 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
3845 GENERIC_TREE_OPERAND (*expr_p, 0) = lhs;
3846 GENERIC_TREE_OPERAND (*expr_p, 1) = new_rhs;
3850 tree_to_gimple_tuple (expr_p);
3852 append_to_statement_list (*expr_p, pre_p);
3859 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
3865 PRE_P points to the list where side effects that must happen before
3866 *EXPR_P should be stored.
3868 POST_P points to the list where side effects that must happen after
3869 *EXPR_P should be stored.
3871 WANT_VALUE is nonzero iff we want to use the value of this expression
3872 in another expression. */
3874 static enum gimplify_status
3875 gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
3877 tree *from_p = &GENERIC_TREE_OPERAND (*expr_p, 1);
3878 tree *to_p = &GENERIC_TREE_OPERAND (*expr_p, 0);
3879 enum gimplify_status ret = GS_UNHANDLED;
3881 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
3882 || TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT
3883 || TREE_CODE (*expr_p) == INIT_EXPR);
3885 /* Insert pointer conversions required by the middle-end that are not
3886 required by the frontend. This fixes middle-end type checking for
3887 for example gcc.dg/redecl-6.c. */
3888 if (POINTER_TYPE_P (TREE_TYPE (*to_p))
3889 && lang_hooks.types_compatible_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
3891 STRIP_USELESS_TYPE_CONVERSION (*from_p);
3892 if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
3893 *from_p = fold_convert (TREE_TYPE (*to_p), *from_p);
3896 /* See if any simplifications can be done based on what the RHS is. */
3897 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3899 if (ret != GS_UNHANDLED)
3902 /* For zero sized types only gimplify the left hand side and right hand
3903 side as statements and throw away the assignment. Do this after
3904 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
3906 if (zero_sized_type (TREE_TYPE (*from_p)))
3908 gimplify_stmt (from_p);
3909 gimplify_stmt (to_p);
3910 append_to_statement_list (*from_p, pre_p);
3911 append_to_statement_list (*to_p, pre_p);
3912 *expr_p = NULL_TREE;
3916 /* If the value being copied is of variable width, compute the length
3917 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
3918 before gimplifying any of the operands so that we can resolve any
3919 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
3920 the size of the expression to be copied, not of the destination, so
3921 that is what we must here. */
3922 maybe_with_size_expr (from_p);
3924 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
3925 if (ret == GS_ERROR)
3928 ret = gimplify_expr (from_p, pre_p, post_p,
3929 rhs_predicate_for (*to_p), fb_rvalue);
3930 if (ret == GS_ERROR)
3933 /* Now see if the above changed *from_p to something we handle specially. */
3934 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3936 if (ret != GS_UNHANDLED)
3939 /* If we've got a variable sized assignment between two lvalues (i.e. does
3940 not involve a call), then we can make things a bit more straightforward
3941 by converting the assignment to memcpy or memset. */
3942 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
3944 tree from = TREE_OPERAND (*from_p, 0);
3945 tree size = TREE_OPERAND (*from_p, 1);
3947 if (TREE_CODE (from) == CONSTRUCTOR)
3948 return gimplify_modify_expr_to_memset (expr_p, size, want_value);
3949 if (is_gimple_addressable (from))
3952 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value);
3956 /* Transform partial stores to non-addressable complex variables into
3957 total stores. This allows us to use real instead of virtual operands
3958 for these variables, which improves optimization. */
3959 if ((TREE_CODE (*to_p) == REALPART_EXPR
3960 || TREE_CODE (*to_p) == IMAGPART_EXPR)
3961 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
3962 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
3964 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
3966 /* If we've somehow already got an SSA_NAME on the LHS, then
3967 we're probably modified it twice. Not good. */
3968 gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
3969 *to_p = make_ssa_name (*to_p, *expr_p);
3972 /* Try to alleviate the effects of the gimplification creating artificial
3973 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
3974 if (!gimplify_ctxp->into_ssa
3975 && DECL_P (*from_p) && DECL_IGNORED_P (*from_p)
3976 && DECL_P (*to_p) && !DECL_IGNORED_P (*to_p))
3978 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
3980 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
3981 DECL_DEBUG_EXPR_IS_FROM (*from_p) = 1;
3982 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
3987 tree_to_gimple_tuple (expr_p);
3989 append_to_statement_list (*expr_p, pre_p);
3997 /* Gimplify a comparison between two variable-sized objects. Do this
3998 with a call to BUILT_IN_MEMCMP. */
4000 static enum gimplify_status
4001 gimplify_variable_sized_compare (tree *expr_p)
4003 tree op0 = TREE_OPERAND (*expr_p, 0);
4004 tree op1 = TREE_OPERAND (*expr_p, 1);
4005 tree t, arg, dest, src;
4007 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
4008 arg = unshare_expr (arg);
4009 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
4010 src = build_fold_addr_expr (op1);
4011 dest = build_fold_addr_expr (op0);
4012 t = implicit_built_in_decls[BUILT_IN_MEMCMP];
4013 t = build_call_expr (t, 3, dest, src, arg);
4015 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
4020 /* Gimplify a comparison between two aggregate objects of integral scalar
4021 mode as a comparison between the bitwise equivalent scalar values. */
4023 static enum gimplify_status
4024 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
4026 tree op0 = TREE_OPERAND (*expr_p, 0);
4027 tree op1 = TREE_OPERAND (*expr_p, 1);
4029 tree type = TREE_TYPE (op0);
4030 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
4032 op0 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op0);
4033 op1 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op1);
4036 = fold_build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
4041 /* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P
4042 points to the expression to gimplify.
4044 Expressions of the form 'a && b' are gimplified to:
4046 a && b ? true : false
4048 gimplify_cond_expr will do the rest.
4050 PRE_P points to the list where side effects that must happen before
4051 *EXPR_P should be stored. */
4053 static enum gimplify_status
4054 gimplify_boolean_expr (tree *expr_p)
4056 /* Preserve the original type of the expression. */
4057 tree type = TREE_TYPE (*expr_p);
4059 *expr_p = build3 (COND_EXPR, type, *expr_p,
4060 fold_convert (type, boolean_true_node),
4061 fold_convert (type, boolean_false_node));
4066 /* Gimplifies an expression sequence. This function gimplifies each
4067 expression and re-writes the original expression with the last
4068 expression of the sequence in GIMPLE form.
4070 PRE_P points to the list where the side effects for all the
4071 expressions in the sequence will be emitted.
4073 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4074 /* ??? Should rearrange to share the pre-queue with all the indirect
4075 invocations of gimplify_expr. Would probably save on creations
4076 of statement_list nodes. */
4078 static enum gimplify_status
4079 gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value)
4085 tree *sub_p = &TREE_OPERAND (t, 0);
4087 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
4088 gimplify_compound_expr (sub_p, pre_p, false);
4090 gimplify_stmt (sub_p);
4091 append_to_statement_list (*sub_p, pre_p);
4093 t = TREE_OPERAND (t, 1);
4095 while (TREE_CODE (t) == COMPOUND_EXPR);
4102 gimplify_stmt (expr_p);
4107 /* Gimplifies a statement list. These may be created either by an
4108 enlightened front-end, or by shortcut_cond_expr. */
4110 static enum gimplify_status
4111 gimplify_statement_list (tree *expr_p, tree *pre_p)
4113 tree temp = voidify_wrapper_expr (*expr_p, NULL);
4115 tree_stmt_iterator i = tsi_start (*expr_p);
4117 while (!tsi_end_p (i))
4121 gimplify_stmt (tsi_stmt_ptr (i));
4126 else if (TREE_CODE (t) == STATEMENT_LIST)
4128 tsi_link_before (&i, t, TSI_SAME_STMT);
4137 append_to_statement_list (*expr_p, pre_p);
4145 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4146 gimplify. After gimplification, EXPR_P will point to a new temporary
4147 that holds the original value of the SAVE_EXPR node.
4149 PRE_P points to the list where side effects that must happen before
4150 *EXPR_P should be stored. */
4152 static enum gimplify_status
4153 gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p)
4155 enum gimplify_status ret = GS_ALL_DONE;
4158 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
4159 val = TREE_OPERAND (*expr_p, 0);
4161 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4162 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
4164 /* The operand may be a void-valued expression such as SAVE_EXPRs
4165 generated by the Java frontend for class initialization. It is
4166 being executed only for its side-effects. */
4167 if (TREE_TYPE (val) == void_type_node)
4169 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
4170 is_gimple_stmt, fb_none);
4171 append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p);
4175 val = get_initialized_tmp_var (val, pre_p, post_p);
4177 TREE_OPERAND (*expr_p, 0) = val;
4178 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
4186 /* Re-write the ADDR_EXPR node pointed to by EXPR_P
4193 PRE_P points to the list where side effects that must happen before
4194 *EXPR_P should be stored.
4196 POST_P points to the list where side effects that must happen after
4197 *EXPR_P should be stored. */
4199 static enum gimplify_status
4200 gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
4202 tree expr = *expr_p;
4203 tree op0 = TREE_OPERAND (expr, 0);
4204 enum gimplify_status ret;
4206 switch (TREE_CODE (op0))
4209 case MISALIGNED_INDIRECT_REF:
4211 /* Check if we are dealing with an expression of the form '&*ptr'.
4212 While the front end folds away '&*ptr' into 'ptr', these
4213 expressions may be generated internally by the compiler (e.g.,
4214 builtins like __builtin_va_end). */
4215 /* Caution: the silent array decomposition semantics we allow for
4216 ADDR_EXPR means we can't always discard the pair. */
4217 /* Gimplification of the ADDR_EXPR operand may drop
4218 cv-qualification conversions, so make sure we add them if
4221 tree op00 = TREE_OPERAND (op0, 0);
4222 tree t_expr = TREE_TYPE (expr);
4223 tree t_op00 = TREE_TYPE (op00);
4225 if (!useless_type_conversion_p (t_expr, t_op00))
4226 op00 = fold_convert (TREE_TYPE (expr), op00);
4232 case VIEW_CONVERT_EXPR:
4233 /* Take the address of our operand and then convert it to the type of
4236 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
4237 all clear. The impact of this transformation is even less clear. */
4239 /* If the operand is a useless conversion, look through it. Doing so
4240 guarantees that the ADDR_EXPR and its operand will remain of the
4242 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
4243 op0 = TREE_OPERAND (op0, 0);
4245 *expr_p = fold_convert (TREE_TYPE (expr),
4246 build_fold_addr_expr (TREE_OPERAND (op0, 0)));
4251 /* We use fb_either here because the C frontend sometimes takes
4252 the address of a call that returns a struct; see
4253 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
4254 the implied temporary explicit. */
4256 /* Mark the RHS addressable. */
4257 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
4258 is_gimple_addressable, fb_either);
4259 if (ret != GS_ERROR)
4261 op0 = TREE_OPERAND (expr, 0);
4263 /* For various reasons, the gimplification of the expression
4264 may have made a new INDIRECT_REF. */
4265 if (TREE_CODE (op0) == INDIRECT_REF)
4266 goto do_indirect_ref;
4268 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
4269 recompute_tree_invariant_for_addr_expr (expr);
4271 mark_addressable (TREE_OPERAND (expr, 0));
4279 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
4280 value; output operands should be a gimple lvalue. */
4282 static enum gimplify_status
4283 gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p)
4285 tree expr = *expr_p;
4286 int noutputs = list_length (ASM_OUTPUTS (expr));
4287 const char **oconstraints
4288 = (const char **) alloca ((noutputs) * sizeof (const char *));
4291 const char *constraint;
4292 bool allows_mem, allows_reg, is_inout;
4293 enum gimplify_status ret, tret;
4296 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link))
4298 size_t constraint_len;
4300 oconstraints[i] = constraint
4301 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
4302 constraint_len = strlen (constraint);
4303 if (constraint_len == 0)
4306 ok = parse_output_constraint (&constraint, i, 0, 0,
4307 &allows_mem, &allows_reg, &is_inout);
4314 if (!allows_reg && allows_mem)
4315 mark_addressable (TREE_VALUE (link));
4317 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4318 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
4319 fb_lvalue | fb_mayfail);
4320 if (tret == GS_ERROR)
4322 error ("invalid lvalue in asm output %d", i);
4328 /* An input/output operand. To give the optimizers more
4329 flexibility, split it into separate input and output
4334 /* Turn the in/out constraint into an output constraint. */
4335 char *p = xstrdup (constraint);
4337 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
4339 /* And add a matching input constraint. */
4342 sprintf (buf, "%d", i);
4344 /* If there are multiple alternatives in the constraint,
4345 handle each of them individually. Those that allow register
4346 will be replaced with operand number, the others will stay
4348 if (strchr (p, ',') != NULL)
4350 size_t len = 0, buflen = strlen (buf);
4351 char *beg, *end, *str, *dst;
4355 end = strchr (beg, ',');
4357 end = strchr (beg, '\0');
4358 if ((size_t) (end - beg) < buflen)
4361 len += end - beg + 1;
4368 str = (char *) alloca (len);
4369 for (beg = p + 1, dst = str;;)
4372 bool mem_p, reg_p, inout_p;
4374 end = strchr (beg, ',');
4379 parse_output_constraint (&tem, i, 0, 0,
4380 &mem_p, ®_p, &inout_p);
4385 memcpy (dst, buf, buflen);
4394 memcpy (dst, beg, len);
4403 input = build_string (dst - str, str);
4406 input = build_string (strlen (buf), buf);
4409 input = build_string (constraint_len - 1, constraint + 1);
4413 input = build_tree_list (build_tree_list (NULL_TREE, input),
4414 unshare_expr (TREE_VALUE (link)));
4415 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
4419 for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link))
4422 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
4423 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
4424 oconstraints, &allows_mem, &allows_reg);
4426 /* If we can't make copies, we can only accept memory. */
4427 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
4433 error ("impossible constraint in %<asm%>");
4434 error ("non-memory input %d must stay in memory", i);
4439 /* If the operand is a memory input, it should be an lvalue. */
4440 if (!allows_reg && allows_mem)
4442 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4443 is_gimple_lvalue, fb_lvalue | fb_mayfail);
4444 mark_addressable (TREE_VALUE (link));
4445 if (tret == GS_ERROR)
4447 error ("memory input %d is not directly addressable", i);
4453 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4454 is_gimple_asm_val, fb_rvalue);
4455 if (tret == GS_ERROR)
4463 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
4464 WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
4465 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
4466 return to this function.
4468 FIXME should we complexify the prequeue handling instead? Or use flags
4469 for all the cleanups and let the optimizer tighten them up? The current
4470 code seems pretty fragile; it will break on a cleanup within any
4471 non-conditional nesting. But any such nesting would be broken, anyway;
4472 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
4473 and continues out of it. We can do that at the RTL level, though, so
4474 having an optimizer to tighten up try/finally regions would be a Good
4477 static enum gimplify_status
4478 gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p)
4480 tree_stmt_iterator iter;
4483 tree temp = voidify_wrapper_expr (*expr_p, NULL);
4485 /* We only care about the number of conditions between the innermost
4486 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
4487 any cleanups collected outside the CLEANUP_POINT_EXPR. */
4488 int old_conds = gimplify_ctxp->conditions;
4489 tree old_cleanups = gimplify_ctxp->conditional_cleanups;
4490 gimplify_ctxp->conditions = 0;
4491 gimplify_ctxp->conditional_cleanups = NULL_TREE;
4493 body = TREE_OPERAND (*expr_p, 0);
4494 gimplify_to_stmt_list (&body);
4496 gimplify_ctxp->conditions = old_conds;
4497 gimplify_ctxp->conditional_cleanups = old_cleanups;
4499 for (iter = tsi_start (body); !tsi_end_p (iter); )
4501 tree *wce_p = tsi_stmt_ptr (iter);
4504 if (TREE_CODE (wce) == WITH_CLEANUP_EXPR)
4506 if (tsi_one_before_end_p (iter))
4508 tsi_link_before (&iter, TREE_OPERAND (wce, 0), TSI_SAME_STMT);
4515 enum tree_code code;
4517 if (CLEANUP_EH_ONLY (wce))
4518 code = TRY_CATCH_EXPR;
4520 code = TRY_FINALLY_EXPR;
4522 sl = tsi_split_statement_list_after (&iter);
4523 tfe = build2 (code, void_type_node, sl, NULL_TREE);
4524 append_to_statement_list (TREE_OPERAND (wce, 0),
4525 &TREE_OPERAND (tfe, 1));
4527 iter = tsi_start (sl);
4537 append_to_statement_list (body, pre_p);
4547 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
4548 is the cleanup action required. */
4551 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p)
4555 /* Errors can result in improperly nested cleanups. Which results in
4556 confusion when trying to resolve the WITH_CLEANUP_EXPR. */
4557 if (errorcount || sorrycount)
4560 if (gimple_conditional_context ())
4562 /* If we're in a conditional context, this is more complex. We only
4563 want to run the cleanup if we actually ran the initialization that
4564 necessitates it, but we want to run it after the end of the
4565 conditional context. So we wrap the try/finally around the
4566 condition and use a flag to determine whether or not to actually
4567 run the destructor. Thus
4571 becomes (approximately)
4575 if (test) { A::A(temp); flag = 1; val = f(temp); }
4578 if (flag) A::~A(temp);
4583 tree flag = create_tmp_var (boolean_type_node, "cleanup");
4584 tree ffalse = build_gimple_modify_stmt (flag, boolean_false_node);
4585 tree ftrue = build_gimple_modify_stmt (flag, boolean_true_node);
4586 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
4587 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4588 append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups);
4589 append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups);
4590 append_to_statement_list (ftrue, pre_p);
4592 /* Because of this manipulation, and the EH edges that jump
4593 threading cannot redirect, the temporary (VAR) will appear
4594 to be used uninitialized. Don't warn. */
4595 TREE_NO_WARNING (var) = 1;
4599 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4600 CLEANUP_EH_ONLY (wce) = eh_only;
4601 append_to_statement_list (wce, pre_p);
4604 gimplify_stmt (&TREE_OPERAND (wce, 0));
4607 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
4609 static enum gimplify_status
4610 gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p)
4612 tree targ = *expr_p;
4613 tree temp = TARGET_EXPR_SLOT (targ);
4614 tree init = TARGET_EXPR_INITIAL (targ);
4615 enum gimplify_status ret;
4619 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
4620 to the temps list. Handle also variable length TARGET_EXPRs. */
4621 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
4623 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
4624 gimplify_type_sizes (TREE_TYPE (temp), pre_p);
4625 gimplify_vla_decl (temp, pre_p);
4628 gimple_add_tmp_var (temp);
4630 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
4631 expression is supposed to initialize the slot. */
4632 if (VOID_TYPE_P (TREE_TYPE (init)))
4633 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
4636 init = build2 (INIT_EXPR, void_type_node, temp, init);
4637 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt,
4640 if (ret == GS_ERROR)
4642 /* PR c++/28266 Make sure this is expanded only once. */
4643 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4646 append_to_statement_list (init, pre_p);
4648 /* If needed, push the cleanup for the temp. */
4649 if (TARGET_EXPR_CLEANUP (targ))
4651 gimplify_stmt (&TARGET_EXPR_CLEANUP (targ));
4652 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
4653 CLEANUP_EH_ONLY (targ), pre_p);
4656 /* Only expand this once. */
4657 TREE_OPERAND (targ, 3) = init;
4658 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4661 /* We should have expanded this before. */
4662 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
4668 /* Gimplification of expression trees. */
4670 /* Gimplify an expression which appears at statement context; usually, this
4671 means replacing it with a suitably gimple STATEMENT_LIST. */
4674 gimplify_stmt (tree *stmt_p)
4676 gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none);
4679 /* Similarly, but force the result to be a STATEMENT_LIST. */
4682 gimplify_to_stmt_list (tree *stmt_p)
4684 gimplify_stmt (stmt_p);
4686 *stmt_p = alloc_stmt_list ();
4687 else if (TREE_CODE (*stmt_p) != STATEMENT_LIST)
4690 *stmt_p = alloc_stmt_list ();
4691 append_to_statement_list (t, stmt_p);
4696 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
4697 to CTX. If entries already exist, force them to be some flavor of private.
4698 If there is no enclosing parallel, do nothing. */
4701 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
4705 if (decl == NULL || !DECL_P (decl))
4710 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4713 if (n->value & GOVD_SHARED)
4714 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
4718 else if (ctx->region_type != ORT_WORKSHARE)
4719 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
4721 ctx = ctx->outer_context;
4726 /* Similarly for each of the type sizes of TYPE. */
4729 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
4731 if (type == NULL || type == error_mark_node)
4733 type = TYPE_MAIN_VARIANT (type);
4735 if (pointer_set_insert (ctx->privatized_types, type))
4738 switch (TREE_CODE (type))
4744 case FIXED_POINT_TYPE:
4745 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
4746 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
4750 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4751 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
4756 case QUAL_UNION_TYPE:
4759 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4760 if (TREE_CODE (field) == FIELD_DECL)
4762 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
4763 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
4769 case REFERENCE_TYPE:
4770 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4777 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
4778 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
4779 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
4782 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
4785 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
4788 unsigned int nflags;
4791 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4794 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
4795 there are constructors involved somewhere. */
4796 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
4797 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
4800 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4803 /* We shouldn't be re-adding the decl with the same data
4805 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
4806 /* The only combination of data sharing classes we should see is
4807 FIRSTPRIVATE and LASTPRIVATE. */
4808 nflags = n->value | flags;
4809 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
4810 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
4815 /* When adding a variable-sized variable, we have to handle all sorts
4816 of additional bits of data: the pointer replacement variable, and
4817 the parameters of the type. */
4818 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
4820 /* Add the pointer replacement variable as PRIVATE if the variable
4821 replacement is private, else FIRSTPRIVATE since we'll need the
4822 address of the original variable either for SHARED, or for the
4823 copy into or out of the context. */
4824 if (!(flags & GOVD_LOCAL))
4826 nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
4827 nflags |= flags & GOVD_SEEN;
4828 t = DECL_VALUE_EXPR (decl);
4829 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
4830 t = TREE_OPERAND (t, 0);
4831 gcc_assert (DECL_P (t));
4832 omp_add_variable (ctx, t, nflags);
4835 /* Add all of the variable and type parameters (which should have
4836 been gimplified to a formal temporary) as FIRSTPRIVATE. */
4837 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
4838 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
4839 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4841 /* The variable-sized variable itself is never SHARED, only some form
4842 of PRIVATE. The sharing would take place via the pointer variable
4843 which we remapped above. */
4844 if (flags & GOVD_SHARED)
4845 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
4846 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
4848 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
4849 alloca statement we generate for the variable, so make sure it
4850 is available. This isn't automatically needed for the SHARED
4851 case, since we won't be allocating local storage then.
4852 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
4853 in this case omp_notice_variable will be called later
4854 on when it is gimplified. */
4855 else if (! (flags & GOVD_LOCAL))
4856 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
4858 else if (lang_hooks.decls.omp_privatize_by_reference (decl))
4860 gcc_assert ((flags & GOVD_LOCAL) == 0);
4861 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4863 /* Similar to the direct variable sized case above, we'll need the
4864 size of references being privatized. */
4865 if ((flags & GOVD_SHARED) == 0)
4867 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
4868 if (TREE_CODE (t) != INTEGER_CST)
4869 omp_notice_variable (ctx, t, true);
4873 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
4876 /* Record the fact that DECL was used within the OpenMP context CTX.
4877 IN_CODE is true when real code uses DECL, and false when we should
4878 merely emit default(none) errors. Return true if DECL is going to
4879 be remapped and thus DECL shouldn't be gimplified into its
4880 DECL_VALUE_EXPR (if any). */
4883 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
4886 unsigned flags = in_code ? GOVD_SEEN : 0;
4887 bool ret = false, shared;
4889 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4892 /* Threadprivate variables are predetermined. */
4893 if (is_global_var (decl))
4895 if (DECL_THREAD_LOCAL_P (decl))
4898 if (DECL_HAS_VALUE_EXPR_P (decl))
4900 tree value = get_base_address (DECL_VALUE_EXPR (decl));
4902 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
4907 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4910 enum omp_clause_default_kind default_kind, kind;
4911 struct gimplify_omp_ctx *octx;
4913 if (ctx->region_type == ORT_WORKSHARE)
4916 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
4917 remapped firstprivate instead of shared. To some extent this is
4918 addressed in omp_firstprivatize_type_sizes, but not effectively. */
4919 default_kind = ctx->default_kind;
4920 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
4921 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
4922 default_kind = kind;
4924 switch (default_kind)
4926 case OMP_CLAUSE_DEFAULT_NONE:
4927 error ("%qs not specified in enclosing parallel",
4928 IDENTIFIER_POINTER (DECL_NAME (decl)));
4929 error ("%Henclosing parallel", &ctx->location);
4931 case OMP_CLAUSE_DEFAULT_SHARED:
4932 flags |= GOVD_SHARED;
4934 case OMP_CLAUSE_DEFAULT_PRIVATE:
4935 flags |= GOVD_PRIVATE;
4937 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
4938 flags |= GOVD_FIRSTPRIVATE;
4940 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
4941 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
4942 gcc_assert (ctx->region_type == ORT_TASK);
4943 if (ctx->outer_context)
4944 omp_notice_variable (ctx->outer_context, decl, in_code);
4945 for (octx = ctx->outer_context; octx; octx = octx->outer_context)
4949 n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
4950 if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
4952 flags |= GOVD_FIRSTPRIVATE;
4955 if ((octx->region_type & ORT_PARALLEL) != 0)
4958 if (flags & GOVD_FIRSTPRIVATE)
4961 && (TREE_CODE (decl) == PARM_DECL
4962 || (!is_global_var (decl)
4963 && DECL_CONTEXT (decl) == current_function_decl)))
4965 flags |= GOVD_FIRSTPRIVATE;
4968 flags |= GOVD_SHARED;
4974 if ((flags & GOVD_PRIVATE)
4975 && lang_hooks.decls.omp_private_outer_ref (decl))
4976 flags |= GOVD_PRIVATE_OUTER_REF;
4978 omp_add_variable (ctx, decl, flags);
4980 shared = (flags & GOVD_SHARED) != 0;
4981 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4985 shared = ((flags | n->value) & GOVD_SHARED) != 0;
4986 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4988 /* If nothing changed, there's nothing left to do. */
4989 if ((n->value & flags) == flags)
4995 /* If the variable is private in the current context, then we don't
4996 need to propagate anything to an outer context. */
4997 if ((flags & GOVD_PRIVATE) && !(flags & GOVD_PRIVATE_OUTER_REF))
4999 if (ctx->outer_context
5000 && omp_notice_variable (ctx->outer_context, decl, in_code))
5005 /* Verify that DECL is private within CTX. If there's specific information
5006 to the contrary in the innermost scope, generate an error. */
5009 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl)
5013 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5016 if (n->value & GOVD_SHARED)
5018 if (ctx == gimplify_omp_ctxp)
5020 error ("iteration variable %qs should be private",
5021 IDENTIFIER_POINTER (DECL_NAME (decl)));
5022 n->value = GOVD_PRIVATE;
5028 else if ((n->value & GOVD_EXPLICIT) != 0
5029 && (ctx == gimplify_omp_ctxp
5030 || (ctx->region_type == ORT_COMBINED_PARALLEL
5031 && gimplify_omp_ctxp->outer_context == ctx)))
5033 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
5034 error ("iteration variable %qs should not be firstprivate",
5035 IDENTIFIER_POINTER (DECL_NAME (decl)));
5036 else if ((n->value & GOVD_REDUCTION) != 0)
5037 error ("iteration variable %qs should not be reduction",
5038 IDENTIFIER_POINTER (DECL_NAME (decl)));
5040 return (ctx == gimplify_omp_ctxp
5041 || (ctx->region_type == ORT_COMBINED_PARALLEL
5042 && gimplify_omp_ctxp->outer_context == ctx));
5045 if (ctx->region_type != ORT_WORKSHARE)
5047 else if (ctx->outer_context)
5048 return omp_is_private (ctx->outer_context, decl);
5052 /* Return true if DECL is private within a parallel region
5053 that binds to the current construct's context or in parallel
5054 region's REDUCTION clause. */
5057 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl)
5063 ctx = ctx->outer_context;
5065 return !(is_global_var (decl)
5066 /* References might be private, but might be shared too. */
5067 || lang_hooks.decls.omp_privatize_by_reference (decl));
5069 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5071 return (n->value & GOVD_SHARED) == 0;
5073 while (ctx->region_type == ORT_WORKSHARE);
5077 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
5078 and previous omp contexts. */
5081 gimplify_scan_omp_clauses (tree *list_p, tree *pre_p,
5082 enum omp_region_type region_type)
5084 struct gimplify_omp_ctx *ctx, *outer_ctx;
5085 struct gimplify_ctx gctx;
5088 ctx = new_omp_context (region_type);
5089 outer_ctx = ctx->outer_context;
5091 while ((c = *list_p) != NULL)
5093 enum gimplify_status gs;
5094 bool remove = false;
5095 bool notice_outer = true;
5096 const char *check_non_private = NULL;
5100 switch (OMP_CLAUSE_CODE (c))
5102 case OMP_CLAUSE_PRIVATE:
5103 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
5104 if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
5106 flags |= GOVD_PRIVATE_OUTER_REF;
5107 OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
5110 notice_outer = false;
5112 case OMP_CLAUSE_SHARED:
5113 flags = GOVD_SHARED | GOVD_EXPLICIT;
5115 case OMP_CLAUSE_FIRSTPRIVATE:
5116 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
5117 check_non_private = "firstprivate";
5119 case OMP_CLAUSE_LASTPRIVATE:
5120 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
5121 check_non_private = "lastprivate";
5123 case OMP_CLAUSE_REDUCTION:
5124 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
5125 check_non_private = "reduction";
5129 decl = OMP_CLAUSE_DECL (c);
5130 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
5135 omp_add_variable (ctx, decl, flags);
5136 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
5137 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
5139 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
5140 GOVD_LOCAL | GOVD_SEEN);
5141 gimplify_omp_ctxp = ctx;
5142 push_gimplify_context (&gctx);
5143 gimplify_stmt (&OMP_CLAUSE_REDUCTION_INIT (c));
5144 pop_gimplify_context (OMP_CLAUSE_REDUCTION_INIT (c));
5145 push_gimplify_context (&gctx);
5146 gimplify_stmt (&OMP_CLAUSE_REDUCTION_MERGE (c));
5147 pop_gimplify_context (OMP_CLAUSE_REDUCTION_MERGE (c));
5148 gimplify_omp_ctxp = outer_ctx;
5150 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
5151 && OMP_CLAUSE_LASTPRIVATE_STMT (c))
5153 gimplify_omp_ctxp = ctx;
5154 push_gimplify_context (&gctx);
5155 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
5157 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
5159 TREE_SIDE_EFFECTS (bind) = 1;
5160 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
5161 OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
5163 gimplify_stmt (&OMP_CLAUSE_LASTPRIVATE_STMT (c));
5164 pop_gimplify_context (OMP_CLAUSE_LASTPRIVATE_STMT (c));
5165 gimplify_omp_ctxp = outer_ctx;
5171 case OMP_CLAUSE_COPYIN:
5172 case OMP_CLAUSE_COPYPRIVATE:
5173 decl = OMP_CLAUSE_DECL (c);
5174 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
5181 omp_notice_variable (outer_ctx, decl, true);
5182 if (check_non_private
5183 && region_type == ORT_WORKSHARE
5184 && omp_check_private (ctx, decl))
5186 error ("%s variable %qs is private in outer context",
5187 check_non_private, IDENTIFIER_POINTER (DECL_NAME (decl)));
5193 OMP_CLAUSE_OPERAND (c, 0)
5194 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
5197 case OMP_CLAUSE_SCHEDULE:
5198 case OMP_CLAUSE_NUM_THREADS:
5199 gs = gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
5200 is_gimple_val, fb_rvalue);
5205 case OMP_CLAUSE_NOWAIT:
5206 case OMP_CLAUSE_ORDERED:
5207 case OMP_CLAUSE_UNTIED:
5208 case OMP_CLAUSE_COLLAPSE:
5211 case OMP_CLAUSE_DEFAULT:
5212 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
5220 *list_p = OMP_CLAUSE_CHAIN (c);
5222 list_p = &OMP_CLAUSE_CHAIN (c);
5225 gimplify_omp_ctxp = ctx;
5228 /* For all variables that were not actually used within the context,
5229 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
5232 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
5234 tree *list_p = (tree *) data;
5235 tree decl = (tree) n->key;
5236 unsigned flags = n->value;
5237 enum omp_clause_code code;
5241 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
5243 if ((flags & GOVD_SEEN) == 0)
5245 if (flags & GOVD_DEBUG_PRIVATE)
5247 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
5248 private_debug = true;
5252 = lang_hooks.decls.omp_private_debug_clause (decl,
5253 !!(flags & GOVD_SHARED));
5255 code = OMP_CLAUSE_PRIVATE;
5256 else if (flags & GOVD_SHARED)
5258 if (is_global_var (decl))
5260 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
5264 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5265 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
5266 | GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
5268 ctx = ctx->outer_context;
5273 code = OMP_CLAUSE_SHARED;
5275 else if (flags & GOVD_PRIVATE)
5276 code = OMP_CLAUSE_PRIVATE;
5277 else if (flags & GOVD_FIRSTPRIVATE)
5278 code = OMP_CLAUSE_FIRSTPRIVATE;
5282 clause = build_omp_clause (code);
5283 OMP_CLAUSE_DECL (clause) = decl;
5284 OMP_CLAUSE_CHAIN (clause) = *list_p;
5286 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
5287 else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
5288 OMP_CLAUSE_PRIVATE_OUTER_REF (clause) = 1;
5290 lang_hooks.decls.omp_finish_clause (clause);
5296 gimplify_adjust_omp_clauses (tree *list_p)
5298 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
5301 while ((c = *list_p) != NULL)
5304 bool remove = false;
5306 switch (OMP_CLAUSE_CODE (c))
5308 case OMP_CLAUSE_PRIVATE:
5309 case OMP_CLAUSE_SHARED:
5310 case OMP_CLAUSE_FIRSTPRIVATE:
5311 decl = OMP_CLAUSE_DECL (c);
5312 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5313 remove = !(n->value & GOVD_SEEN);
5316 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
5317 if ((n->value & GOVD_DEBUG_PRIVATE)
5318 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
5320 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
5321 || ((n->value & GOVD_DATA_SHARE_CLASS)
5323 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
5324 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
5329 case OMP_CLAUSE_LASTPRIVATE:
5330 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
5331 accurately reflect the presence of a FIRSTPRIVATE clause. */
5332 decl = OMP_CLAUSE_DECL (c);
5333 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5334 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
5335 = (n->value & GOVD_FIRSTPRIVATE) != 0;
5338 case OMP_CLAUSE_REDUCTION:
5339 case OMP_CLAUSE_COPYIN:
5340 case OMP_CLAUSE_COPYPRIVATE:
5342 case OMP_CLAUSE_NUM_THREADS:
5343 case OMP_CLAUSE_SCHEDULE:
5344 case OMP_CLAUSE_NOWAIT:
5345 case OMP_CLAUSE_ORDERED:
5346 case OMP_CLAUSE_DEFAULT:
5347 case OMP_CLAUSE_UNTIED:
5348 case OMP_CLAUSE_COLLAPSE:
5356 *list_p = OMP_CLAUSE_CHAIN (c);
5358 list_p = &OMP_CLAUSE_CHAIN (c);
5361 /* Add in any implicit data sharing. */
5362 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
5364 gimplify_omp_ctxp = ctx->outer_context;
5365 delete_omp_context (ctx);
5368 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
5369 gimplification of the body, as well as scanning the body for used
5370 variables. We need to do this scan now, because variable-sized
5371 decls will be decomposed during gimplification. */
5373 static enum gimplify_status
5374 gimplify_omp_parallel (tree *expr_p, tree *pre_p)
5376 tree expr = *expr_p;
5377 struct gimplify_ctx gctx;
5379 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
5380 OMP_PARALLEL_COMBINED (expr)
5381 ? ORT_COMBINED_PARALLEL
5384 push_gimplify_context (&gctx);
5386 gimplify_stmt (&OMP_PARALLEL_BODY (expr));
5388 if (TREE_CODE (OMP_PARALLEL_BODY (expr)) == BIND_EXPR)
5389 pop_gimplify_context (OMP_PARALLEL_BODY (expr));
5391 pop_gimplify_context (NULL_TREE);
5393 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
5398 /* Gimplify the contents of an OMP_TASK statement. This involves
5399 gimplification of the body, as well as scanning the body for used
5400 variables. We need to do this scan now, because variable-sized
5401 decls will be decomposed during gimplification. */
5403 static enum gimplify_status
5404 gimplify_omp_task (tree *expr_p, tree *pre_p)
5406 tree expr = *expr_p;
5407 struct gimplify_ctx gctx;
5409 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p, ORT_TASK);
5411 push_gimplify_context (&gctx);
5413 gimplify_stmt (&OMP_TASK_BODY (expr));
5415 if (TREE_CODE (OMP_TASK_BODY (expr)) == BIND_EXPR)
5416 pop_gimplify_context (OMP_TASK_BODY (expr));
5418 pop_gimplify_context (NULL_TREE);
5420 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr));
5425 /* Gimplify the gross structure of an OMP_FOR statement. */
5427 static enum gimplify_status
5428 gimplify_omp_for (tree *expr_p, tree *pre_p)
5430 tree for_stmt, decl, var, t, bodylist;
5431 enum gimplify_status ret = GS_OK;
5432 tree body, init_decl = NULL_TREE;
5437 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p,
5440 /* If OMP_FOR is re-gimplified, ensure all variables in pre-body
5442 gimplify_stmt (&OMP_FOR_PRE_BODY (for_stmt));
5444 bodylist = alloc_stmt_list ();
5446 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
5447 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
5448 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
5449 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
5450 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
5452 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
5453 gcc_assert (TREE_CODE (t) == MODIFY_EXPR
5454 || TREE_CODE (t) == GIMPLE_MODIFY_STMT);
5455 decl = GENERIC_TREE_OPERAND (t, 0);
5456 gcc_assert (DECL_P (decl));
5457 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))
5458 || POINTER_TYPE_P (TREE_TYPE (decl)));
5460 /* Make sure the iteration variable is private. */
5461 if (omp_is_private (gimplify_omp_ctxp, decl))
5462 omp_notice_variable (gimplify_omp_ctxp, decl, true);
5464 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
5466 /* If DECL is not a gimple register, create a temporary variable to act
5467 as an iteration counter. This is valid, since DECL cannot be
5468 modified in the body of the loop. */
5469 if (!is_gimple_reg (decl))
5471 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
5472 GENERIC_TREE_OPERAND (t, 0) = var;
5474 init_decl = build_gimple_modify_stmt (decl, var);
5475 omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
5480 ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
5481 &OMP_FOR_PRE_BODY (for_stmt),
5482 NULL, is_gimple_val, fb_rvalue);
5484 tree_to_gimple_tuple (&TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i));
5486 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
5487 gcc_assert (COMPARISON_CLASS_P (t));
5488 gcc_assert (GENERIC_TREE_OPERAND (t, 0) == decl);
5489 TREE_OPERAND (t, 0) = var;
5491 ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
5492 &OMP_FOR_PRE_BODY (for_stmt),
5493 NULL, is_gimple_val, fb_rvalue);
5495 tree_to_gimple_tuple (&TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i));
5496 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
5497 switch (TREE_CODE (t))
5499 case PREINCREMENT_EXPR:
5500 case POSTINCREMENT_EXPR:
5501 t = build_int_cst (TREE_TYPE (decl), 1);
5502 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
5503 t = build_gimple_modify_stmt (var, t);
5504 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
5507 case PREDECREMENT_EXPR:
5508 case POSTDECREMENT_EXPR:
5509 t = build_int_cst (TREE_TYPE (decl), -1);
5510 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
5511 t = build_gimple_modify_stmt (var, t);
5512 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
5515 case GIMPLE_MODIFY_STMT:
5516 gcc_assert (GIMPLE_STMT_OPERAND (t, 0) == decl);
5517 GIMPLE_STMT_OPERAND (t, 0) = var;
5519 t = GIMPLE_STMT_OPERAND (t, 1);
5520 switch (TREE_CODE (t))
5523 if (TREE_OPERAND (t, 1) == decl)
5525 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
5526 TREE_OPERAND (t, 0) = var;
5532 case POINTER_PLUS_EXPR:
5533 gcc_assert (TREE_OPERAND (t, 0) == decl);
5534 TREE_OPERAND (t, 0) = var;
5540 ret |= gimplify_expr (&TREE_OPERAND (t, 1),
5541 &OMP_FOR_PRE_BODY (for_stmt),
5542 NULL, is_gimple_val, fb_rvalue);
5550 append_to_statement_list (init_decl, &bodylist);
5552 if (var != decl || TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1)
5555 for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
5556 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
5557 && OMP_CLAUSE_DECL (c) == decl
5558 && OMP_CLAUSE_LASTPRIVATE_STMT (c) == NULL)
5560 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
5561 gcc_assert (TREE_CODE (t) == GIMPLE_MODIFY_STMT);
5562 gcc_assert (GIMPLE_STMT_OPERAND (t, 0) == var);
5563 t = GIMPLE_STMT_OPERAND (t, 1);
5564 gcc_assert (TREE_CODE (t) == PLUS_EXPR
5565 || TREE_CODE (t) == MINUS_EXPR
5566 || TREE_CODE (t) == POINTER_PLUS_EXPR);
5567 gcc_assert (TREE_OPERAND (t, 0) == var);
5568 t = build2 (TREE_CODE (t), TREE_TYPE (decl), decl,
5569 TREE_OPERAND (t, 1));
5570 OMP_CLAUSE_LASTPRIVATE_STMT (c)
5571 = build_gimple_modify_stmt (decl, t);
5576 body = OMP_FOR_BODY (for_stmt);
5577 gimplify_to_stmt_list (&body);
5578 append_to_statement_list (body, &bodylist);
5579 OMP_FOR_BODY (for_stmt) = bodylist;
5580 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
5582 return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR;
5585 /* Gimplify the gross structure of other OpenMP worksharing constructs.
5586 In particular, OMP_SECTIONS and OMP_SINGLE. */
5588 static enum gimplify_status
5589 gimplify_omp_workshare (tree *expr_p, tree *pre_p)
5591 tree stmt = *expr_p;
5593 gimplify_scan_omp_clauses (&OMP_CLAUSES (stmt), pre_p, ORT_WORKSHARE);
5594 gimplify_to_stmt_list (&OMP_BODY (stmt));
5595 gimplify_adjust_omp_clauses (&OMP_CLAUSES (stmt));
5600 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
5601 stabilized the lhs of the atomic operation as *ADDR. Return true if
5602 EXPR is this stabilized form. */
5605 goa_lhs_expr_p (tree expr, tree addr)
5607 /* Also include casts to other type variants. The C front end is fond
5608 of adding these for e.g. volatile variables. This is like
5609 STRIP_TYPE_NOPS but includes the main variant lookup. */
5610 while ((CONVERT_EXPR_P (expr)
5611 || TREE_CODE (expr) == NON_LVALUE_EXPR)
5612 && TREE_OPERAND (expr, 0) != error_mark_node
5613 && (TYPE_MAIN_VARIANT (TREE_TYPE (expr))
5614 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (expr, 0)))))
5615 expr = TREE_OPERAND (expr, 0);
5617 if (TREE_CODE (expr) == INDIRECT_REF)
5619 expr = TREE_OPERAND (expr, 0);
5621 && (CONVERT_EXPR_P (expr)
5622 || TREE_CODE (expr) == NON_LVALUE_EXPR)
5623 && TREE_CODE (expr) == TREE_CODE (addr)
5624 && TYPE_MAIN_VARIANT (TREE_TYPE (expr))
5625 == TYPE_MAIN_VARIANT (TREE_TYPE (addr)))
5627 expr = TREE_OPERAND (expr, 0);
5628 addr = TREE_OPERAND (addr, 0);
5632 return (TREE_CODE (addr) == ADDR_EXPR
5633 && TREE_CODE (expr) == ADDR_EXPR
5634 && TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
5636 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
5641 /* Walk *EXPR_P and replace
5642 appearances of *LHS_ADDR with LHS_VAR. If an expression does not involve
5643 the lhs, evaluate it into a temporary. Return 1 if the lhs appeared as
5644 a subexpression, 0 if it did not, or -1 if an error was encountered. */
5647 goa_stabilize_expr (tree *expr_p, tree *pre_p, tree lhs_addr, tree lhs_var)
5649 tree expr = *expr_p;
5652 if (goa_lhs_expr_p (expr, lhs_addr))
5657 if (is_gimple_val (expr))
5661 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
5664 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
5667 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
5676 enum gimplify_status gs;
5677 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
5678 if (gs != GS_ALL_DONE)
5685 /* Gimplify an OMP_ATOMIC statement. */
5687 static enum gimplify_status
5688 gimplify_omp_atomic (tree *expr_p, tree *pre_p)
5690 tree addr = TREE_OPERAND (*expr_p, 0);
5691 tree rhs = TREE_OPERAND (*expr_p, 1);
5692 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
5693 tree tmp_load, load, store;
5695 tmp_load = create_tmp_var (type, NULL);
5696 if (goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
5699 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
5703 load = build2 (OMP_ATOMIC_LOAD, void_type_node, tmp_load, addr);
5704 append_to_statement_list (load, pre_p);
5705 if (gimplify_expr (&rhs, pre_p, NULL, is_gimple_val, fb_rvalue)
5708 store = build1 (OMP_ATOMIC_STORE, void_type_node, rhs);
5715 /* Gimplifies the expression tree pointed to by EXPR_P. Return 0 if
5716 gimplification failed.
5718 PRE_P points to the list where side effects that must happen before
5719 EXPR should be stored.
5721 POST_P points to the list where side effects that must happen after
5722 EXPR should be stored, or NULL if there is no suitable list. In
5723 that case, we copy the result to a temporary, emit the
5724 post-effects, and then return the temporary.
5726 GIMPLE_TEST_F points to a function that takes a tree T and
5727 returns nonzero if T is in the GIMPLE form requested by the
5728 caller. The GIMPLE predicates are in tree-gimple.c.
5730 This test is used twice. Before gimplification, the test is
5731 invoked to determine whether *EXPR_P is already gimple enough. If
5732 that fails, *EXPR_P is gimplified according to its code and
5733 GIMPLE_TEST_F is called again. If the test still fails, then a new
5734 temporary variable is created and assigned the value of the
5735 gimplified expression.
5737 FALLBACK tells the function what sort of a temporary we want. If the 1
5738 bit is set, an rvalue is OK. If the 2 bit is set, an lvalue is OK.
5739 If both are set, either is OK, but an lvalue is preferable.
5741 The return value is either GS_ERROR or GS_ALL_DONE, since this function
5742 iterates until solution. */
5744 enum gimplify_status
5745 gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
5746 bool (* gimple_test_f) (tree), fallback_t fallback)
5749 tree internal_pre = NULL_TREE;
5750 tree internal_post = NULL_TREE;
5752 int is_statement = (pre_p == NULL);
5753 location_t saved_location;
5754 enum gimplify_status ret;
5756 save_expr = *expr_p;
5757 if (save_expr == NULL_TREE)
5760 /* We used to check the predicate here and return immediately if it
5761 succeeds. This is wrong; the design is for gimplification to be
5762 idempotent, and for the predicates to only test for valid forms, not
5763 whether they are fully simplified. */
5765 /* Set up our internal queues if needed. */
5767 pre_p = &internal_pre;
5769 post_p = &internal_post;
5771 saved_location = input_location;
5772 if (save_expr != error_mark_node
5773 && EXPR_HAS_LOCATION (*expr_p))
5774 input_location = EXPR_LOCATION (*expr_p);
5776 /* Loop over the specific gimplifiers until the toplevel node
5777 remains the same. */
5780 /* Strip away as many useless type conversions as possible
5782 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
5784 /* Remember the expr. */
5785 save_expr = *expr_p;
5787 /* Die, die, die, my darling. */
5788 if (save_expr == error_mark_node
5789 || (!GIMPLE_STMT_P (save_expr)
5790 && TREE_TYPE (save_expr)
5791 && TREE_TYPE (save_expr) == error_mark_node))
5797 /* Do any language-specific gimplification. */
5798 ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p);
5801 if (*expr_p == NULL_TREE)
5803 if (*expr_p != save_expr)
5806 else if (ret != GS_UNHANDLED)
5810 switch (TREE_CODE (*expr_p))
5812 /* First deal with the special cases. */
5814 case POSTINCREMENT_EXPR:
5815 case POSTDECREMENT_EXPR:
5816 case PREINCREMENT_EXPR:
5817 case PREDECREMENT_EXPR:
5818 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
5819 fallback != fb_none);
5823 case ARRAY_RANGE_REF:
5827 case VIEW_CONVERT_EXPR:
5828 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
5829 fallback ? fallback : fb_rvalue);
5833 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
5834 /* C99 code may assign to an array in a structure value of a
5835 conditional expression, and this has undefined behavior
5836 only on execution, so create a temporary if an lvalue is
5838 if (fallback == fb_lvalue)
5840 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5841 mark_addressable (*expr_p);
5846 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
5847 /* C99 code may assign to an array in a structure returned
5848 from a function, and this has undefined behavior only on
5849 execution, so create a temporary if an lvalue is
5851 if (fallback == fb_lvalue)
5853 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5854 mark_addressable (*expr_p);
5862 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
5866 case GIMPLE_MODIFY_STMT:
5868 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
5869 fallback != fb_none);
5873 /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer
5875 if (TREE_CODE (*expr_p) == INIT_EXPR)
5876 TREE_SET_CODE (*expr_p, MODIFY_EXPR);
5878 /* Convert MODIFY_EXPR to GIMPLE_MODIFY_STMT. */
5879 if (TREE_CODE (*expr_p) == MODIFY_EXPR)
5880 tree_to_gimple_tuple (expr_p);
5885 case TRUTH_ANDIF_EXPR:
5886 case TRUTH_ORIF_EXPR:
5887 ret = gimplify_boolean_expr (expr_p);
5890 case TRUTH_NOT_EXPR:
5891 if (TREE_CODE (TREE_TYPE (*expr_p)) != BOOLEAN_TYPE)
5893 tree type = TREE_TYPE (*expr_p);
5894 *expr_p = fold_convert (type, gimple_boolify (*expr_p));
5899 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5900 is_gimple_val, fb_rvalue);
5901 recalculate_side_effects (*expr_p);
5905 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
5909 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
5913 if (IS_EMPTY_STMT (*expr_p))
5919 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
5920 || fallback == fb_none)
5922 /* Just strip a conversion to void (or in void context) and
5924 *expr_p = TREE_OPERAND (*expr_p, 0);
5928 ret = gimplify_conversion (expr_p);
5929 if (ret == GS_ERROR)
5931 if (*expr_p != save_expr)
5935 case FIX_TRUNC_EXPR:
5936 /* unary_expr: ... | '(' cast ')' val | ... */
5937 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5938 is_gimple_val, fb_rvalue);
5939 recalculate_side_effects (*expr_p);
5943 *expr_p = fold_indirect_ref (*expr_p);
5944 if (*expr_p != save_expr)
5946 /* else fall through. */
5947 case ALIGN_INDIRECT_REF:
5948 case MISALIGNED_INDIRECT_REF:
5949 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5950 is_gimple_reg, fb_rvalue);
5951 recalculate_side_effects (*expr_p);
5954 /* Constants need not be gimplified. */
5965 /* If we require an lvalue, such as for ADDR_EXPR, retain the
5966 CONST_DECL node. Otherwise the decl is replaceable by its
5968 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
5969 if (fallback & fb_lvalue)
5972 *expr_p = DECL_INITIAL (*expr_p);
5976 ret = gimplify_decl_expr (expr_p);
5980 /* FIXME make this a decl. */
5985 ret = gimplify_bind_expr (expr_p, pre_p);
5989 ret = gimplify_loop_expr (expr_p, pre_p);
5993 ret = gimplify_switch_expr (expr_p, pre_p);
5997 ret = gimplify_exit_expr (expr_p);
6001 /* If the target is not LABEL, then it is a computed jump
6002 and the target needs to be gimplified. */
6003 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
6004 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
6005 NULL, is_gimple_val, fb_rvalue);
6008 /* Predictions are always gimplified. */
6014 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
6015 == current_function_decl);
6018 case CASE_LABEL_EXPR:
6019 ret = gimplify_case_label_expr (expr_p);
6023 ret = gimplify_return_expr (*expr_p, pre_p);
6027 /* Don't reduce this in place; let gimplify_init_constructor work its
6028 magic. Buf if we're just elaborating this for side effects, just
6029 gimplify any element that has side-effects. */
6030 if (fallback == fb_none)
6032 unsigned HOST_WIDE_INT ix;
6033 constructor_elt *ce;
6034 tree temp = NULL_TREE;
6036 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
6039 if (TREE_SIDE_EFFECTS (ce->value))
6040 append_to_statement_list (ce->value, &temp);
6045 /* C99 code may assign to an array in a constructed
6046 structure or union, and this has undefined behavior only
6047 on execution, so create a temporary if an lvalue is
6049 else if (fallback == fb_lvalue)
6051 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6052 mark_addressable (*expr_p);
6058 /* The following are special cases that are not handled by the
6059 original GIMPLE grammar. */
6061 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
6064 ret = gimplify_save_expr (expr_p, pre_p, post_p);
6069 enum gimplify_status r0, r1, r2;
6071 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
6072 is_gimple_lvalue, fb_either);
6073 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
6074 is_gimple_val, fb_rvalue);
6075 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p,
6076 is_gimple_val, fb_rvalue);
6077 recalculate_side_effects (*expr_p);
6079 ret = MIN (r0, MIN (r1, r2));
6083 case NON_LVALUE_EXPR:
6084 /* This should have been stripped above. */
6088 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
6091 case TRY_FINALLY_EXPR:
6092 case TRY_CATCH_EXPR:
6093 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0));
6094 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1));
6098 case CLEANUP_POINT_EXPR:
6099 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
6103 ret = gimplify_target_expr (expr_p, pre_p, post_p);
6107 gimplify_to_stmt_list (&CATCH_BODY (*expr_p));
6111 case EH_FILTER_EXPR:
6112 gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p));
6116 case CHANGE_DYNAMIC_TYPE_EXPR:
6117 ret = gimplify_expr (&CHANGE_DYNAMIC_TYPE_LOCATION (*expr_p),
6118 pre_p, post_p, is_gimple_reg, fb_lvalue);
6123 enum gimplify_status r0, r1;
6124 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p,
6125 is_gimple_val, fb_rvalue);
6126 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
6127 is_gimple_val, fb_rvalue);
6133 /* We get here when taking the address of a label. We mark
6134 the label as "forced"; meaning it can never be removed and
6135 it is a potential target for any computed goto. */
6136 FORCED_LABEL (*expr_p) = 1;
6140 case STATEMENT_LIST:
6141 ret = gimplify_statement_list (expr_p, pre_p);
6144 case WITH_SIZE_EXPR:
6146 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
6147 post_p == &internal_post ? NULL : post_p,
6148 gimple_test_f, fallback);
6149 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
6150 is_gimple_val, fb_rvalue);
6156 ret = gimplify_var_or_parm_decl (expr_p);
6160 /* When within an OpenMP context, notice uses of variables. */
6161 if (gimplify_omp_ctxp)
6162 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
6167 /* Allow callbacks into the gimplifier during optimization. */
6172 ret = gimplify_omp_parallel (expr_p, pre_p);
6176 ret = gimplify_omp_task (expr_p, pre_p);
6180 ret = gimplify_omp_for (expr_p, pre_p);
6185 ret = gimplify_omp_workshare (expr_p, pre_p);
6192 gimplify_to_stmt_list (&OMP_BODY (*expr_p));
6196 ret = gimplify_omp_atomic (expr_p, pre_p);
6201 case OMP_ATOMIC_STORE:
6202 case OMP_SECTIONS_SWITCH:
6206 case OMP_ATOMIC_LOAD:
6207 if (gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, NULL,
6208 is_gimple_val, fb_rvalue) != GS_ALL_DONE)
6214 case POINTER_PLUS_EXPR:
6215 /* Convert ((type *)A)+offset into &A->field_of_type_and_offset.
6216 The second is gimple immediate saving a need for extra statement.
6218 if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
6219 && (tmp = maybe_fold_offset_to_reference
6220 (TREE_OPERAND (*expr_p, 0), TREE_OPERAND (*expr_p, 1),
6221 TREE_TYPE (TREE_TYPE (*expr_p)))))
6223 tree ptr_type = build_pointer_type (TREE_TYPE (tmp));
6224 if (useless_type_conversion_p (TREE_TYPE (*expr_p), ptr_type))
6226 *expr_p = build_fold_addr_expr_with_type (tmp, ptr_type);
6230 /* Convert (void *)&a + 4 into (void *)&a[1]. */
6231 if (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == NOP_EXPR
6232 && TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
6233 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*expr_p,
6235 && (tmp = maybe_fold_offset_to_reference
6236 (TREE_OPERAND (TREE_OPERAND (*expr_p, 0), 0),
6237 TREE_OPERAND (*expr_p, 1),
6238 TREE_TYPE (TREE_TYPE
6239 (TREE_OPERAND (TREE_OPERAND (*expr_p, 0),
6242 tmp = build_fold_addr_expr (tmp);
6243 *expr_p = fold_convert (TREE_TYPE (*expr_p), tmp);
6248 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
6250 case tcc_comparison:
6251 /* Handle comparison of objects of non scalar mode aggregates
6252 with a call to memcmp. It would be nice to only have to do
6253 this for variable-sized objects, but then we'd have to allow
6254 the same nest of reference nodes we allow for MODIFY_EXPR and
6257 Compare scalar mode aggregates as scalar mode values. Using
6258 memcmp for them would be very inefficient at best, and is
6259 plain wrong if bitfields are involved. */
6262 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
6264 if (!AGGREGATE_TYPE_P (type))
6266 else if (TYPE_MODE (type) != BLKmode)
6267 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
6269 ret = gimplify_variable_sized_compare (expr_p);
6274 /* If *EXPR_P does not need to be special-cased, handle it
6275 according to its class. */
6277 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
6278 post_p, is_gimple_val, fb_rvalue);
6284 enum gimplify_status r0, r1;
6286 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
6287 post_p, is_gimple_val, fb_rvalue);
6288 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
6289 post_p, is_gimple_val, fb_rvalue);
6295 case tcc_declaration:
6298 goto dont_recalculate;
6301 gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
6302 || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
6303 || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
6307 recalculate_side_effects (*expr_p);
6312 /* If we replaced *expr_p, gimplify again. */
6313 if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
6316 while (ret == GS_OK);
6318 /* If we encountered an error_mark somewhere nested inside, either
6319 stub out the statement or propagate the error back out. */
6320 if (ret == GS_ERROR)
6327 /* This was only valid as a return value from the langhook, which
6328 we handled. Make sure it doesn't escape from any other context. */
6329 gcc_assert (ret != GS_UNHANDLED);
6331 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
6333 /* We aren't looking for a value, and we don't have a valid
6334 statement. If it doesn't have side-effects, throw it away. */
6335 if (!TREE_SIDE_EFFECTS (*expr_p))
6337 else if (!TREE_THIS_VOLATILE (*expr_p))
6339 /* This is probably a _REF that contains something nested that
6340 has side effects. Recurse through the operands to find it. */
6341 enum tree_code code = TREE_CODE (*expr_p);
6348 case VIEW_CONVERT_EXPR:
6349 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
6350 gimple_test_f, fallback);
6354 case ARRAY_RANGE_REF:
6355 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
6356 gimple_test_f, fallback);
6357 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
6358 gimple_test_f, fallback);
6362 /* Anything else with side-effects must be converted to
6363 a valid statement before we get here. */
6369 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
6370 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
6372 /* Historically, the compiler has treated a bare reference
6373 to a non-BLKmode volatile lvalue as forcing a load. */
6374 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
6375 /* Normally, we do not want to create a temporary for a
6376 TREE_ADDRESSABLE type because such a type should not be
6377 copied by bitwise-assignment. However, we make an
6378 exception here, as all we are doing here is ensuring that
6379 we read the bytes that make up the type. We use
6380 create_tmp_var_raw because create_tmp_var will abort when
6381 given a TREE_ADDRESSABLE type. */
6382 tree tmp = create_tmp_var_raw (type, "vol");
6383 gimple_add_tmp_var (tmp);
6384 *expr_p = build_gimple_modify_stmt (tmp, *expr_p);
6387 /* We can't do anything useful with a volatile reference to
6388 an incomplete type, so just throw it away. Likewise for
6389 a BLKmode type, since any implicit inner load should
6390 already have been turned into an explicit one by the
6391 gimplification process. */
6395 /* If we are gimplifying at the statement level, we're done. Tack
6396 everything together and replace the original statement with the
6398 if (fallback == fb_none || is_statement)
6400 if (internal_pre || internal_post)
6402 append_to_statement_list (*expr_p, &internal_pre);
6403 append_to_statement_list (internal_post, &internal_pre);
6404 annotate_all_with_locus (&internal_pre, input_location);
6405 *expr_p = internal_pre;
6409 else if (TREE_CODE (*expr_p) == STATEMENT_LIST)
6410 annotate_all_with_locus (expr_p, input_location);
6412 annotate_one_with_locus (*expr_p, input_location);
6416 /* Otherwise we're gimplifying a subexpression, so the resulting value is
6419 /* If it's sufficiently simple already, we're done. Unless we are
6420 handling some post-effects internally; if that's the case, we need to
6421 copy into a temp before adding the post-effects to the tree. */
6422 if (!internal_post && (*gimple_test_f) (*expr_p))
6425 /* Otherwise, we need to create a new temporary for the gimplified
6428 /* We can't return an lvalue if we have an internal postqueue. The
6429 object the lvalue refers to would (probably) be modified by the
6430 postqueue; we need to copy the value out first, which means an
6432 if ((fallback & fb_lvalue) && !internal_post
6433 && is_gimple_addressable (*expr_p))
6435 /* An lvalue will do. Take the address of the expression, store it
6436 in a temporary, and replace the expression with an INDIRECT_REF of
6438 tmp = build_fold_addr_expr (*expr_p);
6439 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
6440 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
6442 else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_rhs (*expr_p))
6444 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
6446 /* An rvalue will do. Assign the gimplified expression into a new
6447 temporary TMP and replace the original expression with TMP. */
6449 if (internal_post || (fallback & fb_lvalue))
6450 /* The postqueue might change the value of the expression between
6451 the initialization and use of the temporary, so we can't use a
6452 formal temp. FIXME do we care? */
6453 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6455 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
6457 if (TREE_CODE (*expr_p) != SSA_NAME)
6458 DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1;
6462 #ifdef ENABLE_CHECKING
6463 if (!(fallback & fb_mayfail))
6465 fprintf (stderr, "gimplification failed:\n");
6466 print_generic_expr (stderr, *expr_p, 0);
6467 debug_tree (*expr_p);
6468 internal_error ("gimplification failed");
6471 gcc_assert (fallback & fb_mayfail);
6472 /* If this is an asm statement, and the user asked for the
6473 impossible, don't die. Fail and let gimplify_asm_expr
6479 /* Make sure the temporary matches our predicate. */
6480 gcc_assert ((*gimple_test_f) (*expr_p));
6484 annotate_all_with_locus (&internal_post, input_location);
6485 append_to_statement_list (internal_post, pre_p);
6489 input_location = saved_location;
6493 /* Look through TYPE for variable-sized objects and gimplify each such
6494 size that we find. Add to LIST_P any statements generated. */
6497 gimplify_type_sizes (tree type, tree *list_p)
6501 if (type == NULL || type == error_mark_node)
6504 /* We first do the main variant, then copy into any other variants. */
6505 type = TYPE_MAIN_VARIANT (type);
6507 /* Avoid infinite recursion. */
6508 if (TYPE_SIZES_GIMPLIFIED (type))
6511 TYPE_SIZES_GIMPLIFIED (type) = 1;
6513 switch (TREE_CODE (type))
6519 case FIXED_POINT_TYPE:
6520 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
6521 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
6523 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6525 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
6526 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
6531 /* These types may not have declarations, so handle them here. */
6532 gimplify_type_sizes (TREE_TYPE (type), list_p);
6533 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
6538 case QUAL_UNION_TYPE:
6539 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6540 if (TREE_CODE (field) == FIELD_DECL)
6542 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
6543 gimplify_type_sizes (TREE_TYPE (field), list_p);
6548 case REFERENCE_TYPE:
6549 /* We used to recurse on the pointed-to type here, which turned out to
6550 be incorrect because its definition might refer to variables not
6551 yet initialized at this point if a forward declaration is involved.
6553 It was actually useful for anonymous pointed-to types to ensure
6554 that the sizes evaluation dominates every possible later use of the
6555 values. Restricting to such types here would be safe since there
6556 is no possible forward declaration around, but would introduce an
6557 undesirable middle-end semantic to anonymity. We then defer to
6558 front-ends the responsibility of ensuring that the sizes are
6559 evaluated both early and late enough, e.g. by attaching artificial
6560 type declarations to the tree. */
6567 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
6568 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
6570 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6572 TYPE_SIZE (t) = TYPE_SIZE (type);
6573 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
6574 TYPE_SIZES_GIMPLIFIED (t) = 1;
6578 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
6579 a size or position, has had all of its SAVE_EXPRs evaluated.
6580 We add any required statements to STMT_P. */
6583 gimplify_one_sizepos (tree *expr_p, tree *stmt_p)
6585 tree type, expr = *expr_p;
6587 /* We don't do anything if the value isn't there, is constant, or contains
6588 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
6589 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
6590 will want to replace it with a new variable, but that will cause problems
6591 if this type is from outside the function. It's OK to have that here. */
6592 if (expr == NULL_TREE || TREE_CONSTANT (expr)
6593 || TREE_CODE (expr) == VAR_DECL
6594 || CONTAINS_PLACEHOLDER_P (expr))
6597 type = TREE_TYPE (expr);
6598 *expr_p = unshare_expr (expr);
6600 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
6603 /* Verify that we've an exact type match with the original expression.
6604 In particular, we do not wish to drop a "sizetype" in favour of a
6605 type of similar dimensions. We don't want to pollute the generic
6606 type-stripping code with this knowledge because it doesn't matter
6607 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
6608 and friends retain their "sizetype-ness". */
6609 if (TREE_TYPE (expr) != type
6610 && TREE_CODE (type) == INTEGER_TYPE
6611 && TYPE_IS_SIZETYPE (type))
6615 *expr_p = create_tmp_var (type, NULL);
6616 tmp = build1 (NOP_EXPR, type, expr);
6617 tmp = build_gimple_modify_stmt (*expr_p, tmp);
6618 if (EXPR_HAS_LOCATION (expr))
6619 SET_EXPR_LOCUS (tmp, EXPR_LOCUS (expr));
6621 SET_EXPR_LOCATION (tmp, input_location);
6623 gimplify_and_add (tmp, stmt_p);
6628 /* Gimplify the body of statements pointed to by BODY_P. FNDECL is the
6629 function decl containing BODY. */
6632 gimplify_body (tree *body_p, tree fndecl, bool do_parms)
6634 location_t saved_location = input_location;
6635 tree body, parm_stmts;
6636 struct gimplify_ctx gctx;
6638 timevar_push (TV_TREE_GIMPLIFY);
6640 gcc_assert (gimplify_ctxp == NULL);
6641 push_gimplify_context (&gctx);
6643 /* Unshare most shared trees in the body and in that of any nested functions.
6644 It would seem we don't have to do this for nested functions because
6645 they are supposed to be output and then the outer function gimplified
6646 first, but the g++ front end doesn't always do it that way. */
6647 unshare_body (body_p, fndecl);
6648 unvisit_body (body_p, fndecl);
6650 /* Make sure input_location isn't set to something weird. */
6651 input_location = DECL_SOURCE_LOCATION (fndecl);
6653 /* Resolve callee-copies. This has to be done before processing
6654 the body so that DECL_VALUE_EXPR gets processed correctly. */
6655 parm_stmts = do_parms ? gimplify_parameters () : NULL;
6657 /* Gimplify the function's body. */
6658 gimplify_stmt (body_p);
6662 body = alloc_stmt_list ();
6663 else if (TREE_CODE (body) == STATEMENT_LIST)
6665 tree t = expr_only (*body_p);
6670 /* If there isn't an outer BIND_EXPR, add one. */
6671 if (TREE_CODE (body) != BIND_EXPR)
6673 tree b = build3 (BIND_EXPR, void_type_node, NULL_TREE,
6674 NULL_TREE, NULL_TREE);
6675 TREE_SIDE_EFFECTS (b) = 1;
6676 append_to_statement_list_force (body, &BIND_EXPR_BODY (b));
6680 /* If we had callee-copies statements, insert them at the beginning
6684 append_to_statement_list_force (BIND_EXPR_BODY (body), &parm_stmts);
6685 BIND_EXPR_BODY (body) = parm_stmts;
6688 /* Unshare again, in case gimplification was sloppy. */
6689 unshare_all_trees (body);
6693 pop_gimplify_context (body);
6694 gcc_assert (gimplify_ctxp == NULL);
6696 #ifdef ENABLE_TYPES_CHECKING
6697 if (!errorcount && !sorrycount)
6698 verify_gimple_1 (BIND_EXPR_BODY (*body_p));
6701 timevar_pop (TV_TREE_GIMPLIFY);
6702 input_location = saved_location;
6705 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
6706 node for the function we want to gimplify. */
6709 gimplify_function_tree (tree fndecl)
6711 tree oldfn, parm, ret;
6713 oldfn = current_function_decl;
6714 current_function_decl = fndecl;
6715 if (DECL_STRUCT_FUNCTION (fndecl))
6716 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
6718 push_struct_function (fndecl);
6720 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm))
6722 /* Preliminarily mark non-addressed complex variables as eligible
6723 for promotion to gimple registers. We'll transform their uses
6725 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
6726 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
6727 && !TREE_THIS_VOLATILE (parm)
6728 && !needs_to_live_in_memory (parm))
6729 DECL_GIMPLE_REG_P (parm) = 1;
6732 ret = DECL_RESULT (fndecl);
6733 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
6734 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
6735 && !needs_to_live_in_memory (ret))
6736 DECL_GIMPLE_REG_P (ret) = 1;
6738 gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true);
6740 /* If we're instrumenting function entry/exit, then prepend the call to
6741 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
6742 catch the exit hook. */
6743 /* ??? Add some way to ignore exceptions for this TFE. */
6744 if (flag_instrument_function_entry_exit
6745 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)
6746 && !flag_instrument_functions_exclude_p (fndecl))
6750 tf = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
6751 TREE_SIDE_EFFECTS (tf) = 1;
6752 x = DECL_SAVED_TREE (fndecl);
6753 append_to_statement_list (x, &TREE_OPERAND (tf, 0));
6754 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
6755 x = build_call_expr (x, 0);
6756 append_to_statement_list (x, &TREE_OPERAND (tf, 1));
6758 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
6759 TREE_SIDE_EFFECTS (bind) = 1;
6760 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
6761 x = build_call_expr (x, 0);
6762 append_to_statement_list (x, &BIND_EXPR_BODY (bind));
6763 append_to_statement_list (tf, &BIND_EXPR_BODY (bind));
6765 DECL_SAVED_TREE (fndecl) = bind;
6768 current_function_decl = oldfn;
6772 /* Expands EXPR to list of gimple statements STMTS. If SIMPLE is true,
6773 force the result to be either ssa_name or an invariant, otherwise
6774 just force it to be a rhs expression. If VAR is not NULL, make the
6775 base variable of the final destination be VAR if suitable. */
6778 force_gimple_operand (tree expr, tree *stmts, bool simple, tree var)
6781 enum gimplify_status ret;
6782 gimple_predicate gimple_test_f;
6783 struct gimplify_ctx gctx;
6787 if (is_gimple_val (expr))
6790 gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs;
6792 push_gimplify_context (&gctx);
6793 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
6794 gimplify_ctxp->allow_rhs_cond_expr = true;
6797 expr = build_gimple_modify_stmt (var, expr);
6799 if (TREE_CODE (expr) != GIMPLE_MODIFY_STMT
6800 && TREE_TYPE (expr) == void_type_node)
6802 gimplify_and_add (expr, stmts);
6807 ret = gimplify_expr (&expr, stmts, NULL,
6808 gimple_test_f, fb_rvalue);
6809 gcc_assert (ret != GS_ERROR);
6812 if (gimple_referenced_vars (cfun))
6814 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
6815 add_referenced_var (t);
6818 pop_gimplify_context (NULL);
6823 /* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR. If
6824 some statements are produced, emits them at BSI. If BEFORE is true.
6825 the statements are appended before BSI, otherwise they are appended after
6826 it. M specifies the way BSI moves after insertion (BSI_SAME_STMT or
6827 BSI_CONTINUE_LINKING are the usual values). */
6830 force_gimple_operand_bsi (block_stmt_iterator *bsi, tree expr,
6831 bool simple_p, tree var, bool before,
6832 enum bsi_iterator_update m)
6836 expr = force_gimple_operand (expr, &stmts, simple_p, var);
6839 if (gimple_in_ssa_p (cfun))
6841 tree_stmt_iterator tsi;
6843 for (tsi = tsi_start (stmts); !tsi_end_p (tsi); tsi_next (&tsi))
6844 mark_symbols_for_renaming (tsi_stmt (tsi));
6848 bsi_insert_before (bsi, stmts, m);
6850 bsi_insert_after (bsi, stmts, m);
6856 #include "gt-gimplify.h"