+2007-08-20 Richard Guenther <rguenther@suse.de>
+
+ * 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 <andrew_pinski@playstation.sony.com>
PR middle-end/30564
+2007-08-20 Richard Guenther <rguenther@suse.de>
+
+ * 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 <jakub@redhat.com>
PR c++/33025
/* 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. */
#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
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);
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);
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;
}
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);
}
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
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);
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;
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;
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;
}
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)
{
{
/* 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);
}
}
/* 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. */
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)
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)
}
/* 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. */
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);
}
\f
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;
}
{
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);
}
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)
{
#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)
+2007-08-20 Richard Guenther <rguenther@suse.de>
+
+ * lang.c (java_tree_inlining_walk_subtrees): Remove.
+ (LANG_HOOKS_TREE_INLINING_WALK_SUBTREES): Remove.
+
2007-08-17 Tom Tromey <tromey@redhat.com>
* typeck.c (find_method_in_interfaces): Update.
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);
#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
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
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);
#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 \
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, \
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. */
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);
#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; \
} \
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;
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;
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)
{
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;
}
/* 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;
}
/* 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;
}
/* 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. */
projects / gcc.git / commitdiff