diff options
author | Andrew Hsieh <andrewhsieh@google.com> | 2012-11-08 09:43:39 -0800 |
---|---|---|
committer | Andrew Hsieh <andrewhsieh@google.com> | 2012-11-08 09:43:39 -0800 |
commit | 3c56f697e112c79fb5457538fdc373e348beca24 (patch) | |
tree | 91987aa2182421ebead7f3bc3e14ae0effd4ba88 /gcc-4.2.1-5666.3/gcc/cp/cp-gimplify.c | |
parent | 8add91f46171be1526e9b37fffcdb7683ad27d77 (diff) | |
download | toolchain_gcc-3c56f697e112c79fb5457538fdc373e348beca24.tar.gz toolchain_gcc-3c56f697e112c79fb5457538fdc373e348beca24.tar.bz2 toolchain_gcc-3c56f697e112c79fb5457538fdc373e348beca24.zip |
Initial checkin of unmodified gcc-5666.3.tar.gz
This is the source to build gcc-4.2 for MacOSX
gcc version 4.2.1 (Apple Inc. build 5666) (dot 3)
http://opensource.apple.com/tarballs/gcc/gcc-5666.3.tar.gz
Change-Id: I69540223f018e9d07f861fca04bd3833fc138f8b
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, 1034 insertions, 0 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 new file mode 100644 index 000000000..f831ad3cc --- /dev/null +++ b/gcc-4.2.1-5666.3/gcc/cp/cp-gimplify.c @@ -0,0 +1,1034 @@ +/* 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); +} |