This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [rfc] Whole program optimization
> On Thu, May 26, 2005 at 06:46:33PM -0700, Geoffrey Keating wrote:
> > > I remember that we discussed this with Richard while past and Richard
> > > argued that ELF visibility flags should be used instead. I don't have
> > > archive of the disucssion and I am not quite convinced that this is
> > > possible (this is quite ortoghonal issue to the visibility outside
> > > linked object), so if I miss something here, please enlighten me.
> >
> > I believe that the idea here was that instead of
> > __attribute__((used)), you would use
> > __attribute__((visibility("default"))) or
> > __attribute__((visibility("hidden"))) or
> > __attribute__((visibility("protected"))). That is, this new functionality
> > would be equivalent to saying -fvisibility=internal.
>
> Indeed. The point is that we have existing options to control
> visibility of symbols. We do not need another.
OK,
here is updated patch that makes unit-at-a-time to thread
VISIBILITY_INTERNAL symbols same way as it used to do with globals and
-fwhole-program. It breaks two testcases however:
g++.dg/ext/visibility/pragma-override1.C scan-assembler \\\\.internal.*Foo.methodEv
g++.dg/ext/visibility/pragma-override2.C scan-assembler \\\\.internal.*Foo.methodEv
Since these are emitted as statics now. I am not quite sure if we want
to restore them somehow.
If this seems to make sense, I will proceed with the plan outlined -
making -fvisibility=internal supported on non-ELF systems and
unit-at-a-time mode and making main function immune to any -fvisibility
setting.
Seems to make sense?
Honza
2005-05-26 Jan Hubicka <jh@suse.cz>
* cgraph.c (dump_cgraph_node): Print new flags.
(dump_cgraph_varpool_node): Likewise.
(decide_variable_is_needed): Initialize externally_visible flag.
* cgraph.h (cgraph_local_info): Add externally_visible flag.
(cgraph_varpool_node): Likewise.
(cgraph_function_flags_ready): Declare.
* cgraph.c (cgraph_mark_local_functions): Rename to ...
(cgraph_function_and_variable_visibility) ... this one; handle
externally_visible flags.
(decide_is_function_needed): Set externally_visible flag.
(cgraph_finalize_function): Deal properly with early cleanups.
(cgraph_optimize): Update call of
cgraph_function_and_variable_visibility.
Index: cgraph.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cgraph.c,v
retrieving revision 1.74
diff -c -3 -p -r1.74 cgraph.c
*** cgraph.c 27 May 2005 21:17:48 -0000 1.74
--- cgraph.c 28 May 2005 14:34:00 -0000
*************** dump_cgraph_node (FILE *f, struct cgraph
*** 582,591 ****
--- 582,597 ----
fprintf (f, " output");
if (node->local.local)
fprintf (f, " local");
+ if (node->local.externally_visible)
+ fprintf (f, " externally_visible");
+ if (node->local.finalized)
+ fprintf (f, " finalized");
if (node->local.disregard_inline_limits)
fprintf (f, " always_inline");
else if (node->local.inlinable)
fprintf (f, " inlinable");
+ if (node->local.redefined_extern_inline)
+ fprintf (f, " redefined_extern_inline");
if (TREE_ASM_WRITTEN (node->decl))
fprintf (f, " asm_written");
*************** dump_cgraph_varpool_node (FILE *f, struc
*** 639,644 ****
--- 645,652 ----
fprintf (f, " finalized");
if (node->output)
fprintf (f, " output");
+ if (node->externally_visible)
+ fprintf (f, " externally_visible");
fprintf (f, "\n");
}
*************** decide_is_variable_needed (struct cgraph
*** 786,793 ****
if (node->needed)
return true;
! /* Externally visible functions must be output. The exception is
! COMDAT functions that must be output only when they are needed. */
if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
return true;
--- 794,801 ----
if (node->needed)
return true;
! /* Externally visible variables must be output. The exception is
! COMDAT variables that must be output only when they are needed. */
if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
return true;
*************** cgraph_varpool_finalize_decl (tree decl)
*** 824,829 ****
--- 832,842 ----
if (decide_is_variable_needed (node, decl))
cgraph_varpool_mark_needed_node (node);
+ /* Since we reclaim unrechable nodes at the end of every language
+ level unit, we need to be conservative about possible entry points
+ there. */
+ if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
+ cgraph_varpool_mark_needed_node (node);
if (cgraph_global_info_ready || !flag_unit_at_a_time)
cgraph_varpool_assemble_pending_decls ();
}
Index: cgraph.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cgraph.h,v
retrieving revision 1.55
diff -c -3 -p -r1.55 cgraph.h
*** cgraph.h 27 May 2005 21:17:49 -0000 1.55
--- cgraph.h 28 May 2005 14:34:00 -0000
*************** struct cgraph_local_info GTY(())
*** 36,41 ****
--- 36,44 ----
and its address is never taken. */
bool local;
+ /* Set when function is visible by other units. */
+ bool externally_visible;
+
/* Set once it has been finalized so we consider it to be output. */
bool finalized;
*************** struct cgraph_varpool_node GTY(())
*** 177,182 ****
--- 180,187 ----
bool finalized;
/* Set when function is scheduled to be assembled. */
bool output;
+ /* Set when function is visible by other units. */
+ bool externally_visible;
/* Set for aliases once they got through assemble_alias. */
bool alias;
};
*************** extern GTY(()) struct cgraph_node *cgrap
*** 185,190 ****
--- 190,196 ----
extern GTY(()) int cgraph_n_nodes;
extern GTY(()) int cgraph_max_uid;
extern bool cgraph_global_info_ready;
+ extern bool cgraph_function_flags_ready;
extern GTY(()) struct cgraph_node *cgraph_nodes_queue;
extern GTY(()) struct cgraph_varpool_node *cgraph_varpool_first_unanalyzed_node;
Index: cgraphunit.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cgraphunit.c,v
retrieving revision 1.109
diff -c -3 -p -r1.109 cgraphunit.c
*** cgraphunit.c 27 May 2005 21:17:50 -0000 1.109
--- cgraphunit.c 28 May 2005 14:34:00 -0000
*************** static void cgraph_expand_all_functions
*** 170,176 ****
static void cgraph_mark_functions_to_output (void);
static void cgraph_expand_function (struct cgraph_node *);
static tree record_reference (tree *, int *, void *);
- static void cgraph_mark_local_functions (void);
static void cgraph_analyze_function (struct cgraph_node *node);
/* Records tree nodes seen in record_reference. Simply using
--- 170,175 ----
*************** decide_is_function_needed (struct cgraph
*** 191,196 ****
--- 190,206 ----
{
tree origin;
+ /* If the user told us it is used, then it must be so. */
+ if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
+ return true;
+
+ /* ??? If the assembler name is set by hand, it is possible to assemble
+ the name later after finalizing the function and the fact is noticed
+ in assemble_name then. This is arguably a bug. */
+ if (DECL_ASSEMBLER_NAME_SET_P (decl)
+ && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
+ return true;
+
/* If we decided it was needed before, but at the time we didn't have
the body of the function available, then it's still needed. We have
to go back and re-check its dependencies now. */
*************** decide_is_function_needed (struct cgraph
*** 199,205 ****
/* Externally visible functions must be output. The exception is
COMDAT functions that must be output only when they are needed. */
! if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
return true;
/* Constructors and destructors are reachable from the runtime by
--- 209,216 ----
/* Externally visible functions must be output. The exception is
COMDAT functions that must be output only when they are needed. */
! if ((TREE_PUBLIC (decl) && DECL_VISIBILITY (decl) != VISIBILITY_INTERNAL)
! && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
return true;
/* Constructors and destructors are reachable from the runtime by
*************** decide_is_function_needed (struct cgraph
*** 207,223 ****
if (DECL_STATIC_CONSTRUCTOR (decl) || DECL_STATIC_DESTRUCTOR (decl))
return true;
- /* If the user told us it is used, then it must be so. */
- if (lookup_attribute ("used", DECL_ATTRIBUTES (decl)))
- return true;
-
- /* ??? If the assembler name is set by hand, it is possible to assemble
- the name later after finalizing the function and the fact is noticed
- in assemble_name then. This is arguably a bug. */
- if (DECL_ASSEMBLER_NAME_SET_P (decl)
- && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
- return true;
-
if (flag_unit_at_a_time)
return false;
--- 218,223 ----
*************** cgraph_finalize_function (tree decl, boo
*** 422,427 ****
--- 422,433 ----
if (decide_is_function_needed (node, decl))
cgraph_mark_needed_node (node);
+ /* Since we reclaim unrechable nodes at the end of every language
+ level unit, we need to be conservative about possible entry points
+ there. */
+ if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
+ cgraph_mark_reachable_node (node);
+
/* If not unit at a time, go ahead and emit everything we've found
to be reachable at this time. */
if (!nested)
*************** cgraph_expand_all_functions (void)
*** 1016,1040 ****
free (order);
}
! /* Mark all local functions.
A local function is one whose calls can occur only in the current
compilation unit and all its calls are explicit, so we can change
its calling convention. We simply mark all static functions whose
! address is not taken as local. */
static void
! cgraph_mark_local_functions (void)
{
struct cgraph_node *node;
- /* Figure out functions we want to assemble. */
for (node = cgraph_nodes; node; node = node->next)
{
node->local.local = (!node->needed
! && DECL_SAVED_TREE (node->decl)
! && !TREE_PUBLIC (node->decl));
}
if (cgraph_dump_file)
{
--- 1022,1076 ----
free (order);
}
! /* Mark visibility of all functions.
A local function is one whose calls can occur only in the current
compilation unit and all its calls are explicit, so we can change
its calling convention. We simply mark all static functions whose
! address is not taken as local.
!
! We also change the TREE_PUBLIC flag of all declarations that are public
! in language point of view but we want to overwrite this default
! via visibilities for the backend point of view. */
static void
! cgraph_function_and_variable_visibility (void)
{
struct cgraph_node *node;
+ struct cgraph_varpool_node *vnode;
for (node = cgraph_nodes; node; node = node->next)
{
+ if (node->reachable
+ && (DECL_COMDAT (node->decl)
+ || (TREE_PUBLIC (node->decl) && !DECL_EXTERNAL (node->decl)
+ && DECL_VISIBILITY (node->decl) != VISIBILITY_INTERNAL)))
+ node->local.externally_visible = 1;
+ if (!node->local.externally_visible && node->analyzed
+ && !DECL_EXTERNAL (node->decl))
+ TREE_PUBLIC (node->decl) = 0;
node->local.local = (!node->needed
! && node->analyzed
! && !TREE_PUBLIC (node->decl));
}
+ for (vnode = cgraph_varpool_nodes_queue; vnode; vnode = vnode->next_needed)
+ {
+ if (vnode->needed
+ && (DECL_COMDAT (vnode->decl)
+ || (TREE_PUBLIC (vnode->decl)
+ && DECL_VISIBILITY (vnode->decl) != VISIBILITY_INTERNAL)))
+ vnode->externally_visible = 1;
+ if (!vnode->externally_visible)
+ TREE_PUBLIC (vnode->decl) = 0;
+ gcc_assert (TREE_STATIC (vnode->decl));
+ }
+
+ /* Because we have to be conservative on the boundaries of source
+ level units, it is possible that we marked some functions in
+ reachable just because they might be used later via external
+ linkage, but after making them local they are really unreachable
+ now. */
+ cgraph_remove_unreachable_nodes (true, cgraph_dump_file);
if (cgraph_dump_file)
{
*************** cgraph_mark_local_functions (void)
*** 1043,1049 ****
--- 1079,1091 ----
if (node->local.local)
fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
fprintf (cgraph_dump_file, "\n\n");
+ fprintf (cgraph_dump_file, "\nMarking externally visible functions:");
+ for (node = cgraph_nodes; node; node = node->next)
+ if (node->local.externally_visible)
+ fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
+ fprintf (cgraph_dump_file, "\n\n");
}
+ cgraph_function_flags_ready = true;
}
/* Return true when function body of DECL still needs to be kept around
*************** cgraph_optimize (void)
*** 1088,1094 ****
if (!quiet_flag)
fprintf (stderr, "Performing intraprocedural optimizations\n");
! cgraph_mark_local_functions ();
if (cgraph_dump_file)
{
fprintf (cgraph_dump_file, "Marked ");
--- 1130,1136 ----
if (!quiet_flag)
fprintf (stderr, "Performing intraprocedural optimizations\n");
! cgraph_function_and_variable_visibility ();
if (cgraph_dump_file)
{
fprintf (cgraph_dump_file, "Marked ");