FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

tree-inline.c (initialize_inlined_parameters): Pass proper function context to gimplify_body.

Browse source 
* tree-inline.c (initialize_inlined_parameters): Pass proper function
	context to gimplify_body.
	(walk_tree): Don't walk into types twice.
	(walk_tree, case POINTER_TYPE): Deal with mutually recursive pointers.

From-SVN: r84058
This commit is contained in:
Richard Kenner 2004-07-03 14:48:14 +00:00 • committed by Richard Kenner
parent 51fa2e5fc3
commit 83e113ae50
2 changed files with 37 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
gcc/ChangeLog
View file

@ -1,5 +1,10 @@
2004-07-03 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
* tree-inline.c (initialize_inlined_parameters): Pass proper function
context to gimplify_body.
(walk_tree): Don't walk into types twice.
(walk_tree, case POINTER_TYPE): Deal with mutually recursive pointers.
* tree-sra.c (generate_element_init): Remove any useless conversions.
* gimplify.c (gimplify_conversion): Remove stripping useless

42
gcc/tree-inline.c
View file

@ -863,7 +863,7 @@ initialize_inlined_parameters (inline_data *id, tree args, tree static_chain,
}
if (gimplify_init_stmts_p && lang_hooks.gimple_before_inlining)
gimplify_body (&init_stmts, fn);
gimplify_body (&init_stmts, current_function_decl);
declare_inline_vars (bind_expr, vars);
return init_stmts;
@ -2038,19 +2038,19 @@ walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_)
tree decl = DECL_EXPR_DECL (*tp);
tree type = TREE_TYPE (decl);
/* Walk into fields of the DECL if it's not a type, then into fields
of the type in both cases. */
if (TREE_CODE (decl) != TYPE_DECL
&& TREE_CODE (decl) != FIELD_DECL && TREE_CODE (decl) != PARM_DECL)
/* Walk into fields of the DECL if it's not a type. */
if (TREE_CODE (decl) != TYPE_DECL)
{
WALK_SUBTREE (DECL_INITIAL (decl));
if (TREE_CODE (decl) != FIELD_DECL && TREE_CODE (decl) != PARM_DECL)
WALK_SUBTREE (DECL_INITIAL (decl));
WALK_SUBTREE (DECL_SIZE (decl));
WALK_SUBTREE (DECL_SIZE_UNIT (decl));
WALK_SUBTREE_TAIL (DECL_SIZE_UNIT (decl));
}
/* First do the common fields via recursion, then the fields we only
do when we are declaring the type or object. */
/* Otherwise, we are declaring a type. First do the common fields via
recursion, then the fields we only do when we are declaring the type
or object. */
WALK_SUBTREE (type);
WALK_SUBTREE (TYPE_SIZE (type));
WALK_SUBTREE (TYPE_SIZE_UNIT (type));
@ -2198,6 +2198,28 @@ walk_tree (tree *tp, walk_tree_fn func, void *data, void *htab_)
case POINTER_TYPE:
case REFERENCE_TYPE:
/* We have to worry about mutually recursive pointers. These can't
be written in C. They can in Ada. It's pathlogical, but
there's an ACATS test (c38102a) that checks it. Deal with this
by checking if we're pointing to another pointer, that one
points to another pointer, that one does too, and we have no htab.
If so, get a hash table. We check three levels deep to avoid
the cost of the hash table if we don't need one. */
if (POINTER_TYPE_P (TREE_TYPE (*tp))
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*tp)))
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (*tp))))
&& !htab)
{
result = walk_tree_without_duplicates (&TREE_TYPE (*tp),
func, data);
if (result)
return result;
break;
}
/* ... fall through ... */
case COMPLEX_TYPE:
WALK_SUBTREE_TAIL (TREE_TYPE (*tp));
break;