diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/cp/cp-gimplify.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/gcc/cp/cp-gimplify.c | 1034 |
1 files changed, 0 insertions, 1034 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/cp/cp-gimplify.c b/gcc-4.2.1-5666.3/gcc/cp/cp-gimplify.c deleted file mode 100644 index f831ad3cc..000000000 --- a/gcc-4.2.1-5666.3/gcc/cp/cp-gimplify.c +++ /dev/null @@ -1,1034 +0,0 @@ -/* C++-specific tree lowering bits; see also c-gimplify.c and tree-gimple.c. - - Copyright (C) 2002, 2003, 2004, 2005, 2006 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 2, 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 COPYING. If not, write to the Free -Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301, USA. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "tree.h" -#include "cp-tree.h" -#include "c-common.h" -#include "toplev.h" -#include "tree-gimple.h" -#include "hashtab.h" -#include "pointer-set.h" -#include "flags.h" - -/* 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]; - -/* APPLE LOCAL begin radar 4547045 */ -/* Pop label (which should be a 'break' label in this case) from the - label of break/continue stack. */ -static tree -objc_pop_break_label (void) -{ - tree label = bc_label[bc_break]; - gcc_assert (label); - bc_label[bc_break] = TREE_CHAIN (label); - TREE_CHAIN (label) = NULL_TREE; - return label; -} - -/* Push the label on break/continue stack of labels. */ -static void -objc_push_break_label (tree label) -{ - TREE_CHAIN (label) = bc_label[bc_break]; - bc_label[bc_break] = label; -} -/* APPLE LOCAL end radar 4547045 */ - -/* Begin a scope which can be exited by a break or continue statement. BC - indicates which. - - Just creates a label and pushes it into the current context. */ - -static tree -begin_bc_block (enum bc_t bc) -{ - tree label = create_artificial_label (); - TREE_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. BODY is - an expression for the contents of the scope. - - If we saw a break (or continue) in the scope, append a LABEL_EXPR to - body. Otherwise, just forget the label. */ - -static tree -finish_bc_block (enum bc_t bc, tree label, tree body) -{ - gcc_assert (label == bc_label[bc]); - - if (TREE_USED (label)) - { - tree t, sl = NULL; - - t = build1 (LABEL_EXPR, void_type_node, label); - - append_to_statement_list (body, &sl); - append_to_statement_list (t, &sl); - body = sl; - } - - bc_label[bc] = TREE_CHAIN (label); - TREE_CHAIN (label) = NULL_TREE; - return body; -} - -/* Build a GOTO_EXPR to represent a break or continue statement. BC - indicates which. */ - -static tree -build_bc_goto (enum bc_t bc) -{ - tree label = bc_label[bc]; - - if (label == NULL_TREE) - { - if (bc == bc_break) - error ("break statement not within loop or switch"); - else - error ("continue statement not within loop or switch"); - - return NULL_TREE; - } - - /* Mark the label used for finish_bc_block. */ - TREE_USED (label) = 1; - return build1 (GOTO_EXPR, void_type_node, 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); - - gimplify_stmt (&body); - - if (CLEANUP_P (*stmt_p)) - /* A cleanup is an expression, so it doesn't need to be genericized. */; - else - gimplify_stmt (&cleanup); - - *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); - - gimplify_stmt (&body); - - /* FIXME should the caught type go in TREE_TYPE? */ - *stmt_p = build2 (CATCH_EXPR, void_type_node, type, body); -} - -/* 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 (call_unexpected_node, - tree_cons (NULL_TREE, build_exc_ptr (), - NULL_TREE)); - gimplify_stmt (&body); - - *stmt_p = gimple_build_eh_filter (body, allowed, failure); -} - -/* Genericize an IF_STMT by turning it into a COND_EXPR. */ - -static void -gimplify_if_stmt (tree *stmt_p) -{ - tree stmt, cond, then_, else_; - - stmt = *stmt_p; - cond = IF_COND (stmt); - then_ = THEN_CLAUSE (stmt); - else_ = ELSE_CLAUSE (stmt); - - if (!then_) - then_ = build_empty_stmt (); - if (!else_) - else_ = build_empty_stmt (); - - 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_); - *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 tree -/* APPLE LOCAL begin C* language */ -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ -gimplify_cp_loop (tree cond, tree body, tree incr, tree attrs, - bool cond_is_first, tree inner_foreach) -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ -/* APPLE LOCAL end C* language */ -{ - tree top, entry, exit, cont_block, break_block, stmt_list, t; - location_t stmt_locus; - - stmt_locus = input_location; - stmt_list = NULL_TREE; - entry = NULL_TREE; - - /* APPLE LOCAL begin C* language */ - /* Order of label addition to stack is important for objc's foreach-stmt. */ - /* APPLE LOCAL radar 4667060 */ - if (inner_foreach == integer_zero_node) - { - cont_block = begin_bc_block (bc_continue); - break_block = begin_bc_block (bc_break); - } - else - { - break_block = begin_bc_block (bc_break); - cont_block = begin_bc_block (bc_continue); - } - /* APPLE LOCAL end C* language */ - - /* If condition is zero don't generate a loop construct. */ - if (cond && integer_zerop (cond)) - { - top = NULL_TREE; - exit = NULL_TREE; - if (cond_is_first) - { - t = build_bc_goto (bc_break); - append_to_statement_list (t, &stmt_list); - } - } - else - { - /* If we use a LOOP_EXPR here, we have to feed the whole thing - back through the main gimplifier to lower it. Given that we - have to gimplify the loop body NOW so that we can resolve - break/continue stmts, seems easier to just expand to gotos. */ - top = build1 (LABEL_EXPR, void_type_node, NULL_TREE); - - /* 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 = build_and_jump (&LABEL_EXPR_LABEL (top)); -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - - /* Add the attributes to the 'top' label. */ - decl_attributes (&LABEL_EXPR_LABEL (top), attrs, 0); - -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - if (cond && !integer_nonzerop (cond)) - { - /* APPLE LOCAL begin radar 4667060 */ - bool outer_foreach_loop = (inner_foreach - && inner_foreach != integer_zero_node); - tree label = NULL_TREE; - if (outer_foreach_loop) - /* New spec. requires that if no match was found; i.e. foreach - exited with no match, 'elem' be set to nil. So, we use a new - label for getting out of of the outer while loop and set - 'elem=nill' after this label. */ - t = build_and_jump (&label); - else - t = build_bc_goto (bc_break); - exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t); - gimplify_stmt (&exit); - if (outer_foreach_loop) - { - /* Label: ; */ - t = build1 (LABEL_EXPR, void_type_node, label); - gimplify_stmt (&t); - append_to_statement_list (t, &exit); - /* elem = nil */ - t = build2 (MODIFY_EXPR, void_type_node, inner_foreach, - fold_convert (TREE_TYPE (inner_foreach), - integer_zero_node)); - gimplify_stmt (&t); - append_to_statement_list (t, &exit); - } - /* APPLE LOCAL end radar 4667060 */ - if (cond_is_first) - { - if (incr) - { - entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE); - t = build_and_jump (&LABEL_EXPR_LABEL (entry)); - } - else - t = build_bc_goto (bc_continue); - append_to_statement_list (t, &stmt_list); - } - } - } - - /* APPLE LOCAL begin radar 4547045 */ - /* Pop foreach's inner loop break label so outer loop's - break label becomes target of inner loop body's break statements. - */ - t = NULL_TREE; - /* APPLE LOCAL radar 4667060 */ - if (inner_foreach == integer_zero_node) - t = objc_pop_break_label (); - /* APPLE LOCAL end radar 4547045 */ - gimplify_stmt (&body); - gimplify_stmt (&incr); - - body = finish_bc_block (bc_continue, cont_block, body); - /* APPLE LOCAL begin radar 4547045 */ - /* Push back inner loop's own 'break' label so rest - of code works seemlessly. */ - /* APPLE LOCAL radar 4667060 */ - if (inner_foreach == integer_zero_node) - objc_push_break_label (t); - /* APPLE LOCAL end radar 4547045 */ - - append_to_statement_list (top, &stmt_list); - append_to_statement_list (body, &stmt_list); - append_to_statement_list (incr, &stmt_list); - append_to_statement_list (entry, &stmt_list); - append_to_statement_list (exit, &stmt_list); - - annotate_all_with_locus (&stmt_list, stmt_locus); - - return finish_bc_block (bc_break, break_block, stmt_list); -} - -/* Gimplify a FOR_STMT node. Move the stuff in the for-init-stmt into the - prequeue and hand off to gimplify_cp_loop. */ - -static void -gimplify_for_stmt (tree *stmt_p, tree *pre_p) -{ - tree stmt = *stmt_p; - - if (FOR_INIT_STMT (stmt)) - gimplify_and_add (FOR_INIT_STMT (stmt), pre_p); - -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - /* APPLE LOCAL begin C* language */ - *stmt_p = gimplify_cp_loop (FOR_COND (stmt), FOR_BODY (stmt), - FOR_EXPR (stmt), FOR_ATTRIBUTES (stmt), 1, - NULL_TREE); - /* APPLE LOCAL end C* language */ -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ -} - -/* Gimplify a WHILE_STMT node. */ - -static void -gimplify_while_stmt (tree *stmt_p) -{ - tree stmt = *stmt_p; -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - /* APPLE LOCAL begin C* language */ - *stmt_p = gimplify_cp_loop (WHILE_COND (stmt), WHILE_BODY (stmt), - NULL_TREE, WHILE_ATTRIBUTES (stmt), 1, - NULL_TREE); - /* APPLE LOCAL end C* language */ -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ -} - -/* Gimplify a DO_STMT node. */ - -static void -gimplify_do_stmt (tree *stmt_p) -{ - tree stmt = *stmt_p; -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - /* APPLE LOCAL begin C* language */ - *stmt_p = gimplify_cp_loop (DO_COND (stmt), DO_BODY (stmt), - NULL_TREE, DO_ATTRIBUTES (stmt), 0, - DO_FOREACH (stmt)); - /* APPLE LOCAL end C* language */ -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ -} - -/* Genericize a SWITCH_STMT by turning it into a SWITCH_EXPR. */ - -static void -gimplify_switch_stmt (tree *stmt_p) -{ - tree stmt = *stmt_p; - tree break_block, body; - location_t stmt_locus = input_location; - - break_block = begin_bc_block (bc_break); - - body = SWITCH_STMT_BODY (stmt); - if (!body) - body = build_empty_stmt (); - - *stmt_p = build3 (SWITCH_EXPR, SWITCH_STMT_TYPE (stmt), - SWITCH_STMT_COND (stmt), body, NULL_TREE); - SET_EXPR_LOCATION (*stmt_p, stmt_locus); - gimplify_stmt (stmt_p); - - *stmt_p = finish_bc_block (bc_break, break_block, *stmt_p); -} - -/* Hook into the middle of gimplifying an OMP_FOR node. This is required - in order to properly gimplify CONTINUE statements. Here we merely - manage the continue stack; the rest of the job is performed by the - regular gimplifier. */ - -static enum gimplify_status -cp_gimplify_omp_for (tree *expr_p) -{ - tree for_stmt = *expr_p; - tree cont_block; - - /* Protect ourselves from recursion. */ - if (OMP_FOR_GIMPLIFYING_P (for_stmt)) - return GS_UNHANDLED; - OMP_FOR_GIMPLIFYING_P (for_stmt) = 1; - - /* Note that while technically the continue label is enabled too soon - here, we should have already diagnosed invalid continues nested within - statement expressions within the INIT, COND, or INCR expressions. */ - cont_block = begin_bc_block (bc_continue); - - gimplify_stmt (expr_p); - - OMP_FOR_BODY (for_stmt) - = finish_bc_block (bc_continue, cont_block, OMP_FOR_BODY (for_stmt)); - 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 && (extra_warnings || 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_Wextra, "statement with no effect"); - } - else if (warn_unused_value) - 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 *pre_p, tree *post_p) -{ - tree from = TREE_OPERAND (*expr_p, 1); - tree to = TREE_OPERAND (*expr_p, 0); - tree sub; - - /* 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. */ - sub = expr_last (from); - - /* 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) - { - gimplify_expr (&to, pre_p, post_p, is_gimple_lvalue, fb_lvalue); - TREE_OPERAND (sub, 2) = 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; - } -} - -/* Gimplify a MUST_NOT_THROW_EXPR. */ - -static void -gimplify_must_not_throw_expr (tree *expr_p, tree *pre_p) -{ - tree stmt = *expr_p; - tree temp = voidify_wrapper_expr (stmt, NULL); - tree body = TREE_OPERAND (stmt, 0); - - gimplify_stmt (&body); - - stmt = gimple_build_eh_filter (body, NULL_TREE, - build_call (terminate_node, NULL_TREE)); - - if (temp) - { - append_to_statement_list (stmt, pre_p); - *expr_p = temp; - } - else - *expr_p = stmt; -} - -/* Do C++-specific gimplification. Args are as for gimplify_expr. */ - -int -cp_gimplify_expr (tree *expr_p, tree *pre_p, tree *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 THROW_EXPR: - /* FIXME communicate throw type to backend, probably by moving - THROW_EXPR into ../tree.def. */ - *expr_p = TREE_OPERAND (*expr_p, 0); - ret = GS_OK; - break; - - case MUST_NOT_THROW_EXPR: - gimplify_must_not_throw_expr (expr_p, pre_p); - ret = GS_OK; - 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: - cp_gimplify_init_expr (expr_p, pre_p, post_p); - 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: - /* Just ignore for now. Eventually we will want to pass this on to - the debugger. */ - *expr_p = build_empty_stmt (); - ret = GS_ALL_DONE; - break; - - case IF_STMT: - gimplify_if_stmt (expr_p); - ret = GS_OK; - break; - - case FOR_STMT: - gimplify_for_stmt (expr_p, pre_p); - ret = GS_ALL_DONE; - break; - - case WHILE_STMT: - gimplify_while_stmt (expr_p); - ret = GS_ALL_DONE; - break; - - case DO_STMT: - gimplify_do_stmt (expr_p); - ret = GS_ALL_DONE; - break; - - case SWITCH_STMT: - gimplify_switch_stmt (expr_p); - ret = GS_ALL_DONE; - break; - - case OMP_FOR: - ret = cp_gimplify_omp_for (expr_p); - break; - - case CONTINUE_STMT: - *expr_p = build_bc_goto (bc_continue); - ret = GS_ALL_DONE; - break; - - case BREAK_STMT: - *expr_p = build_bc_goto (bc_break); - ret = GS_ALL_DONE; - 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; - - default: - ret = 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 (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; -} - -/* 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 pointer_set_t *p_set = (struct pointer_set_t*) data; - - 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 - && (TREE_CODE (stmt) == FUNCTION_DECL || TREE_CODE (stmt) == VAR_DECL) - && 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))) - { - *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_PRIVATE: - case OMP_CLAUSE_SHARED: - case OMP_CLAUSE_FIRSTPRIVATE: - case OMP_CLAUSE_LASTPRIVATE: - 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: - gcc_assert (!is_invisiref_parm (OMP_CLAUSE_DECL (stmt))); - 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 (CLEANUP_EH_ONLY (stmt) ? TRY_CATCH_EXPR - : TRY_FINALLY_EXPR, - void_type_node, - CLEANUP_BODY (stmt), - CLEANUP_EXPR (stmt)); - - pointer_set_insert (p_set, *stmt_p); - - return NULL; -} - -void -cp_genericize (tree fndecl) -{ - tree t; - struct pointer_set_t *p_set; - - /* Fix up the types of parms passed by invisible reference. */ - for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_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 we're a clone, the body is already GIMPLE. */ - if (DECL_CLONED_FUNCTION_P (fndecl)) - return; - - /* We do want to see every occurrence of the parms, so we can't just use - walk_tree's hash functionality. */ - p_set = pointer_set_create (); - walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, p_set, NULL); - pointer_set_destroy (p_set); - - /* 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; - int i; - - if (fn == NULL) - return NULL; - - 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, t; - - 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 (start1); - if (arg2) - start2 = build_fold_addr_expr (start2); - - end1 = TYPE_SIZE_UNIT (TREE_TYPE (arg1)); - end1 = fold_convert (TREE_TYPE (start1), end1); - end1 = build2 (PLUS_EXPR, TREE_TYPE (start1), start1, end1); - - p1 = create_tmp_var (TREE_TYPE (start1), NULL); - t = build2 (MODIFY_EXPR, void_type_node, p1, start1); - append_to_statement_list (t, &ret); - - if (arg2) - { - p2 = create_tmp_var (TREE_TYPE (start2), NULL); - t = build2 (MODIFY_EXPR, void_type_node, p2, start2); - append_to_statement_list (t, &ret); - } - - lab = create_artificial_label (); - t = build1 (LABEL_EXPR, void_type_node, lab); - append_to_statement_list (t, &ret); - - t = tree_cons (NULL, p1, NULL); - if (arg2) - t = tree_cons (NULL, p2, t); - /* Handle default arguments. */ - i = 1 + (arg2 != NULL); - for (parm = defparm; parm != void_list_node; parm = TREE_CHAIN (parm)) - t = tree_cons (NULL, convert_default_arg (TREE_VALUE (parm), - TREE_PURPOSE (parm), - fn, i++), t); - t = build_call (fn, nreverse (t)); - append_to_statement_list (t, &ret); - - t = fold_convert (TREE_TYPE (p1), TYPE_SIZE_UNIT (inner_type)); - t = build2 (PLUS_EXPR, TREE_TYPE (p1), p1, t); - t = build2 (MODIFY_EXPR, void_type_node, p1, t); - append_to_statement_list (t, &ret); - - if (arg2) - { - t = fold_convert (TREE_TYPE (p2), TYPE_SIZE_UNIT (inner_type)); - t = build2 (PLUS_EXPR, TREE_TYPE (p2), p2, t); - t = build2 (MODIFY_EXPR, void_type_node, 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 - { - tree t = tree_cons (NULL, build_fold_addr_expr (arg1), NULL); - if (arg2) - t = tree_cons (NULL, build_fold_addr_expr (arg2), t); - /* Handle default arguments. */ - i = 1 + (arg2 != NULL); - for (parm = defparm; parm != void_list_node; parm = TREE_CHAIN (parm)) - t = tree_cons (NULL, convert_default_arg (TREE_VALUE (parm), - TREE_PURPOSE (parm), - fn, i++), t); - return build_call (fn, nreverse (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 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, void_type_node, 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, void_type_node, 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 (tree decl) -{ - return is_invisiref_parm (decl); -} |