From 20a8f962f826727be1912aaeb411681561241240 Mon Sep 17 00:00:00 2001 From: rguenth Date: Mon, 20 Aug 2007 11:19:22 +0000 Subject: [PATCH] 2007-08-20 Richard Guenther * tree.c (WALK_SUBTREE): Call walk_tree_1. (walk_type_fields): Take lh parameter. (walk_tree): Rename to ... (walk_tree_1): ... this. Do not call the walk_subtrees langhook but the now passed callback. Pass lh on recursion. (walk_tree_without_duplicates): Rename to ... (walk_tree_without_duplicates_1): ... this. Take lh parameter and call walk_tree_1. * tree.h (walk_tree_lh): New typedef. (walk_tree_1): Declare. (walk_tree_without_duplicates_1): Likewise. (walk_tree): New define to walk_tree_1 with NULL lh parameter. (walk_tree_without_duplicates): New define to walk_tree_without_duplicates_1 with NULL lh parameter. * langhooks.c (lhd_tree_inlining_walk_subtrees): Remove. * langhooks.h (lang_hooks_for_tree_inlining): Remove walk_subtrees langhook. * langhooks-def.h (lhd_tree_inlining_walk_subtrees): Remove. (LANG_HOOKS_TREE_INLINING_WALK_SUBTREES): Likewise. (LANG_HOOKS_TREE_INLINING_INITIALIZER): Remove walk_subtrees initializer. java/ * lang.c (java_tree_inlining_walk_subtrees): Remove. (LANG_HOOKS_TREE_INLINING_WALK_SUBTREES): Remove. cp/ * cp-objcp-common.h (LANG_HOOKS_TREE_INLINING_WALK_SUBTREES): Remove define. * tree.h (cp_walk_tree): New define to walk_tree_1 with cp_walk_subtrees lh parameter. (cp_walk_tree_without_duplicates): New define to walk_tree_without_duplicates_1 with cp_walk_subtrees lh parameter. * tree.c (count_trees): Call cp_walk_tree_without_duplicates. (verify_stmt_tree): Call cp_walk_tree. (break_out_target_exprs): Likewise. (WALK_SUBTREE): Likewise. * cp-gimplify.c (cp_genericize): Likewise. * cp-pt.c (find_parameter_packs_r): Likewise. (uses_parameter_packs): Likewise. (make_pack_expansion): Likewise. (check_for_bare_parameter_packs): Likewise. (for_each_template_parm): Likewise. * decl.c (check_default_argument): Call cp_walk_tree_without_duplicates. * except.c (build_throw): Likewise. * decl2.c (type_visibility): Likewise. * semantics.c (expand_or_defer_fn): Likewise. (finalize_nrv): Call cp_walk_tree. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@127642 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 24 ++++++++++++++++++++++++ gcc/cp/ChangeLog | 26 ++++++++++++++++++++++++++ gcc/cp/cp-gimplify.c | 2 +- gcc/cp/cp-objcp-common.h | 3 --- gcc/cp/cp-tree.h | 4 ++++ gcc/cp/decl.c | 3 +-- gcc/cp/decl2.c | 2 +- gcc/cp/except.c | 2 +- gcc/cp/pt.c | 34 +++++++++++++++++----------------- gcc/cp/semantics.c | 8 ++++---- gcc/cp/tree.c | 10 +++++----- gcc/java/ChangeLog | 5 +++++ gcc/java/lang.c | 44 -------------------------------------------- gcc/langhooks-def.h | 4 ---- gcc/langhooks.c | 21 --------------------- gcc/langhooks.h | 3 --- gcc/tree.c | 26 +++++++++++++++----------- gcc/tree.h | 16 ++++++++++++++-- 18 files changed, 118 insertions(+), 119 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 6f486f8..2e090c1 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,27 @@ +2007-08-20 Richard Guenther + + * tree.c (WALK_SUBTREE): Call walk_tree_1. + (walk_type_fields): Take lh parameter. + (walk_tree): Rename to ... + (walk_tree_1): ... this. Do not call the walk_subtrees + langhook but the now passed callback. Pass lh on recursion. + (walk_tree_without_duplicates): Rename to ... + (walk_tree_without_duplicates_1): ... this. Take lh parameter + and call walk_tree_1. + * tree.h (walk_tree_lh): New typedef. + (walk_tree_1): Declare. + (walk_tree_without_duplicates_1): Likewise. + (walk_tree): New define to walk_tree_1 with NULL lh parameter. + (walk_tree_without_duplicates): New define to + walk_tree_without_duplicates_1 with NULL lh parameter. + * langhooks.c (lhd_tree_inlining_walk_subtrees): Remove. + * langhooks.h (lang_hooks_for_tree_inlining): Remove walk_subtrees + langhook. + * langhooks-def.h (lhd_tree_inlining_walk_subtrees): Remove. + (LANG_HOOKS_TREE_INLINING_WALK_SUBTREES): Likewise. + (LANG_HOOKS_TREE_INLINING_INITIALIZER): Remove walk_subtrees + initializer. + 2007-08-20 Andrew Pinski PR middle-end/30564 diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index b12b785..d9dbda9 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,29 @@ +2007-08-20 Richard Guenther + + * cp-objcp-common.h (LANG_HOOKS_TREE_INLINING_WALK_SUBTREES): + Remove define. + * tree.h (cp_walk_tree): New define to walk_tree_1 with + cp_walk_subtrees lh parameter. + (cp_walk_tree_without_duplicates): New define to + walk_tree_without_duplicates_1 with cp_walk_subtrees lh parameter. + * tree.c (count_trees): Call + cp_walk_tree_without_duplicates. + (verify_stmt_tree): Call cp_walk_tree. + (break_out_target_exprs): Likewise. + (WALK_SUBTREE): Likewise. + * cp-gimplify.c (cp_genericize): Likewise. + * cp-pt.c (find_parameter_packs_r): Likewise. + (uses_parameter_packs): Likewise. + (make_pack_expansion): Likewise. + (check_for_bare_parameter_packs): Likewise. + (for_each_template_parm): Likewise. + * decl.c (check_default_argument): Call + cp_walk_tree_without_duplicates. + * except.c (build_throw): Likewise. + * decl2.c (type_visibility): Likewise. + * semantics.c (expand_or_defer_fn): Likewise. + (finalize_nrv): Call cp_walk_tree. + 2007-08-20 Jakub Jelinek PR c++/33025 diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c index c83fcae..6fcc9b0 100644 --- a/gcc/cp/cp-gimplify.c +++ b/gcc/cp/cp-gimplify.c @@ -746,7 +746,7 @@ cp_genericize (tree fndecl) /* 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); + cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, p_set, NULL); pointer_set_destroy (p_set); /* Do everything else. */ diff --git a/gcc/cp/cp-objcp-common.h b/gcc/cp/cp-objcp-common.h index 2c6267a..9cff31b 100644 --- a/gcc/cp/cp-objcp-common.h +++ b/gcc/cp/cp-objcp-common.h @@ -104,9 +104,6 @@ extern tree objcp_tsubst_copy_and_build (tree, tree, tsubst_flags_t, #undef LANG_HOOKS_ATTRIBUTE_TABLE #define LANG_HOOKS_ATTRIBUTE_TABLE cxx_attribute_table -#undef LANG_HOOKS_TREE_INLINING_WALK_SUBTREES -#define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES \ - cp_walk_subtrees #undef LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN #define LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN \ cp_cannot_inline_tree_fn diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index a80fbad..c35bb95 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -4736,6 +4736,10 @@ extern void verify_stmt_tree (tree); extern linkage_kind decl_linkage (tree); extern tree cp_walk_subtrees (tree*, int*, walk_tree_fn, void*, struct pointer_set_t*); +#define cp_walk_tree(a,b,c,d) \ + walk_tree_1 (a, b, c, d, cp_walk_subtrees) +#define cp_walk_tree_without_duplicates(a,b,c) \ + walk_tree_without_duplicates_1 (a, b, c, cp_walk_subtrees) extern int cp_cannot_inline_tree_fn (tree*); extern int cp_auto_var_in_fn_p (const_tree, const_tree); extern tree fold_if_not_in_template (tree); diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 6172296..a890ee1 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -9061,8 +9061,7 @@ check_default_argument (tree decl, tree arg) The keyword `this' shall not be used in a default argument of a member function. */ - var = walk_tree_without_duplicates (&arg, local_variable_p_walkfn, - NULL); + var = cp_walk_tree_without_duplicates (&arg, local_variable_p_walkfn, NULL); if (var) { error ("default argument %qE uses local variable %qD", arg, var); diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c index d66b731..97a03c7 100644 --- a/gcc/cp/decl2.c +++ b/gcc/cp/decl2.c @@ -1561,7 +1561,7 @@ static int type_visibility (tree type) { int vis = VISIBILITY_DEFAULT; - walk_tree_without_duplicates (&type, min_vis_r, &vis); + cp_walk_tree_without_duplicates (&type, min_vis_r, &vis); return vis; } diff --git a/gcc/cp/except.c b/gcc/cp/except.c index b5c93b4..081dd0f 100644 --- a/gcc/cp/except.c +++ b/gcc/cp/except.c @@ -782,7 +782,7 @@ build_throw (tree exp) we don't have to do them during unwinding. But first wrap them in MUST_NOT_THROW_EXPR, since they are run after the exception object is initialized. */ - walk_tree_without_duplicates (&temp_expr, wrap_cleanups_r, 0); + cp_walk_tree_without_duplicates (&temp_expr, wrap_cleanups_r, 0); exp = build2 (COMPOUND_EXPR, TREE_TYPE (exp), temp_expr, exp); exp = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp); } diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 76d3518..3f218e6 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -2391,7 +2391,7 @@ find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data) if (TYPE_P (t)) { tree context = TYPE_CONTEXT (t); - walk_tree (&context, &find_parameter_packs_r, ppd, ppd->visited); + cp_walk_tree (&context, &find_parameter_packs_r, ppd, ppd->visited); } /* This switch statement will return immediately if we don't find a @@ -2405,8 +2405,8 @@ find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data) case BOUND_TEMPLATE_TEMPLATE_PARM: /* Check the template arguments. */ - walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd, - ppd->visited); + cp_walk_tree (&TYPE_TI_ARGS (t), &find_parameter_packs_r, ppd, + ppd->visited); /* Dig out the underlying TEMPLATE_TEMPLATE_PARM. */ t = TYPE_TI_TEMPLATE (t); @@ -2442,7 +2442,7 @@ find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data) if (TYPE_TEMPLATE_INFO (t)) { tree args = TREE_VALUE (TYPE_TEMPLATE_INFO (t)); - walk_tree (&args, &find_parameter_packs_r, ppd, ppd->visited); + cp_walk_tree (&args, &find_parameter_packs_r, ppd, ppd->visited); } *walk_subtrees = 0; @@ -2462,8 +2462,8 @@ find_parameter_packs_r (tree *tp, int *walk_subtrees, void* data) return NULL_TREE; case INTEGER_TYPE: - walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r, - ppd, ppd->visited); + cp_walk_tree (&TYPE_MAX_VALUE (t), &find_parameter_packs_r, + ppd, ppd->visited); *walk_subtrees = 0; return NULL_TREE; @@ -2485,7 +2485,7 @@ uses_parameter_packs (tree t) struct find_parameter_pack_data ppd; ppd.parameter_packs = ¶meter_packs; ppd.visited = pointer_set_create (); - walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited); + cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited); pointer_set_destroy (ppd.visited); return parameter_packs != NULL_TREE; } @@ -2535,8 +2535,8 @@ make_pack_expansion (tree arg) class expansion. */ ppd.visited = pointer_set_create (); ppd.parameter_packs = ¶meter_packs; - walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r, - &ppd, ppd.visited); + cp_walk_tree (&TREE_PURPOSE (arg), &find_parameter_packs_r, + &ppd, ppd.visited); if (parameter_packs == NULL_TREE) { @@ -2553,8 +2553,8 @@ make_pack_expansion (tree arg) { /* Determine which parameter packs will be expanded in this argument. */ - walk_tree (&TREE_VALUE (value), &find_parameter_packs_r, - &ppd, ppd.visited); + cp_walk_tree (&TREE_VALUE (value), &find_parameter_packs_r, + &ppd, ppd.visited); } } @@ -2592,7 +2592,7 @@ make_pack_expansion (tree arg) /* Determine which parameter packs will be expanded. */ ppd.parameter_packs = ¶meter_packs; ppd.visited = pointer_set_create (); - walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited); + cp_walk_tree (&arg, &find_parameter_packs_r, &ppd, ppd.visited); pointer_set_destroy (ppd.visited); /* Make sure we found some parameter packs. */ @@ -2637,7 +2637,7 @@ check_for_bare_parameter_packs (tree t) ppd.parameter_packs = ¶meter_packs; ppd.visited = pointer_set_create (); - walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited); + cp_walk_tree (&t, &find_parameter_packs_r, &ppd, ppd.visited); pointer_set_destroy (ppd.visited); if (parameter_packs) @@ -5896,10 +5896,10 @@ for_each_template_parm (tree t, tree_fn_t fn, void* data, pfd.visited = visited; else pfd.visited = pointer_set_create (); - result = walk_tree (&t, - for_each_template_parm_r, - &pfd, - pfd.visited) != NULL_TREE; + result = cp_walk_tree (&t, + for_each_template_parm_r, + &pfd, + pfd.visited) != NULL_TREE; /* Clean up. */ if (!visited) diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index 9d0f9df..176e6be 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -3184,9 +3184,9 @@ expand_or_defer_fn (tree fn) } /* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs. */ - walk_tree_without_duplicates (&DECL_SAVED_TREE (fn), - simplify_aggr_init_exprs_r, - NULL); + cp_walk_tree_without_duplicates (&DECL_SAVED_TREE (fn), + simplify_aggr_init_exprs_r, + NULL); /* If this is a constructor or destructor body, we have to clone it. */ @@ -3336,7 +3336,7 @@ finalize_nrv (tree *tp, tree var, tree result) data.var = var; data.result = result; data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL); - walk_tree (tp, finalize_nrv_r, &data, 0); + cp_walk_tree (tp, finalize_nrv_r, &data, 0); htab_delete (data.visited); } diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c index 1d16f2c..3edf39f 100644 --- a/gcc/cp/tree.c +++ b/gcc/cp/tree.c @@ -1282,7 +1282,7 @@ int count_trees (tree t) { int n_trees = 0; - walk_tree_without_duplicates (&t, count_trees_r, &n_trees); + cp_walk_tree_without_duplicates (&t, count_trees_r, &n_trees); return n_trees; } @@ -1319,7 +1319,7 @@ verify_stmt_tree (tree t) { htab_t statements; statements = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL); - walk_tree (&t, verify_stmt_tree_r, &statements, NULL); + cp_walk_tree (&t, verify_stmt_tree_r, &statements, NULL); htab_delete (statements); } @@ -1521,8 +1521,8 @@ break_out_target_exprs (tree t) target_remap = splay_tree_new (splay_tree_compare_pointers, /*splay_tree_delete_key_fn=*/NULL, /*splay_tree_delete_value_fn=*/NULL); - walk_tree (&t, bot_manip, target_remap, NULL); - walk_tree (&t, bot_replace, target_remap, NULL); + cp_walk_tree (&t, bot_manip, target_remap, NULL); + cp_walk_tree (&t, bot_replace, target_remap, NULL); if (!--target_remap_count) { @@ -2290,7 +2290,7 @@ cp_walk_subtrees (tree *tp, int *walk_subtrees_p, walk_tree_fn func, #define WALK_SUBTREE(NODE) \ do \ { \ - result = walk_tree (&(NODE), func, data, pset); \ + result = cp_walk_tree (&(NODE), func, data, pset); \ if (result) goto out; \ } \ while (0) diff --git a/gcc/java/ChangeLog b/gcc/java/ChangeLog index cd919b3..693053b 100644 --- a/gcc/java/ChangeLog +++ b/gcc/java/ChangeLog @@ -1,3 +1,8 @@ +2007-08-20 Richard Guenther + + * lang.c (java_tree_inlining_walk_subtrees): Remove. + (LANG_HOOKS_TREE_INLINING_WALK_SUBTREES): Remove. + 2007-08-17 Tom Tromey * typeck.c (find_method_in_interfaces): Update. diff --git a/gcc/java/lang.c b/gcc/java/lang.c index ffb64d8..dc685eb 100644 --- a/gcc/java/lang.c +++ b/gcc/java/lang.c @@ -55,8 +55,6 @@ static int java_handle_option (size_t scode, const char *arg, int value); static void put_decl_string (const char *, int); static void put_decl_node (tree); static void java_print_error_function (diagnostic_context *, const char *); -static tree java_tree_inlining_walk_subtrees (tree *, int *, walk_tree_fn, - void *, struct pointer_set_t *); static int merge_init_test_initialization (void * *, void *); static int inline_init_test_initialization (void * *, void *); static bool java_dump_tree (void *, tree); @@ -188,9 +186,6 @@ struct language_function GTY(()) #undef LANG_HOOKS_GIMPLIFY_EXPR #define LANG_HOOKS_GIMPLIFY_EXPR java_gimplify_expr -#undef LANG_HOOKS_TREE_INLINING_WALK_SUBTREES -#define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES java_tree_inlining_walk_subtrees - #undef LANG_HOOKS_DECL_OK_FOR_SIBCALL #define LANG_HOOKS_DECL_OK_FOR_SIBCALL java_decl_ok_for_sibcall @@ -688,45 +683,6 @@ decl_constant_value (tree decl) return decl; } -/* Walk the language specific tree nodes during inlining. */ - -static tree -java_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED, - int *subtrees ATTRIBUTE_UNUSED, - walk_tree_fn func ATTRIBUTE_UNUSED, - void *data ATTRIBUTE_UNUSED, - struct pointer_set_t *pset ATTRIBUTE_UNUSED) -{ - enum tree_code code; - tree result; - -#define WALK_SUBTREE(NODE) \ - do \ - { \ - result = walk_tree (&(NODE), func, data, pset); \ - if (result) \ - return result; \ - } \ - while (0) - - tree t = *tp; - if (!t) - return NULL_TREE; - - code = TREE_CODE (t); - switch (code) - { - case BLOCK: - WALK_SUBTREE (BLOCK_EXPR_BODY (t)); - return NULL_TREE; - - default: - return NULL_TREE; - } - - #undef WALK_SUBTREE -} - /* Every call to a static constructor has an associated boolean variable which is in the outermost scope of the calling method. This variable is used to avoid multiple calls to the static diff --git a/gcc/langhooks-def.h b/gcc/langhooks-def.h index 41bf8e8..074e615 100644 --- a/gcc/langhooks-def.h +++ b/gcc/langhooks-def.h @@ -68,8 +68,6 @@ extern tree lhd_expr_to_decl (tree, bool *, bool *, bool *); extern tree lhd_builtin_function (tree decl); /* Declarations of default tree inlining hooks. */ -extern tree lhd_tree_inlining_walk_subtrees (tree *, int *, walk_tree_fn, - void *, struct pointer_set_t*); extern int lhd_tree_inlining_cannot_inline_tree_fn (tree *); extern int lhd_tree_inlining_disregard_inline_limits (const_tree); extern int lhd_tree_inlining_auto_var_in_fn_p (const_tree, const_tree); @@ -135,7 +133,6 @@ extern void lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *, #define LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE NULL /* Tree inlining hooks. */ -#define LANG_HOOKS_TREE_INLINING_WALK_SUBTREES lhd_tree_inlining_walk_subtrees #define LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN \ lhd_tree_inlining_cannot_inline_tree_fn #define LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS \ @@ -146,7 +143,6 @@ extern void lhd_omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *, hook_bool_tree_tree_false #define LANG_HOOKS_TREE_INLINING_INITIALIZER { \ - LANG_HOOKS_TREE_INLINING_WALK_SUBTREES, \ LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN, \ LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS, \ LANG_HOOKS_TREE_INLINING_AUTO_VAR_IN_FN_P, \ diff --git a/gcc/langhooks.c b/gcc/langhooks.c index 1074615..8260b31 100644 --- a/gcc/langhooks.c +++ b/gcc/langhooks.c @@ -276,27 +276,6 @@ lhd_types_compatible_p (tree x, tree y) return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); } -/* lang_hooks.tree_inlining.walk_subtrees is called by walk_tree() - after handling common cases, but before walking code-specific - sub-trees. If this hook is overridden for a language, it should - handle language-specific tree codes, as well as language-specific - information associated to common tree codes. If a tree node is - completely handled within this function, it should set *SUBTREES to - 0, so that generic handling isn't attempted. The generic handling - cannot deal with language-specific tree codes, so make sure it is - set properly. Both SUBTREES and *SUBTREES is guaranteed to be - nonzero when the function is called. */ - -tree -lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED, - int *subtrees ATTRIBUTE_UNUSED, - walk_tree_fn func ATTRIBUTE_UNUSED, - void *data ATTRIBUTE_UNUSED, - struct pointer_set_t *pset ATTRIBUTE_UNUSED) -{ - return NULL_TREE; -} - /* lang_hooks.tree_inlining.cannot_inline_tree_fn is called to determine whether there are language-specific reasons for not inlining a given function. */ diff --git a/gcc/langhooks.h b/gcc/langhooks.h index a62c615..299ec8f 100644 --- a/gcc/langhooks.h +++ b/gcc/langhooks.h @@ -35,9 +35,6 @@ typedef void (*lang_print_tree_hook) (FILE *, tree, int indent); struct lang_hooks_for_tree_inlining { - tree (*walk_subtrees) (tree *, int *, - tree (*) (tree *, int *, void *), - void *, struct pointer_set_t*); int (*cannot_inline_tree_fn) (tree *); int (*disregard_inline_limits) (const_tree); int (*auto_var_in_fn_p) (const_tree, const_tree); diff --git a/gcc/tree.c b/gcc/tree.c index b6b339c..61f17de 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -8233,7 +8233,7 @@ num_ending_zeros (const_tree x) #define WALK_SUBTREE(NODE) \ do \ { \ - result = walk_tree (&(NODE), func, data, pset); \ + result = walk_tree_1 (&(NODE), func, data, pset, lh); \ if (result) \ return result; \ } \ @@ -8245,7 +8245,7 @@ num_ending_zeros (const_tree x) static tree walk_type_fields (tree type, walk_tree_fn func, void *data, - struct pointer_set_t *pset) + struct pointer_set_t *pset, walk_tree_lh lh) { tree result = NULL_TREE; @@ -8325,7 +8325,8 @@ walk_type_fields (tree type, walk_tree_fn func, void *data, and to avoid visiting a node more than once. */ tree -walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset) +walk_tree_1 (tree *tp, walk_tree_fn func, void *data, + struct pointer_set_t *pset, walk_tree_lh lh) { enum tree_code code; int walk_subtrees; @@ -8372,10 +8373,12 @@ walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset) return NULL_TREE; } - result = lang_hooks.tree_inlining.walk_subtrees (tp, &walk_subtrees, func, - data, pset); - if (result || !walk_subtrees) - return result; + if (lh) + { + result = (*lh) (tp, &walk_subtrees, func, data, pset); + if (result || !walk_subtrees) + return result; + } switch (code) { @@ -8529,7 +8532,7 @@ walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset) if (result || !walk_subtrees) return result; - result = walk_type_fields (*type_p, func, data, pset); + result = walk_type_fields (*type_p, func, data, pset, lh); if (result) return result; @@ -8594,7 +8597,7 @@ walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset) } /* If this is a type, walk the needed fields in the type. */ else if (TYPE_P (*tp)) - return walk_type_fields (*tp, func, data, pset); + return walk_type_fields (*tp, func, data, pset, lh); break; } @@ -8608,13 +8611,14 @@ walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset) /* Like walk_tree, but does not walk duplicate nodes more than once. */ tree -walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data) +walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data, + walk_tree_lh lh) { tree result; struct pointer_set_t *pset; pset = pointer_set_create (); - result = walk_tree (tp, func, data, pset); + result = walk_tree_1 (tp, func, data, pset, lh); pointer_set_destroy (pset); return result; } diff --git a/gcc/tree.h b/gcc/tree.h index 7b62a16..b8e960b 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -5026,8 +5026,20 @@ struct pointer_set_t; /* The type of a callback function for walking over tree structure. */ typedef tree (*walk_tree_fn) (tree *, int *, void *); -extern tree walk_tree (tree*, walk_tree_fn, void*, struct pointer_set_t*); -extern tree walk_tree_without_duplicates (tree*, walk_tree_fn, void*); + +/* The type of a callback function that represents a custom walk_tree. */ + +typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *), + void *, struct pointer_set_t*); + +extern tree walk_tree_1 (tree*, walk_tree_fn, void*, struct pointer_set_t*, + walk_tree_lh); +extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*, + walk_tree_lh); +#define walk_tree(a,b,c,d) \ + walk_tree_1 (a, b, c, d, NULL) +#define walk_tree_without_duplicates(a,b,c) \ + walk_tree_without_duplicates_1 (a, b, c, NULL) /* Assign the RTX to declaration. */ -- 2.7.4