From 5e20bdd7298dfa02e6908bbba92bfd7e3e994025 Mon Sep 17 00:00:00 2001 From: Josef Zlomek Date: Sun, 22 Feb 2004 19:48:42 +0100 Subject: [PATCH] backport: tree-inline.c (insert_decl_map): New. Merge from tree-ssa: 2003-11-20 Richard Henderson * tree-inline.c (insert_decl_map): New. (remap_decl, remap_type, remap_block, copy_body_r, initialize_inlined_parameters, declare_return_variable, remap_save_expr): Use it. * function.c (copy_body_r): Add mapping from id->ret_label to id->ret_label. Revert test for ret_label. From-SVN: r78271 --- gcc/ChangeLog | 13 ++++++++ gcc/tree-inline.c | 75 +++++++++++++++++++++++++---------------------- 2 files changed, 53 insertions(+), 35 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 8377d279989..77442759de7 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2004-02-22 Josef Zlomek + + Merge from tree-ssa: + 2003-11-20 Richard Henderson + + * tree-inline.c (insert_decl_map): New. + (remap_decl, remap_type, remap_block, copy_body_r, + initialize_inlined_parameters, declare_return_variable, + remap_save_expr): Use it. + + * function.c (copy_body_r): Add mapping from id->ret_label to + id->ret_label. Revert test for ret_label. + 2004-02-22 Jakub Jelinek * genoutput.c (process_template): Strip trailing whitespace in @ diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c index 42da58b29f2..3ef97051ebc 100644 --- a/gcc/tree-inline.c +++ b/gcc/tree-inline.c @@ -128,6 +128,22 @@ static void remap_block (tree *, tree, inline_data *); static tree add_stmt_to_compound (tree, tree, tree); #endif /* INLINER_FOR_JAVA */ +/* Insert a tree->tree mapping for ID. Despite the name suggests + that the trees should be variables, it is used for more than that. */ + +static void +insert_decl_map (inline_data *id, tree key, tree value) +{ + splay_tree_insert (id->decl_map, (splay_tree_key) key, + (splay_tree_value) value); + + /* Always insert an identity map as well. If we see this same new + node again, we won't want to duplicate it a second time. */ + if (key != value) + splay_tree_insert (id->decl_map, (splay_tree_key) value, + (splay_tree_value) value); +} + /* Remap DECL during the copying of the BLOCK tree for the function. */ static tree @@ -189,9 +205,8 @@ remap_decl (tree decl, inline_data *id) /* Remember it, so that if we encounter this local entity again we can reuse this copy. */ - n = splay_tree_insert (id->decl_map, - (splay_tree_key) decl, - (splay_tree_value) t); + insert_decl_map (id, decl, t); + return t; } return (tree) n->value; @@ -214,15 +229,13 @@ remap_type (tree type, inline_data *id) /* The type only needs remapping if it's variably modified. */ if (! variably_modified_type_p (type)) { - splay_tree_insert (id->decl_map, (splay_tree_key) type, - (splay_tree_value) type); + insert_decl_map (id, type, type); return type; } /* We do need a copy. build and register it now. */ new = copy_node (type); - splay_tree_insert (id->decl_map, (splay_tree_key) type, - (splay_tree_value) new); + insert_decl_map (id, type, new); /* This is a new type, not a copy of an old type. Need to reassociate variants. We can handle everything except the main variant lazily. */ @@ -392,9 +405,7 @@ remap_block (tree *block, tree decls, inline_data *id) *first_block = new_block; } /* Remember the remapped block. */ - splay_tree_insert (id->decl_map, - (splay_tree_key) old_block, - (splay_tree_value) new_block); + insert_decl_map (id, old_block, new_block); } /* If this is the end of a scope, set the SCOPE_STMT_BLOCK to be the remapped block. */ @@ -568,15 +579,16 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) /* If we're not returning anything just do the jump. */ else *tp = goto_stmt; + + /* We can't replace return label while inlining function + because it is in the outer function. */ + insert_decl_map (id, id->ret_label, id->ret_label); } /* Local variables and labels need to be replaced by equivalent variables. We don't want to copy static variables; there's only one of those, no matter how many times we inline the containing - function. - We do not also want to copy the label which we put into - GOTO_STMT which replaced RETURN_STMT. */ - else if (*tp != id->ret_label - && (*lang_hooks.tree_inlining.auto_var_in_fn_p) (*tp, fn)) + function. */ + else if ((*lang_hooks.tree_inlining.auto_var_in_fn_p) (*tp, fn)) { tree new_decl; @@ -611,9 +623,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data) will refer to it, so save a copy ready for remapping. We save it in the decl_map, although it isn't a decl. */ tree new_block = copy_node (*tp); - splay_tree_insert (id->decl_map, - (splay_tree_key) *tp, - (splay_tree_value) new_block); + insert_decl_map (id, *tp, new_block); *tp = new_block; } else if (TREE_CODE (*tp) == EXIT_BLOCK_EXPR) @@ -784,9 +794,7 @@ DECL_ARGUMENTS (fn); else if (TREE_TYPE (value) != TREE_TYPE (p)) value = fold (build1 (NOP_EXPR, TREE_TYPE (p), value)); - splay_tree_insert (id->decl_map, - (splay_tree_key) p, - (splay_tree_value) value); + insert_decl_map (id, p, value); continue; } } @@ -807,9 +815,7 @@ DECL_ARGUMENTS (fn); /* Register the VAR_DECL as the equivalent for the PARM_DECL; that way, when the PARM_DECL is encountered, it will be automatically replaced by the VAR_DECL. */ - splay_tree_insert (id->decl_map, - (splay_tree_key) p, - (splay_tree_value) var_sub); + insert_decl_map (id, p, var_sub); /* Declare this new variable. */ #ifndef INLINER_FOR_JAVA @@ -947,9 +953,7 @@ declare_return_variable (struct inline_data *id, tree return_slot_addr, /* Register the VAR_DECL as the equivalent for the RESULT_DECL; that way, when the RESULT_DECL is encountered, it will be automatically replaced by the VAR_DECL. */ - splay_tree_insert (id->decl_map, - (splay_tree_key) result, - (splay_tree_value) var); + insert_decl_map (id, result, var); /* Build the USE_STMT. If the return type of the function was promoted, convert it back to the expected type. */ @@ -2005,6 +2009,7 @@ remap_save_expr (tree *tp, void *st_, tree fn, int *walk_subtrees) { splay_tree st = (splay_tree) st_; splay_tree_node n; + tree t; /* See if we already encountered this SAVE_EXPR. */ n = splay_tree_lookup (st, (splay_tree_key) *tp); @@ -2012,7 +2017,7 @@ remap_save_expr (tree *tp, void *st_, tree fn, int *walk_subtrees) /* If we didn't already remap this SAVE_EXPR, do so now. */ if (!n) { - tree t = copy_node (*tp); + t = copy_node (*tp); /* The SAVE_EXPR is now part of the function into which we are inlining this body. */ @@ -2020,19 +2025,19 @@ remap_save_expr (tree *tp, void *st_, tree fn, int *walk_subtrees) /* And we haven't evaluated it yet. */ SAVE_EXPR_RTL (t) = NULL_RTX; /* Remember this SAVE_EXPR. */ - n = splay_tree_insert (st, - (splay_tree_key) *tp, - (splay_tree_value) t); + splay_tree_insert (st, (splay_tree_key) *tp, (splay_tree_value) t); /* Make sure we don't remap an already-remapped SAVE_EXPR. */ splay_tree_insert (st, (splay_tree_key) t, (splay_tree_value) t); } else - /* We've already walked into this SAVE_EXPR, so we needn't do it - again. */ - *walk_subtrees = 0; + { + /* We've already walked into this SAVE_EXPR; don't do it again. */ + *walk_subtrees = 0; + t = (tree) n->value; + } /* Replace this SAVE_EXPR with the copy. */ - *tp = (tree) n->value; + *tp = t; } #ifdef INLINER_FOR_JAVA -- 2.30.2