aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.9/gcc/cp/cp-gimplify.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.9/gcc/cp/cp-gimplify.c')
-rw-r--r--gcc-4.9/gcc/cp/cp-gimplify.c1620
1 files changed, 1620 insertions, 0 deletions
diff --git a/gcc-4.9/gcc/cp/cp-gimplify.c b/gcc-4.9/gcc/cp/cp-gimplify.c
new file mode 100644
index 0000000..ef4b043
--- /dev/null
+++ b/gcc-4.9/gcc/cp/cp-gimplify.c
@@ -0,0 +1,1620 @@
+/* C++-specific tree lowering bits; see also c-gimplify.c and tree-gimple.c.
+
+ Copyright (C) 2002-2014 Free Software Foundation, Inc.
+ Contributed by Jason Merrill <jason@redhat.com>
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "stor-layout.h"
+#include "cp-tree.h"
+#include "c-family/c-common.h"
+#include "tree-iterator.h"
+#include "pointer-set.h"
+#include "basic-block.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-expr.h"
+#include "is-a.h"
+#include "gimple.h"
+#include "gimplify.h"
+#include "hashtab.h"
+#include "flags.h"
+#include "splay-tree.h"
+#include "target.h"
+#include "c-family/c-ubsan.h"
+#include "cilk.h"
+
+/* Forward declarations. */
+
+static tree cp_genericize_r (tree *, int *, void *);
+static void cp_genericize_tree (tree*);
+
+/* Local declarations. */
+
+enum bc_t { bc_break = 0, bc_continue = 1 };
+
+/* Stack of labels which are targets for "break" or "continue",
+ linked through TREE_CHAIN. */
+static tree bc_label[2];
+
+/* Begin a scope which can be exited by a break or continue statement. BC
+ indicates which.
+
+ Just creates a label with location LOCATION and pushes it into the current
+ context. */
+
+static tree
+begin_bc_block (enum bc_t bc, location_t location)
+{
+ tree label = create_artificial_label (location);
+ DECL_CHAIN (label) = bc_label[bc];
+ bc_label[bc] = label;
+ return label;
+}
+
+/* Finish a scope which can be exited by a break or continue statement.
+ LABEL was returned from the most recent call to begin_bc_block. BLOCK is
+ an expression for the contents of the scope.
+
+ If we saw a break (or continue) in the scope, append a LABEL_EXPR to
+ BLOCK. Otherwise, just forget the label. */
+
+static void
+finish_bc_block (tree *block, enum bc_t bc, tree label)
+{
+ gcc_assert (label == bc_label[bc]);
+
+ if (TREE_USED (label))
+ append_to_statement_list (build1 (LABEL_EXPR, void_type_node, label),
+ block);
+
+ bc_label[bc] = DECL_CHAIN (label);
+ DECL_CHAIN (label) = NULL_TREE;
+}
+
+/* Get the LABEL_EXPR to represent a break or continue statement
+ in the current block scope. BC indicates which. */
+
+static tree
+get_bc_label (enum bc_t bc)
+{
+ tree label = bc_label[bc];
+
+ /* Mark the label used for finish_bc_block. */
+ TREE_USED (label) = 1;
+ return label;
+}
+
+/* Genericize a TRY_BLOCK. */
+
+static void
+genericize_try_block (tree *stmt_p)
+{
+ tree body = TRY_STMTS (*stmt_p);
+ tree cleanup = TRY_HANDLERS (*stmt_p);
+
+ *stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup);
+}
+
+/* Genericize a HANDLER by converting to a CATCH_EXPR. */
+
+static void
+genericize_catch_block (tree *stmt_p)
+{
+ tree type = HANDLER_TYPE (*stmt_p);
+ tree body = HANDLER_BODY (*stmt_p);
+
+ /* FIXME should the caught type go in TREE_TYPE? */
+ *stmt_p = build2 (CATCH_EXPR, void_type_node, type, body);
+}
+
+/* A terser interface for building a representation of an exception
+ specification. */
+
+static tree
+build_gimple_eh_filter_tree (tree body, tree allowed, tree failure)
+{
+ tree t;
+
+ /* FIXME should the allowed types go in TREE_TYPE? */
+ t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
+ append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
+
+ t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
+ append_to_statement_list (body, &TREE_OPERAND (t, 0));
+
+ return t;
+}
+
+/* Genericize an EH_SPEC_BLOCK by converting it to a
+ TRY_CATCH_EXPR/EH_FILTER_EXPR pair. */
+
+static void
+genericize_eh_spec_block (tree *stmt_p)
+{
+ tree body = EH_SPEC_STMTS (*stmt_p);
+ tree allowed = EH_SPEC_RAISES (*stmt_p);
+ tree failure = build_call_n (call_unexpected_node, 1, build_exc_ptr ());
+
+ *stmt_p = build_gimple_eh_filter_tree (body, allowed, failure);
+ TREE_NO_WARNING (*stmt_p) = true;
+ TREE_NO_WARNING (TREE_OPERAND (*stmt_p, 1)) = true;
+}
+
+/* Genericize an IF_STMT by turning it into a COND_EXPR. */
+
+static void
+genericize_if_stmt (tree *stmt_p)
+{
+ tree stmt, cond, then_, else_;
+ location_t locus = EXPR_LOCATION (*stmt_p);
+
+ stmt = *stmt_p;
+ cond = IF_COND (stmt);
+ then_ = THEN_CLAUSE (stmt);
+ else_ = ELSE_CLAUSE (stmt);
+
+ if (!then_)
+ then_ = build_empty_stmt (locus);
+ if (!else_)
+ else_ = build_empty_stmt (locus);
+
+ if (integer_nonzerop (cond) && !TREE_SIDE_EFFECTS (else_))
+ stmt = then_;
+ else if (integer_zerop (cond) && !TREE_SIDE_EFFECTS (then_))
+ stmt = else_;
+ else
+ stmt = build3 (COND_EXPR, void_type_node, cond, then_, else_);
+ if (CAN_HAVE_LOCATION_P (stmt) && !EXPR_HAS_LOCATION (stmt))
+ SET_EXPR_LOCATION (stmt, locus);
+ *stmt_p = stmt;
+}
+
+/* Build a generic representation of one of the C loop forms. COND is the
+ loop condition or NULL_TREE. BODY is the (possibly compound) statement
+ controlled by the loop. INCR is the increment expression of a for-loop,
+ or NULL_TREE. COND_IS_FIRST indicates whether the condition is
+ evaluated before the loop body as in while and for loops, or after the
+ loop body as in do-while loops. */
+
+static void
+genericize_cp_loop (tree *stmt_p, location_t start_locus, tree cond, tree body,
+ tree incr, bool cond_is_first, int *walk_subtrees,
+ void *data)
+{
+ tree blab, clab;
+ tree entry = NULL, exit = NULL, t;
+ tree stmt_list = NULL;
+
+ blab = begin_bc_block (bc_break, start_locus);
+ clab = begin_bc_block (bc_continue, start_locus);
+
+ if (incr && EXPR_P (incr))
+ SET_EXPR_LOCATION (incr, start_locus);
+
+ cp_walk_tree (&cond, cp_genericize_r, data, NULL);
+ cp_walk_tree (&body, cp_genericize_r, data, NULL);
+ cp_walk_tree (&incr, cp_genericize_r, data, NULL);
+ *walk_subtrees = 0;
+
+ /* If condition is zero don't generate a loop construct. */
+ if (cond && integer_zerop (cond))
+ {
+ if (cond_is_first)
+ {
+ t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
+ get_bc_label (bc_break));
+ append_to_statement_list (t, &stmt_list);
+ }
+ }
+ else
+ {
+ /* Expand to gotos, just like c_finish_loop. TODO: Use LOOP_EXPR. */
+ tree top = build1 (LABEL_EXPR, void_type_node,
+ create_artificial_label (start_locus));
+
+ /* If we have an exit condition, then we build an IF with gotos either
+ out of the loop, or to the top of it. If there's no exit condition,
+ then we just build a jump back to the top. */
+ exit = build1 (GOTO_EXPR, void_type_node, LABEL_EXPR_LABEL (top));
+
+ if (cond && !integer_nonzerop (cond))
+ {
+ /* Canonicalize the loop condition to the end. This means
+ generating a branch to the loop condition. Reuse the
+ continue label, if possible. */
+ if (cond_is_first)
+ {
+ if (incr)
+ {
+ entry = build1 (LABEL_EXPR, void_type_node,
+ create_artificial_label (start_locus));
+ t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
+ LABEL_EXPR_LABEL (entry));
+ }
+ else
+ t = build1_loc (start_locus, GOTO_EXPR, void_type_node,
+ get_bc_label (bc_continue));
+ append_to_statement_list (t, &stmt_list);
+ }
+
+ t = build1 (GOTO_EXPR, void_type_node, get_bc_label (bc_break));
+ exit = fold_build3_loc (start_locus,
+ COND_EXPR, void_type_node, cond, exit, t);
+ }
+
+ append_to_statement_list (top, &stmt_list);
+ }
+
+ append_to_statement_list (body, &stmt_list);
+ finish_bc_block (&stmt_list, bc_continue, clab);
+ append_to_statement_list (incr, &stmt_list);
+ append_to_statement_list (entry, &stmt_list);
+ append_to_statement_list (exit, &stmt_list);
+ finish_bc_block (&stmt_list, bc_break, blab);
+
+ if (stmt_list == NULL_TREE)
+ stmt_list = build1 (NOP_EXPR, void_type_node, integer_zero_node);
+
+ *stmt_p = stmt_list;
+}
+
+/* Genericize a FOR_STMT node *STMT_P. */
+
+static void
+genericize_for_stmt (tree *stmt_p, int *walk_subtrees, void *data)
+{
+ tree stmt = *stmt_p;
+ tree expr = NULL;
+ tree loop;
+ tree init = FOR_INIT_STMT (stmt);
+
+ if (init)
+ {
+ cp_walk_tree (&init, cp_genericize_r, data, NULL);
+ append_to_statement_list (init, &expr);
+ }
+
+ genericize_cp_loop (&loop, EXPR_LOCATION (stmt), FOR_COND (stmt),
+ FOR_BODY (stmt), FOR_EXPR (stmt), 1, walk_subtrees, data);
+ append_to_statement_list (loop, &expr);
+ *stmt_p = expr;
+}
+
+/* Genericize a WHILE_STMT node *STMT_P. */
+
+static void
+genericize_while_stmt (tree *stmt_p, int *walk_subtrees, void *data)
+{
+ tree stmt = *stmt_p;
+ genericize_cp_loop (stmt_p, EXPR_LOCATION (stmt), WHILE_COND (stmt),
+ WHILE_BODY (stmt), NULL_TREE, 1, walk_subtrees, data);
+}
+
+/* Genericize a DO_STMT node *STMT_P. */
+
+static void
+genericize_do_stmt (tree *stmt_p, int *walk_subtrees, void *data)
+{
+ tree stmt = *stmt_p;
+ genericize_cp_loop (stmt_p, EXPR_LOCATION (stmt), DO_COND (stmt),
+ DO_BODY (stmt), NULL_TREE, 0, walk_subtrees, data);
+}
+
+/* Genericize a SWITCH_STMT node *STMT_P by turning it into a SWITCH_EXPR. */
+
+static void
+genericize_switch_stmt (tree *stmt_p, int *walk_subtrees, void *data)
+{
+ tree stmt = *stmt_p;
+ tree break_block, body, cond, type;
+ location_t stmt_locus = EXPR_LOCATION (stmt);
+
+ break_block = begin_bc_block (bc_break, stmt_locus);
+
+ body = SWITCH_STMT_BODY (stmt);
+ if (!body)
+ body = build_empty_stmt (stmt_locus);
+ cond = SWITCH_STMT_COND (stmt);
+ type = SWITCH_STMT_TYPE (stmt);
+
+ cp_walk_tree (&body, cp_genericize_r, data, NULL);
+ cp_walk_tree (&cond, cp_genericize_r, data, NULL);
+ cp_walk_tree (&type, cp_genericize_r, data, NULL);
+ *walk_subtrees = 0;
+
+ *stmt_p = build3_loc (stmt_locus, SWITCH_EXPR, type, cond, body, NULL_TREE);
+ finish_bc_block (stmt_p, bc_break, break_block);
+}
+
+/* Genericize a CONTINUE_STMT node *STMT_P. */
+
+static void
+genericize_continue_stmt (tree *stmt_p)
+{
+ tree stmt_list = NULL;
+ tree pred = build_predict_expr (PRED_CONTINUE, NOT_TAKEN);
+ tree label = get_bc_label (bc_continue);
+ location_t location = EXPR_LOCATION (*stmt_p);
+ tree jump = build1_loc (location, GOTO_EXPR, void_type_node, label);
+ append_to_statement_list (pred, &stmt_list);
+ append_to_statement_list (jump, &stmt_list);
+ *stmt_p = stmt_list;
+}
+
+/* Genericize a BREAK_STMT node *STMT_P. */
+
+static void
+genericize_break_stmt (tree *stmt_p)
+{
+ tree label = get_bc_label (bc_break);
+ location_t location = EXPR_LOCATION (*stmt_p);
+ *stmt_p = build1_loc (location, GOTO_EXPR, void_type_node, label);
+}
+
+/* Genericize a OMP_FOR node *STMT_P. */
+
+static void
+genericize_omp_for_stmt (tree *stmt_p, int *walk_subtrees, void *data)
+{
+ tree stmt = *stmt_p;
+ location_t locus = EXPR_LOCATION (stmt);
+ tree clab = begin_bc_block (bc_continue, locus);
+
+ cp_walk_tree (&OMP_FOR_BODY (stmt), cp_genericize_r, data, NULL);
+ cp_walk_tree (&OMP_FOR_CLAUSES (stmt), cp_genericize_r, data, NULL);
+ cp_walk_tree (&OMP_FOR_INIT (stmt), cp_genericize_r, data, NULL);
+ cp_walk_tree (&OMP_FOR_COND (stmt), cp_genericize_r, data, NULL);
+ cp_walk_tree (&OMP_FOR_INCR (stmt), cp_genericize_r, data, NULL);
+ cp_walk_tree (&OMP_FOR_PRE_BODY (stmt), cp_genericize_r, data, NULL);
+ *walk_subtrees = 0;
+
+ finish_bc_block (&OMP_FOR_BODY (stmt), bc_continue, clab);
+}
+
+/* Hook into the middle of gimplifying an OMP_FOR node. */
+
+static enum gimplify_status
+cp_gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
+{
+ tree for_stmt = *expr_p;
+ gimple_seq seq = NULL;
+
+ /* Protect ourselves from recursion. */
+ if (OMP_FOR_GIMPLIFYING_P (for_stmt))
+ return GS_UNHANDLED;
+ OMP_FOR_GIMPLIFYING_P (for_stmt) = 1;
+
+ gimplify_and_add (for_stmt, &seq);
+ gimple_seq_add_seq (pre_p, seq);
+
+ OMP_FOR_GIMPLIFYING_P (for_stmt) = 0;
+
+ return GS_ALL_DONE;
+}
+
+/* Gimplify an EXPR_STMT node. */
+
+static void
+gimplify_expr_stmt (tree *stmt_p)
+{
+ tree stmt = EXPR_STMT_EXPR (*stmt_p);
+
+ if (stmt == error_mark_node)
+ stmt = NULL;
+
+ /* Gimplification of a statement expression will nullify the
+ statement if all its side effects are moved to *PRE_P and *POST_P.
+
+ In this case we will not want to emit the gimplified statement.
+ However, we may still want to emit a warning, so we do that before
+ gimplification. */
+ if (stmt && warn_unused_value)
+ {
+ if (!TREE_SIDE_EFFECTS (stmt))
+ {
+ if (!IS_EMPTY_STMT (stmt)
+ && !VOID_TYPE_P (TREE_TYPE (stmt))
+ && !TREE_NO_WARNING (stmt))
+ warning (OPT_Wunused_value, "statement with no effect");
+ }
+ else
+ warn_if_unused_value (stmt, input_location);
+ }
+
+ if (stmt == NULL_TREE)
+ stmt = alloc_stmt_list ();
+
+ *stmt_p = stmt;
+}
+
+/* Gimplify initialization from an AGGR_INIT_EXPR. */
+
+static void
+cp_gimplify_init_expr (tree *expr_p)
+{
+ tree from = TREE_OPERAND (*expr_p, 1);
+ tree to = TREE_OPERAND (*expr_p, 0);
+ tree t;
+
+ /* What about code that pulls out the temp and uses it elsewhere? I
+ think that such code never uses the TARGET_EXPR as an initializer. If
+ I'm wrong, we'll abort because the temp won't have any RTL. In that
+ case, I guess we'll need to replace references somehow. */
+ if (TREE_CODE (from) == TARGET_EXPR)
+ from = TARGET_EXPR_INITIAL (from);
+
+ /* Look through any COMPOUND_EXPRs, since build_compound_expr pushes them
+ inside the TARGET_EXPR. */
+ for (t = from; t; )
+ {
+ tree sub = TREE_CODE (t) == COMPOUND_EXPR ? TREE_OPERAND (t, 0) : t;
+
+ /* If we are initializing from an AGGR_INIT_EXPR, drop the INIT_EXPR and
+ replace the slot operand with our target.
+
+ Should we add a target parm to gimplify_expr instead? No, as in this
+ case we want to replace the INIT_EXPR. */
+ if (TREE_CODE (sub) == AGGR_INIT_EXPR
+ || TREE_CODE (sub) == VEC_INIT_EXPR)
+ {
+ if (TREE_CODE (sub) == AGGR_INIT_EXPR)
+ AGGR_INIT_EXPR_SLOT (sub) = to;
+ else
+ VEC_INIT_EXPR_SLOT (sub) = to;
+ *expr_p = from;
+
+ /* The initialization is now a side-effect, so the container can
+ become void. */
+ if (from != sub)
+ TREE_TYPE (from) = void_type_node;
+ }
+
+ if (t == sub)
+ break;
+ else
+ t = TREE_OPERAND (t, 1);
+ }
+
+}
+
+/* Gimplify a MUST_NOT_THROW_EXPR. */
+
+static enum gimplify_status
+gimplify_must_not_throw_expr (tree *expr_p, gimple_seq *pre_p)
+{
+ tree stmt = *expr_p;
+ tree temp = voidify_wrapper_expr (stmt, NULL);
+ tree body = TREE_OPERAND (stmt, 0);
+ gimple_seq try_ = NULL;
+ gimple_seq catch_ = NULL;
+ gimple mnt;
+
+ gimplify_and_add (body, &try_);
+ mnt = gimple_build_eh_must_not_throw (terminate_node);
+ gimple_seq_add_stmt_without_update (&catch_, mnt);
+ mnt = gimple_build_try (try_, catch_, GIMPLE_TRY_CATCH);
+
+ gimple_seq_add_stmt_without_update (pre_p, mnt);
+ if (temp)
+ {
+ *expr_p = temp;
+ return GS_OK;
+ }
+
+ *expr_p = NULL;
+ return GS_ALL_DONE;
+}
+
+/* Do C++-specific gimplification. Args are as for gimplify_expr. */
+
+int
+cp_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
+{
+ int saved_stmts_are_full_exprs_p = 0;
+ enum tree_code code = TREE_CODE (*expr_p);
+ enum gimplify_status ret;
+
+ if (STATEMENT_CODE_P (code))
+ {
+ saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p ();
+ current_stmt_tree ()->stmts_are_full_exprs_p
+ = STMT_IS_FULL_EXPR_P (*expr_p);
+ }
+
+ switch (code)
+ {
+ case PTRMEM_CST:
+ *expr_p = cplus_expand_constant (*expr_p);
+ ret = GS_OK;
+ break;
+
+ case AGGR_INIT_EXPR:
+ simplify_aggr_init_expr (expr_p);
+ ret = GS_OK;
+ break;
+
+ case VEC_INIT_EXPR:
+ {
+ location_t loc = input_location;
+ tree init = VEC_INIT_EXPR_INIT (*expr_p);
+ int from_array = (init && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE);
+ gcc_assert (EXPR_HAS_LOCATION (*expr_p));
+ input_location = EXPR_LOCATION (*expr_p);
+ *expr_p = build_vec_init (VEC_INIT_EXPR_SLOT (*expr_p), NULL_TREE,
+ init, VEC_INIT_EXPR_VALUE_INIT (*expr_p),
+ from_array,
+ tf_warning_or_error);
+ cp_genericize_tree (expr_p);
+ ret = GS_OK;
+ input_location = loc;
+ }
+ break;
+
+ case THROW_EXPR:
+ /* FIXME communicate throw type to back end, probably by moving
+ THROW_EXPR into ../tree.def. */
+ *expr_p = TREE_OPERAND (*expr_p, 0);
+ ret = GS_OK;
+ break;
+
+ case MUST_NOT_THROW_EXPR:
+ ret = gimplify_must_not_throw_expr (expr_p, pre_p);
+ break;
+
+ /* We used to do this for MODIFY_EXPR as well, but that's unsafe; the
+ LHS of an assignment might also be involved in the RHS, as in bug
+ 25979. */
+ case INIT_EXPR:
+ if (fn_contains_cilk_spawn_p (cfun)
+ && cilk_detect_spawn_and_unwrap (expr_p)
+ && !seen_error ())
+ return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
+ cp_gimplify_init_expr (expr_p);
+ if (TREE_CODE (*expr_p) != INIT_EXPR)
+ return GS_OK;
+ /* Otherwise fall through. */
+ case MODIFY_EXPR:
+ {
+ if (fn_contains_cilk_spawn_p (cfun)
+ && cilk_detect_spawn_and_unwrap (expr_p)
+ && !seen_error ())
+ return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
+
+ /* If the back end isn't clever enough to know that the lhs and rhs
+ types are the same, add an explicit conversion. */
+ tree op0 = TREE_OPERAND (*expr_p, 0);
+ tree op1 = TREE_OPERAND (*expr_p, 1);
+
+ if (!error_operand_p (op0)
+ && !error_operand_p (op1)
+ && (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (op0))
+ || TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (op1)))
+ && !useless_type_conversion_p (TREE_TYPE (op1), TREE_TYPE (op0)))
+ TREE_OPERAND (*expr_p, 1) = build1 (VIEW_CONVERT_EXPR,
+ TREE_TYPE (op0), op1);
+
+ else if ((is_gimple_lvalue (op1) || INDIRECT_REF_P (op1)
+ || (TREE_CODE (op1) == CONSTRUCTOR
+ && CONSTRUCTOR_NELTS (op1) == 0
+ && !TREE_CLOBBER_P (op1))
+ || (TREE_CODE (op1) == CALL_EXPR
+ && !CALL_EXPR_RETURN_SLOT_OPT (op1)))
+ && is_really_empty_class (TREE_TYPE (op0)))
+ {
+ /* Remove any copies of empty classes. We check that the RHS
+ has a simple form so that TARGET_EXPRs and non-empty
+ CONSTRUCTORs get reduced properly, and we leave the return
+ slot optimization alone because it isn't a copy (FIXME so it
+ shouldn't be represented as one).
+
+ Also drop volatile variables on the RHS to avoid infinite
+ recursion from gimplify_expr trying to load the value. */
+ if (!TREE_SIDE_EFFECTS (op1)
+ || (DECL_P (op1) && TREE_THIS_VOLATILE (op1)))
+ *expr_p = op0;
+ else if (TREE_CODE (op1) == MEM_REF
+ && TREE_THIS_VOLATILE (op1))
+ {
+ /* Similarly for volatile MEM_REFs on the RHS. */
+ if (!TREE_SIDE_EFFECTS (TREE_OPERAND (op1, 0)))
+ *expr_p = op0;
+ else
+ *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
+ TREE_OPERAND (op1, 0), op0);
+ }
+ else
+ *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
+ op0, op1);
+ }
+ }
+ ret = GS_OK;
+ break;
+
+ case EMPTY_CLASS_EXPR:
+ /* We create an empty CONSTRUCTOR with RECORD_TYPE. */
+ *expr_p = build_constructor (TREE_TYPE (*expr_p), NULL);
+ ret = GS_OK;
+ break;
+
+ case BASELINK:
+ *expr_p = BASELINK_FUNCTIONS (*expr_p);
+ ret = GS_OK;
+ break;
+
+ case TRY_BLOCK:
+ genericize_try_block (expr_p);
+ ret = GS_OK;
+ break;
+
+ case HANDLER:
+ genericize_catch_block (expr_p);
+ ret = GS_OK;
+ break;
+
+ case EH_SPEC_BLOCK:
+ genericize_eh_spec_block (expr_p);
+ ret = GS_OK;
+ break;
+
+ case USING_STMT:
+ gcc_unreachable ();
+
+ case FOR_STMT:
+ case WHILE_STMT:
+ case DO_STMT:
+ case SWITCH_STMT:
+ case CONTINUE_STMT:
+ case BREAK_STMT:
+ gcc_unreachable ();
+
+ case OMP_FOR:
+ case OMP_SIMD:
+ case OMP_DISTRIBUTE:
+ ret = cp_gimplify_omp_for (expr_p, pre_p);
+ break;
+
+ case EXPR_STMT:
+ gimplify_expr_stmt (expr_p);
+ ret = GS_OK;
+ break;
+
+ case UNARY_PLUS_EXPR:
+ {
+ tree arg = TREE_OPERAND (*expr_p, 0);
+ tree type = TREE_TYPE (*expr_p);
+ *expr_p = (TREE_TYPE (arg) != type) ? fold_convert (type, arg)
+ : arg;
+ ret = GS_OK;
+ }
+ break;
+
+ case CILK_SPAWN_STMT:
+ gcc_assert
+ (fn_contains_cilk_spawn_p (cfun)
+ && cilk_detect_spawn_and_unwrap (expr_p));
+
+ /* If errors are seen, then just process it as a CALL_EXPR. */
+ if (!seen_error ())
+ return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
+
+ case CALL_EXPR:
+ if (fn_contains_cilk_spawn_p (cfun)
+ && cilk_detect_spawn_and_unwrap (expr_p)
+ && !seen_error ())
+ return (enum gimplify_status) gimplify_cilk_spawn (expr_p);
+
+ default:
+ ret = (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p);
+ break;
+ }
+
+ /* Restore saved state. */
+ if (STATEMENT_CODE_P (code))
+ current_stmt_tree ()->stmts_are_full_exprs_p
+ = saved_stmts_are_full_exprs_p;
+
+ return ret;
+}
+
+static inline bool
+is_invisiref_parm (const_tree t)
+{
+ return ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)
+ && DECL_BY_REFERENCE (t));
+}
+
+/* Return true if the uid in both int tree maps are equal. */
+
+int
+cxx_int_tree_map_eq (const void *va, const void *vb)
+{
+ const struct cxx_int_tree_map *a = (const struct cxx_int_tree_map *) va;
+ const struct cxx_int_tree_map *b = (const struct cxx_int_tree_map *) vb;
+ return (a->uid == b->uid);
+}
+
+/* Hash a UID in a cxx_int_tree_map. */
+
+unsigned int
+cxx_int_tree_map_hash (const void *item)
+{
+ return ((const struct cxx_int_tree_map *)item)->uid;
+}
+
+/* A stable comparison routine for use with splay trees and DECLs. */
+
+static int
+splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
+{
+ tree a = (tree) xa;
+ tree b = (tree) xb;
+
+ return DECL_UID (a) - DECL_UID (b);
+}
+
+/* OpenMP context during genericization. */
+
+struct cp_genericize_omp_taskreg
+{
+ bool is_parallel;
+ bool default_shared;
+ struct cp_genericize_omp_taskreg *outer;
+ splay_tree variables;
+};
+
+/* Return true if genericization should try to determine if
+ DECL is firstprivate or shared within task regions. */
+
+static bool
+omp_var_to_track (tree decl)
+{
+ tree type = TREE_TYPE (decl);
+ if (is_invisiref_parm (decl))
+ type = TREE_TYPE (type);
+ while (TREE_CODE (type) == ARRAY_TYPE)
+ type = TREE_TYPE (type);
+ if (type == error_mark_node || !CLASS_TYPE_P (type))
+ return false;
+ if (VAR_P (decl) && DECL_THREAD_LOCAL_P (decl))
+ return false;
+ if (cxx_omp_predetermined_sharing (decl) != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
+ return false;
+ return true;
+}
+
+/* Note DECL use in OpenMP region OMP_CTX during genericization. */
+
+static void
+omp_cxx_notice_variable (struct cp_genericize_omp_taskreg *omp_ctx, tree decl)
+{
+ splay_tree_node n = splay_tree_lookup (omp_ctx->variables,
+ (splay_tree_key) decl);
+ if (n == NULL)
+ {
+ int flags = OMP_CLAUSE_DEFAULT_SHARED;
+ if (omp_ctx->outer)
+ omp_cxx_notice_variable (omp_ctx->outer, decl);
+ if (!omp_ctx->default_shared)
+ {
+ struct cp_genericize_omp_taskreg *octx;
+
+ for (octx = omp_ctx->outer; octx; octx = octx->outer)
+ {
+ n = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
+ if (n && n->value != OMP_CLAUSE_DEFAULT_SHARED)
+ {
+ flags = OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
+ break;
+ }
+ if (octx->is_parallel)
+ break;
+ }
+ if (octx == NULL
+ && (TREE_CODE (decl) == PARM_DECL
+ || (!(TREE_STATIC (decl) || DECL_EXTERNAL (decl))
+ && DECL_CONTEXT (decl) == current_function_decl)))
+ flags = OMP_CLAUSE_DEFAULT_FIRSTPRIVATE;
+ if (flags == OMP_CLAUSE_DEFAULT_FIRSTPRIVATE)
+ {
+ /* DECL is implicitly determined firstprivate in
+ the current task construct. Ensure copy ctor and
+ dtor are instantiated, because during gimplification
+ it will be already too late. */
+ tree type = TREE_TYPE (decl);
+ if (is_invisiref_parm (decl))
+ type = TREE_TYPE (type);
+ while (TREE_CODE (type) == ARRAY_TYPE)
+ type = TREE_TYPE (type);
+ get_copy_ctor (type, tf_none);
+ get_dtor (type, tf_none);
+ }
+ }
+ splay_tree_insert (omp_ctx->variables, (splay_tree_key) decl, flags);
+ }
+}
+
+/* Genericization context. */
+
+struct cp_genericize_data
+{
+ struct pointer_set_t *p_set;
+ vec<tree> bind_expr_stack;
+ struct cp_genericize_omp_taskreg *omp_ctx;
+};
+
+/* Perform any pre-gimplification lowering of C++ front end trees to
+ GENERIC. */
+
+static tree
+cp_genericize_r (tree *stmt_p, int *walk_subtrees, void *data)
+{
+ tree stmt = *stmt_p;
+ struct cp_genericize_data *wtd = (struct cp_genericize_data *) data;
+ struct pointer_set_t *p_set = wtd->p_set;
+
+ /* If in an OpenMP context, note var uses. */
+ if (__builtin_expect (wtd->omp_ctx != NULL, 0)
+ && (VAR_P (stmt)
+ || TREE_CODE (stmt) == PARM_DECL
+ || TREE_CODE (stmt) == RESULT_DECL)
+ && omp_var_to_track (stmt))
+ omp_cxx_notice_variable (wtd->omp_ctx, stmt);
+
+ if (is_invisiref_parm (stmt)
+ /* Don't dereference parms in a thunk, pass the references through. */
+ && !(DECL_THUNK_P (current_function_decl)
+ && TREE_CODE (stmt) == PARM_DECL))
+ {
+ *stmt_p = convert_from_reference (stmt);
+ *walk_subtrees = 0;
+ return NULL;
+ }
+
+ /* Map block scope extern declarations to visible declarations with the
+ same name and type in outer scopes if any. */
+ if (cp_function_chain->extern_decl_map
+ && VAR_OR_FUNCTION_DECL_P (stmt)
+ && DECL_EXTERNAL (stmt))
+ {
+ struct cxx_int_tree_map *h, in;
+ in.uid = DECL_UID (stmt);
+ h = (struct cxx_int_tree_map *)
+ htab_find_with_hash (cp_function_chain->extern_decl_map,
+ &in, in.uid);
+ if (h)
+ {
+ *stmt_p = h->to;
+ *walk_subtrees = 0;
+ return NULL;
+ }
+ }
+
+ /* Other than invisiref parms, don't walk the same tree twice. */
+ if (pointer_set_contains (p_set, stmt))
+ {
+ *walk_subtrees = 0;
+ return NULL_TREE;
+ }
+
+ if (TREE_CODE (stmt) == ADDR_EXPR
+ && is_invisiref_parm (TREE_OPERAND (stmt, 0)))
+ {
+ /* If in an OpenMP context, note var uses. */
+ if (__builtin_expect (wtd->omp_ctx != NULL, 0)
+ && omp_var_to_track (TREE_OPERAND (stmt, 0)))
+ omp_cxx_notice_variable (wtd->omp_ctx, TREE_OPERAND (stmt, 0));
+ *stmt_p = convert (TREE_TYPE (stmt), TREE_OPERAND (stmt, 0));
+ *walk_subtrees = 0;
+ }
+ else if (TREE_CODE (stmt) == RETURN_EXPR
+ && TREE_OPERAND (stmt, 0)
+ && is_invisiref_parm (TREE_OPERAND (stmt, 0)))
+ /* Don't dereference an invisiref RESULT_DECL inside a RETURN_EXPR. */
+ *walk_subtrees = 0;
+ else if (TREE_CODE (stmt) == OMP_CLAUSE)
+ switch (OMP_CLAUSE_CODE (stmt))
+ {
+ case OMP_CLAUSE_LASTPRIVATE:
+ /* Don't dereference an invisiref in OpenMP clauses. */
+ if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
+ {
+ *walk_subtrees = 0;
+ if (OMP_CLAUSE_LASTPRIVATE_STMT (stmt))
+ cp_walk_tree (&OMP_CLAUSE_LASTPRIVATE_STMT (stmt),
+ cp_genericize_r, data, NULL);
+ }
+ break;
+ case OMP_CLAUSE_PRIVATE:
+ /* Don't dereference an invisiref in OpenMP clauses. */
+ if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
+ *walk_subtrees = 0;
+ else if (wtd->omp_ctx != NULL)
+ {
+ /* Private clause doesn't cause any references to the
+ var in outer contexts, avoid calling
+ omp_cxx_notice_variable for it. */
+ struct cp_genericize_omp_taskreg *old = wtd->omp_ctx;
+ wtd->omp_ctx = NULL;
+ cp_walk_tree (&OMP_CLAUSE_DECL (stmt), cp_genericize_r,
+ data, NULL);
+ wtd->omp_ctx = old;
+ *walk_subtrees = 0;
+ }
+ break;
+ case OMP_CLAUSE_SHARED:
+ case OMP_CLAUSE_FIRSTPRIVATE:
+ case OMP_CLAUSE_COPYIN:
+ case OMP_CLAUSE_COPYPRIVATE:
+ /* Don't dereference an invisiref in OpenMP clauses. */
+ if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
+ *walk_subtrees = 0;
+ break;
+ case OMP_CLAUSE_REDUCTION:
+ /* Don't dereference an invisiref in reduction clause's
+ OMP_CLAUSE_DECL either. OMP_CLAUSE_REDUCTION_{INIT,MERGE}
+ still needs to be genericized. */
+ if (is_invisiref_parm (OMP_CLAUSE_DECL (stmt)))
+ {
+ *walk_subtrees = 0;
+ if (OMP_CLAUSE_REDUCTION_INIT (stmt))
+ cp_walk_tree (&OMP_CLAUSE_REDUCTION_INIT (stmt),
+ cp_genericize_r, data, NULL);
+ if (OMP_CLAUSE_REDUCTION_MERGE (stmt))
+ cp_walk_tree (&OMP_CLAUSE_REDUCTION_MERGE (stmt),
+ cp_genericize_r, data, NULL);
+ }
+ break;
+ default:
+ break;
+ }
+ else if (IS_TYPE_OR_DECL_P (stmt))
+ *walk_subtrees = 0;
+
+ /* Due to the way voidify_wrapper_expr is written, we don't get a chance
+ to lower this construct before scanning it, so we need to lower these
+ before doing anything else. */
+ else if (TREE_CODE (stmt) == CLEANUP_STMT)
+ *stmt_p = build2_loc (EXPR_LOCATION (stmt),
+ CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR
+ : TRY_FINALLY_EXPR,
+ void_type_node,
+ CLEANUP_BODY (stmt),
+ CLEANUP_EXPR (stmt));
+
+ else if (TREE_CODE (stmt) == IF_STMT)
+ {
+ genericize_if_stmt (stmt_p);
+ /* *stmt_p has changed, tail recurse to handle it again. */
+ return cp_genericize_r (stmt_p, walk_subtrees, data);
+ }
+
+ /* COND_EXPR might have incompatible types in branches if one or both
+ arms are bitfields. Fix it up now. */
+ else if (TREE_CODE (stmt) == COND_EXPR)
+ {
+ tree type_left
+ = (TREE_OPERAND (stmt, 1)
+ ? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 1))
+ : NULL_TREE);
+ tree type_right
+ = (TREE_OPERAND (stmt, 2)
+ ? is_bitfield_expr_with_lowered_type (TREE_OPERAND (stmt, 2))
+ : NULL_TREE);
+ if (type_left
+ && !useless_type_conversion_p (TREE_TYPE (stmt),
+ TREE_TYPE (TREE_OPERAND (stmt, 1))))
+ {
+ TREE_OPERAND (stmt, 1)
+ = fold_convert (type_left, TREE_OPERAND (stmt, 1));
+ gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
+ type_left));
+ }
+ if (type_right
+ && !useless_type_conversion_p (TREE_TYPE (stmt),
+ TREE_TYPE (TREE_OPERAND (stmt, 2))))
+ {
+ TREE_OPERAND (stmt, 2)
+ = fold_convert (type_right, TREE_OPERAND (stmt, 2));
+ gcc_assert (useless_type_conversion_p (TREE_TYPE (stmt),
+ type_right));
+ }
+ }
+
+ else if (TREE_CODE (stmt) == BIND_EXPR)
+ {
+ if (__builtin_expect (wtd->omp_ctx != NULL, 0))
+ {
+ tree decl;
+ for (decl = BIND_EXPR_VARS (stmt); decl; decl = DECL_CHAIN (decl))
+ if (VAR_P (decl)
+ && !DECL_EXTERNAL (decl)
+ && omp_var_to_track (decl))
+ {
+ splay_tree_node n
+ = splay_tree_lookup (wtd->omp_ctx->variables,
+ (splay_tree_key) decl);
+ if (n == NULL)
+ splay_tree_insert (wtd->omp_ctx->variables,
+ (splay_tree_key) decl,
+ TREE_STATIC (decl)
+ ? OMP_CLAUSE_DEFAULT_SHARED
+ : OMP_CLAUSE_DEFAULT_PRIVATE);
+ }
+ }
+ wtd->bind_expr_stack.safe_push (stmt);
+ cp_walk_tree (&BIND_EXPR_BODY (stmt),
+ cp_genericize_r, data, NULL);
+ wtd->bind_expr_stack.pop ();
+ }
+
+ else if (TREE_CODE (stmt) == USING_STMT)
+ {
+ tree block = NULL_TREE;
+
+ /* Get the innermost inclosing GIMPLE_BIND that has a non NULL
+ BLOCK, and append an IMPORTED_DECL to its
+ BLOCK_VARS chained list. */
+ if (wtd->bind_expr_stack.exists ())
+ {
+ int i;
+ for (i = wtd->bind_expr_stack.length () - 1; i >= 0; i--)
+ if ((block = BIND_EXPR_BLOCK (wtd->bind_expr_stack[i])))
+ break;
+ }
+ if (block)
+ {
+ tree using_directive;
+ gcc_assert (TREE_OPERAND (stmt, 0));
+
+ using_directive = make_node (IMPORTED_DECL);
+ TREE_TYPE (using_directive) = void_type_node;
+
+ IMPORTED_DECL_ASSOCIATED_DECL (using_directive)
+ = TREE_OPERAND (stmt, 0);
+ DECL_CHAIN (using_directive) = BLOCK_VARS (block);
+ BLOCK_VARS (block) = using_directive;
+ }
+ /* The USING_STMT won't appear in GENERIC. */
+ *stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
+ *walk_subtrees = 0;
+ }
+
+ else if (TREE_CODE (stmt) == DECL_EXPR
+ && TREE_CODE (DECL_EXPR_DECL (stmt)) == USING_DECL)
+ {
+ /* Using decls inside DECL_EXPRs are just dropped on the floor. */
+ *stmt_p = build1 (NOP_EXPR, void_type_node, integer_zero_node);
+ *walk_subtrees = 0;
+ }
+ else if (TREE_CODE (stmt) == OMP_PARALLEL || TREE_CODE (stmt) == OMP_TASK)
+ {
+ struct cp_genericize_omp_taskreg omp_ctx;
+ tree c, decl;
+ splay_tree_node n;
+
+ *walk_subtrees = 0;
+ cp_walk_tree (&OMP_CLAUSES (stmt), cp_genericize_r, data, NULL);
+ omp_ctx.is_parallel = TREE_CODE (stmt) == OMP_PARALLEL;
+ omp_ctx.default_shared = omp_ctx.is_parallel;
+ omp_ctx.outer = wtd->omp_ctx;
+ omp_ctx.variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
+ wtd->omp_ctx = &omp_ctx;
+ for (c = OMP_CLAUSES (stmt); c; c = OMP_CLAUSE_CHAIN (c))
+ switch (OMP_CLAUSE_CODE (c))
+ {
+ case OMP_CLAUSE_SHARED:
+ case OMP_CLAUSE_PRIVATE:
+ case OMP_CLAUSE_FIRSTPRIVATE:
+ case OMP_CLAUSE_LASTPRIVATE:
+ decl = OMP_CLAUSE_DECL (c);
+ if (decl == error_mark_node || !omp_var_to_track (decl))
+ break;
+ n = splay_tree_lookup (omp_ctx.variables, (splay_tree_key) decl);
+ if (n != NULL)
+ break;
+ splay_tree_insert (omp_ctx.variables, (splay_tree_key) decl,
+ OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED
+ ? OMP_CLAUSE_DEFAULT_SHARED
+ : OMP_CLAUSE_DEFAULT_PRIVATE);
+ if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_PRIVATE
+ && omp_ctx.outer)
+ omp_cxx_notice_variable (omp_ctx.outer, decl);
+ break;
+ case OMP_CLAUSE_DEFAULT:
+ if (OMP_CLAUSE_DEFAULT_KIND (c) == OMP_CLAUSE_DEFAULT_SHARED)
+ omp_ctx.default_shared = true;
+ default:
+ break;
+ }
+ cp_walk_tree (&OMP_BODY (stmt), cp_genericize_r, data, NULL);
+ wtd->omp_ctx = omp_ctx.outer;
+ splay_tree_delete (omp_ctx.variables);
+ }
+ else if (TREE_CODE (stmt) == CONVERT_EXPR)
+ gcc_assert (!CONVERT_EXPR_VBASE_PATH (stmt));
+ else if (TREE_CODE (stmt) == FOR_STMT)
+ genericize_for_stmt (stmt_p, walk_subtrees, data);
+ else if (TREE_CODE (stmt) == WHILE_STMT)
+ genericize_while_stmt (stmt_p, walk_subtrees, data);
+ else if (TREE_CODE (stmt) == DO_STMT)
+ genericize_do_stmt (stmt_p, walk_subtrees, data);
+ else if (TREE_CODE (stmt) == SWITCH_STMT)
+ genericize_switch_stmt (stmt_p, walk_subtrees, data);
+ else if (TREE_CODE (stmt) == CONTINUE_STMT)
+ genericize_continue_stmt (stmt_p);
+ else if (TREE_CODE (stmt) == BREAK_STMT)
+ genericize_break_stmt (stmt_p);
+ else if (TREE_CODE (stmt) == OMP_FOR
+ || TREE_CODE (stmt) == OMP_SIMD
+ || TREE_CODE (stmt) == OMP_DISTRIBUTE)
+ genericize_omp_for_stmt (stmt_p, walk_subtrees, data);
+ else if (TREE_CODE (stmt) == SIZEOF_EXPR)
+ {
+ if (SIZEOF_EXPR_TYPE_P (stmt))
+ *stmt_p
+ = cxx_sizeof_or_alignof_type (TREE_TYPE (TREE_OPERAND (stmt, 0)),
+ SIZEOF_EXPR, false);
+ else if (TYPE_P (TREE_OPERAND (stmt, 0)))
+ *stmt_p = cxx_sizeof_or_alignof_type (TREE_OPERAND (stmt, 0),
+ SIZEOF_EXPR, false);
+ else
+ *stmt_p = cxx_sizeof_or_alignof_expr (TREE_OPERAND (stmt, 0),
+ SIZEOF_EXPR, false);
+ if (*stmt_p == error_mark_node)
+ *stmt_p = size_one_node;
+ return NULL;
+ }
+
+ pointer_set_insert (p_set, *stmt_p);
+
+ return NULL;
+}
+
+/* Lower C++ front end trees to GENERIC in T_P. */
+
+static void
+cp_genericize_tree (tree* t_p)
+{
+ struct cp_genericize_data wtd;
+
+ wtd.p_set = pointer_set_create ();
+ wtd.bind_expr_stack.create (0);
+ wtd.omp_ctx = NULL;
+ cp_walk_tree (t_p, cp_genericize_r, &wtd, NULL);
+ pointer_set_destroy (wtd.p_set);
+ wtd.bind_expr_stack.release ();
+}
+
+/* If a function that should end with a return in non-void
+ function doesn't obviously end with return, add ubsan
+ instrmentation code to verify it at runtime. */
+
+static void
+cp_ubsan_maybe_instrument_return (tree fndecl)
+{
+ if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl)))
+ || DECL_CONSTRUCTOR_P (fndecl)
+ || DECL_DESTRUCTOR_P (fndecl)
+ || !targetm.warn_func_return (fndecl))
+ return;
+
+ tree t = DECL_SAVED_TREE (fndecl);
+ while (t)
+ {
+ switch (TREE_CODE (t))
+ {
+ case BIND_EXPR:
+ t = BIND_EXPR_BODY (t);
+ continue;
+ case TRY_FINALLY_EXPR:
+ t = TREE_OPERAND (t, 0);
+ continue;
+ case STATEMENT_LIST:
+ {
+ tree_stmt_iterator i = tsi_last (t);
+ if (!tsi_end_p (i))
+ {
+ t = tsi_stmt (i);
+ continue;
+ }
+ }
+ break;
+ case RETURN_EXPR:
+ return;
+ default:
+ break;
+ }
+ break;
+ }
+ if (t == NULL_TREE)
+ return;
+ t = DECL_SAVED_TREE (fndecl);
+ if (TREE_CODE (t) == BIND_EXPR
+ && TREE_CODE (BIND_EXPR_BODY (t)) == STATEMENT_LIST)
+ {
+ tree_stmt_iterator i = tsi_last (BIND_EXPR_BODY (t));
+ t = ubsan_instrument_return (DECL_SOURCE_LOCATION (fndecl));
+ tsi_link_after (&i, t, TSI_NEW_STMT);
+ }
+}
+
+void
+cp_genericize (tree fndecl)
+{
+ tree t;
+
+ /* Fix up the types of parms passed by invisible reference. */
+ for (t = DECL_ARGUMENTS (fndecl); t; t = DECL_CHAIN (t))
+ if (TREE_ADDRESSABLE (TREE_TYPE (t)))
+ {
+ /* If a function's arguments are copied to create a thunk,
+ then DECL_BY_REFERENCE will be set -- but the type of the
+ argument will be a pointer type, so we will never get
+ here. */
+ gcc_assert (!DECL_BY_REFERENCE (t));
+ gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t));
+ TREE_TYPE (t) = DECL_ARG_TYPE (t);
+ DECL_BY_REFERENCE (t) = 1;
+ TREE_ADDRESSABLE (t) = 0;
+ relayout_decl (t);
+ }
+
+ /* Do the same for the return value. */
+ if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl))))
+ {
+ t = DECL_RESULT (fndecl);
+ TREE_TYPE (t) = build_reference_type (TREE_TYPE (t));
+ DECL_BY_REFERENCE (t) = 1;
+ TREE_ADDRESSABLE (t) = 0;
+ relayout_decl (t);
+ if (DECL_NAME (t))
+ {
+ /* Adjust DECL_VALUE_EXPR of the original var. */
+ tree outer = outer_curly_brace_block (current_function_decl);
+ tree var;
+
+ if (outer)
+ for (var = BLOCK_VARS (outer); var; var = DECL_CHAIN (var))
+ if (DECL_NAME (t) == DECL_NAME (var)
+ && DECL_HAS_VALUE_EXPR_P (var)
+ && DECL_VALUE_EXPR (var) == t)
+ {
+ tree val = convert_from_reference (t);
+ SET_DECL_VALUE_EXPR (var, val);
+ break;
+ }
+ }
+ }
+
+ /* If we're a clone, the body is already GIMPLE. */
+ if (DECL_CLONED_FUNCTION_P (fndecl))
+ return;
+
+ /* Expand all the array notations here. */
+ if (flag_cilkplus
+ && contains_array_notation_expr (DECL_SAVED_TREE (fndecl)))
+ DECL_SAVED_TREE (fndecl) =
+ expand_array_notation_exprs (DECL_SAVED_TREE (fndecl));
+
+ /* We do want to see every occurrence of the parms, so we can't just use
+ walk_tree's hash functionality. */
+ cp_genericize_tree (&DECL_SAVED_TREE (fndecl));
+
+ if (flag_sanitize & SANITIZE_RETURN)
+ cp_ubsan_maybe_instrument_return (fndecl);
+
+ /* Do everything else. */
+ c_genericize (fndecl);
+
+ gcc_assert (bc_label[bc_break] == NULL);
+ gcc_assert (bc_label[bc_continue] == NULL);
+}
+
+/* Build code to apply FN to each member of ARG1 and ARG2. FN may be
+ NULL if there is in fact nothing to do. ARG2 may be null if FN
+ actually only takes one argument. */
+
+static tree
+cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
+{
+ tree defparm, parm, t;
+ int i = 0;
+ int nargs;
+ tree *argarray;
+
+ if (fn == NULL)
+ return NULL;
+
+ nargs = list_length (DECL_ARGUMENTS (fn));
+ argarray = XALLOCAVEC (tree, nargs);
+
+ defparm = TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (fn)));
+ if (arg2)
+ defparm = TREE_CHAIN (defparm);
+
+ if (TREE_CODE (TREE_TYPE (arg1)) == ARRAY_TYPE)
+ {
+ tree inner_type = TREE_TYPE (arg1);
+ tree start1, end1, p1;
+ tree start2 = NULL, p2 = NULL;
+ tree ret = NULL, lab;
+
+ start1 = arg1;
+ start2 = arg2;
+ do
+ {
+ inner_type = TREE_TYPE (inner_type);
+ start1 = build4 (ARRAY_REF, inner_type, start1,
+ size_zero_node, NULL, NULL);
+ if (arg2)
+ start2 = build4 (ARRAY_REF, inner_type, start2,
+ size_zero_node, NULL, NULL);
+ }
+ while (TREE_CODE (inner_type) == ARRAY_TYPE);
+ start1 = build_fold_addr_expr_loc (input_location, start1);
+ if (arg2)
+ start2 = build_fold_addr_expr_loc (input_location, start2);
+
+ end1 = TYPE_SIZE_UNIT (TREE_TYPE (arg1));
+ end1 = fold_build_pointer_plus (start1, end1);
+
+ p1 = create_tmp_var (TREE_TYPE (start1), NULL);
+ t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, start1);
+ append_to_statement_list (t, &ret);
+
+ if (arg2)
+ {
+ p2 = create_tmp_var (TREE_TYPE (start2), NULL);
+ t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, start2);
+ append_to_statement_list (t, &ret);
+ }
+
+ lab = create_artificial_label (input_location);
+ t = build1 (LABEL_EXPR, void_type_node, lab);
+ append_to_statement_list (t, &ret);
+
+ argarray[i++] = p1;
+ if (arg2)
+ argarray[i++] = p2;
+ /* Handle default arguments. */
+ for (parm = defparm; parm && parm != void_list_node;
+ parm = TREE_CHAIN (parm), i++)
+ argarray[i] = convert_default_arg (TREE_VALUE (parm),
+ TREE_PURPOSE (parm), fn, i,
+ tf_warning_or_error);
+ t = build_call_a (fn, i, argarray);
+ t = fold_convert (void_type_node, t);
+ t = fold_build_cleanup_point_expr (TREE_TYPE (t), t);
+ append_to_statement_list (t, &ret);
+
+ t = fold_build_pointer_plus (p1, TYPE_SIZE_UNIT (inner_type));
+ t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, t);
+ append_to_statement_list (t, &ret);
+
+ if (arg2)
+ {
+ t = fold_build_pointer_plus (p2, TYPE_SIZE_UNIT (inner_type));
+ t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, t);
+ append_to_statement_list (t, &ret);
+ }
+
+ t = build2 (NE_EXPR, boolean_type_node, p1, end1);
+ t = build3 (COND_EXPR, void_type_node, t, build_and_jump (&lab), NULL);
+ append_to_statement_list (t, &ret);
+
+ return ret;
+ }
+ else
+ {
+ argarray[i++] = build_fold_addr_expr_loc (input_location, arg1);
+ if (arg2)
+ argarray[i++] = build_fold_addr_expr_loc (input_location, arg2);
+ /* Handle default arguments. */
+ for (parm = defparm; parm && parm != void_list_node;
+ parm = TREE_CHAIN (parm), i++)
+ argarray[i] = convert_default_arg (TREE_VALUE (parm),
+ TREE_PURPOSE (parm),
+ fn, i, tf_warning_or_error);
+ t = build_call_a (fn, i, argarray);
+ t = fold_convert (void_type_node, t);
+ return fold_build_cleanup_point_expr (TREE_TYPE (t), t);
+ }
+}
+
+/* Return code to initialize DECL with its default constructor, or
+ NULL if there's nothing to do. */
+
+tree
+cxx_omp_clause_default_ctor (tree clause, tree decl, tree /*outer*/)
+{
+ tree info = CP_OMP_CLAUSE_INFO (clause);
+ tree ret = NULL;
+
+ if (info)
+ ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), decl, NULL);
+
+ return ret;
+}
+
+/* Return code to initialize DST with a copy constructor from SRC. */
+
+tree
+cxx_omp_clause_copy_ctor (tree clause, tree dst, tree src)
+{
+ tree info = CP_OMP_CLAUSE_INFO (clause);
+ tree ret = NULL;
+
+ if (info)
+ ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 0), dst, src);
+ if (ret == NULL)
+ ret = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
+
+ return ret;
+}
+
+/* Similarly, except use an assignment operator instead. */
+
+tree
+cxx_omp_clause_assign_op (tree clause, tree dst, tree src)
+{
+ tree info = CP_OMP_CLAUSE_INFO (clause);
+ tree ret = NULL;
+
+ if (info)
+ ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 2), dst, src);
+ if (ret == NULL)
+ ret = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
+
+ return ret;
+}
+
+/* Return code to destroy DECL. */
+
+tree
+cxx_omp_clause_dtor (tree clause, tree decl)
+{
+ tree info = CP_OMP_CLAUSE_INFO (clause);
+ tree ret = NULL;
+
+ if (info)
+ ret = cxx_omp_clause_apply_fn (TREE_VEC_ELT (info, 1), decl, NULL);
+
+ return ret;
+}
+
+/* True if OpenMP should privatize what this DECL points to rather
+ than the DECL itself. */
+
+bool
+cxx_omp_privatize_by_reference (const_tree decl)
+{
+ return (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE
+ || is_invisiref_parm (decl));
+}
+
+/* Return true if DECL is const qualified var having no mutable member. */
+bool
+cxx_omp_const_qual_no_mutable (tree decl)
+{
+ tree type = TREE_TYPE (decl);
+ if (TREE_CODE (type) == REFERENCE_TYPE)
+ {
+ if (!is_invisiref_parm (decl))
+ return false;
+ type = TREE_TYPE (type);
+
+ if (TREE_CODE (decl) == RESULT_DECL && DECL_NAME (decl))
+ {
+ /* NVR doesn't preserve const qualification of the
+ variable's type. */
+ tree outer = outer_curly_brace_block (current_function_decl);
+ tree var;
+
+ if (outer)
+ for (var = BLOCK_VARS (outer); var; var = DECL_CHAIN (var))
+ if (DECL_NAME (decl) == DECL_NAME (var)
+ && (TYPE_MAIN_VARIANT (type)
+ == TYPE_MAIN_VARIANT (TREE_TYPE (var))))
+ {
+ if (TYPE_READONLY (TREE_TYPE (var)))
+ type = TREE_TYPE (var);
+ break;
+ }
+ }
+ }
+
+ if (type == error_mark_node)
+ return false;
+
+ /* Variables with const-qualified type having no mutable member
+ are predetermined shared. */
+ if (TYPE_READONLY (type) && !cp_has_mutable_p (type))
+ return true;
+
+ return false;
+}
+
+/* True if OpenMP sharing attribute of DECL is predetermined. */
+
+enum omp_clause_default_kind
+cxx_omp_predetermined_sharing (tree decl)
+{
+ /* Static data members are predetermined shared. */
+ if (TREE_STATIC (decl))
+ {
+ tree ctx = CP_DECL_CONTEXT (decl);
+ if (TYPE_P (ctx) && MAYBE_CLASS_TYPE_P (ctx))
+ return OMP_CLAUSE_DEFAULT_SHARED;
+ }
+
+ /* Const qualified vars having no mutable member are predetermined
+ shared. */
+ if (cxx_omp_const_qual_no_mutable (decl))
+ return OMP_CLAUSE_DEFAULT_SHARED;
+
+ return OMP_CLAUSE_DEFAULT_UNSPECIFIED;
+}
+
+/* Finalize an implicitly determined clause. */
+
+void
+cxx_omp_finish_clause (tree c)
+{
+ tree decl, inner_type;
+ bool make_shared = false;
+
+ if (OMP_CLAUSE_CODE (c) != OMP_CLAUSE_FIRSTPRIVATE)
+ return;
+
+ decl = OMP_CLAUSE_DECL (c);
+ decl = require_complete_type (decl);
+ inner_type = TREE_TYPE (decl);
+ if (decl == error_mark_node)
+ make_shared = true;
+ else if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
+ {
+ if (is_invisiref_parm (decl))
+ inner_type = TREE_TYPE (inner_type);
+ else
+ {
+ error ("%qE implicitly determined as %<firstprivate%> has reference type",
+ decl);
+ make_shared = true;
+ }
+ }
+
+ /* We're interested in the base element, not arrays. */
+ while (TREE_CODE (inner_type) == ARRAY_TYPE)
+ inner_type = TREE_TYPE (inner_type);
+
+ /* Check for special function availability by building a call to one.
+ Save the results, because later we won't be in the right context
+ for making these queries. */
+ if (!make_shared
+ && CLASS_TYPE_P (inner_type)
+ && cxx_omp_create_clause_info (c, inner_type, false, true, false, true))
+ make_shared = true;
+
+ if (make_shared)
+ OMP_CLAUSE_CODE (c) = OMP_CLAUSE_SHARED;
+}