git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

re PR debug/47106 (-fcompare-debug failure (length) with -fpartial-inlining -flto -fconserve-stack) 

PR debug/47106
PR debug/47402
* tree-inline.h (estimated_stack_frame_size): Take cgraph node
rather than decl.
* cfgexpand.c (estimated_stack_frame_size): Likewise.
* ipa-inline.c (compute_inline_parameters): Adjust.

From-SVN: r170187
This commit is contained in:
Alexandre Oliva 2011-02-15 18:36:44 +00:00 committed by Alexandre Oliva
parent 1b9a784a89
commit 30925d946a
4 changed files with 23 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
gcc/ChangeLog
View File

@ -1,3 +1,12 @@
2011-02-15 Alexandre Oliva <aoliva@redhat.com>
PR debug/47106
PR debug/47402
* tree-inline.h (estimated_stack_frame_size): Take cgraph node
rather than decl.
* cfgexpand.c (estimated_stack_frame_size): Likewise.
* ipa-inline.c (compute_inline_parameters): Adjust.
2011-02-15 Alexandre Oliva <aoliva@redhat.com>
PR debug/47106

21
gcc/cfgexpand.c
View File

@ -1366,24 +1366,25 @@ fini_vars_expansion (void)
stack_vars_alloc = stack_vars_num = 0;
}
/* Make a fair guess for the size of the stack frame of the decl
passed. This doesn't have to be exact, the result is only used
in the inline heuristics. So we don't want to run the full stack
var packing algorithm (which is quadratic in the number of stack
vars). Instead, we calculate the total size of all stack vars.
This turns out to be a pretty fair estimate -- packing of stack
vars doesn't happen very often. */
/* Make a fair guess for the size of the stack frame of the function
in NODE. This doesn't have to be exact, the result is only used in
the inline heuristics. So we don't want to run the full stack var
packing algorithm (which is quadratic in the number of stack vars).
Instead, we calculate the total size of all stack vars. This turns
out to be a pretty fair estimate -- packing of stack vars doesn't
happen very often. */
HOST_WIDE_INT
estimated_stack_frame_size (tree decl)
estimated_stack_frame_size (struct cgraph_node *node)
{
HOST_WIDE_INT size = 0;
size_t i;
tree var, outer_block = DECL_INITIAL (current_function_decl);
unsigned ix;
tree old_cur_fun_decl = current_function_decl;
current_function_decl = decl;
push_cfun (DECL_STRUCT_FUNCTION (decl));
current_function_decl = node->decl;
push_cfun (DECL_STRUCT_FUNCTION (node->decl));
init_vars_expansion ();

5
gcc/ipa-inline.c
View File

@ -1982,9 +1982,8 @@ compute_inline_parameters (struct cgraph_node *node)
gcc_assert (!node->global.inlined_to);
/* Estimate the stack size for the function. But not at -O0
because estimated_stack_frame_size is a quadratic problem. */
self_stack_size = optimize ? estimated_stack_frame_size (node->decl) : 0;
/* Estimate the stack size for the function if we're optimizing. */
self_stack_size = optimize ? estimated_stack_frame_size (node) : 0;
inline_summary (node)->estimated_self_stack_size = self_stack_size;
node->global.estimated_stack_size = self_stack_size;
node->global.stack_frame_offset = 0;

2
gcc/tree-inline.h
View File

@ -188,6 +188,6 @@ extern tree remap_decl (tree decl, copy_body_data *id);
extern tree remap_type (tree type, copy_body_data *id);
extern gimple_seq copy_gimple_seq_and_replace_locals (gimple_seq seq);
extern HOST_WIDE_INT estimated_stack_frame_size (tree);
extern HOST_WIDE_INT estimated_stack_frame_size (struct cgraph_node *);
#endif /* GCC_TREE_INLINE_H */