Hi,
we have flag_topeleve_reorder and also no_reorder flag on the symbols.
They do roughtly the same but implementation is not 100% shared. This makes
problem with LTO where flag_toplevel_reorder is not very meaningful (as we
don't really have meaningful toplevel args). This patch makes
!flag_topelevel_reorder
to simply set no_reorder flag and commonizes rest of the code except for
partition
sorting I will handle incrementally.
Bootstrapped/regtested x86_64-linux, comitted.
Honza
* cgraphunit.c (cgraph_node::finalize_function): When
!flag_toplevel_reorde set no_reorder flag.
(varpool_node::finalize_decl): Likewise.
(symbol_table::compile): Drop no toplevel reorder path.
* lto-partition.c (lto_balanced_map): Do not check
flag_toplevel_reorder.
Index: lto/lto-partition.c
===================================================================
--- lto/lto-partition.c (revision 250021)
+++ lto/lto-partition.c (working copy)
@@ -506,7 +506,7 @@ lto_balanced_map (int n_lto_partitions,
/* Collect all variables that should not be reordered. */
FOR_EACH_VARIABLE (vnode)
if (vnode->get_partitioning_class () == SYMBOL_PARTITION
- && (!flag_toplevel_reorder || vnode->no_reorder))
+ && vnode->no_reorder)
varpool_order.safe_push (vnode);
n_varpool_nodes = varpool_order.length ();
varpool_order.qsort (varpool_node_cmp);
@@ -634,7 +634,7 @@ lto_balanced_map (int n_lto_partitions,
vnode = dyn_cast <varpool_node *> (ref->referred);
if (!vnode->definition)
continue;
- if (!symbol_partitioned_p (vnode) && flag_toplevel_reorder
+ if (!symbol_partitioned_p (vnode)
&& !vnode->no_reorder
&& vnode->get_partitioning_class () == SYMBOL_PARTITION)
add_symbol_to_partition (partition, vnode);
@@ -672,7 +672,7 @@ lto_balanced_map (int n_lto_partitions,
because it allows them to be removed. Coupling
with objects they refer to only helps to reduce
number of symbols promoted to hidden. */
- if (!symbol_partitioned_p (vnode) && flag_toplevel_reorder
+ if (!symbol_partitioned_p (vnode)
&& !vnode->no_reorder
&& !vnode->can_remove_if_no_refs_p ()
&& vnode->get_partitioning_class () == SYMBOL_PARTITION)
@@ -767,14 +767,10 @@ lto_balanced_map (int n_lto_partitions,
next_nodes.truncate (0);
/* Varables that are not reachable from the code go into last partition. */
- if (flag_toplevel_reorder)
- {
- FOR_EACH_VARIABLE (vnode)
- if (vnode->get_partitioning_class () == SYMBOL_PARTITION
- && !symbol_partitioned_p (vnode)
- && !vnode->no_reorder)
- next_nodes.safe_push (vnode);
- }
+ FOR_EACH_VARIABLE (vnode)
+ if (vnode->get_partitioning_class () == SYMBOL_PARTITION
+ && !symbol_partitioned_p (vnode))
+ next_nodes.safe_push (vnode);
/* Output remaining ordered symbols. */
while (varpool_pos < n_varpool_nodes)
Index: cgraphunit.c
===================================================================
--- cgraphunit.c (revision 250021)
+++ cgraphunit.c (working copy)
@@ -449,6 +449,8 @@ cgraph_node::finalize_function (tree dec
node->definition = true;
notice_global_symbol (decl);
node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
+ if (!flag_toplevel_reorder)
+ node->no_reorder = true;
/* With -fkeep-inline-functions we are keeping all inline functions except
for extern inline ones. */
@@ -471,7 +473,8 @@ cgraph_node::finalize_function (tree dec
declared inline and nested functions. These were optimized out
in the original implementation and it is unclear whether we want
to change the behavior here. */
- if (((!opt_for_fn (decl, optimize) || flag_keep_static_functions)
+ if (((!opt_for_fn (decl, optimize) || flag_keep_static_functions
+ || node->no_reorder)
&& !node->cpp_implicit_alias
&& !DECL_DISREGARD_INLINE_LIMITS (decl)
&& !DECL_DECLARED_INLINE_P (decl)
@@ -840,13 +843,14 @@ varpool_node::finalize_decl (tree decl)
it is available to notice_global_symbol. */
node->definition = true;
notice_global_symbol (decl);
+ if (!flag_toplevel_reorder)
+ node->no_reorder = true;
if (TREE_THIS_VOLATILE (decl) || DECL_PRESERVE_P (decl)
/* Traditionally we do not eliminate static variables when not
optimizing and when not doing toplevel reoder. */
|| node->no_reorder
- || ((!flag_toplevel_reorder
- && !DECL_COMDAT (node->decl)
- && !DECL_ARTIFICIAL (node->decl))))
+ || (!DECL_COMDAT (node->decl)
+ && !DECL_ARTIFICIAL (node->decl)))
node->force_output = true;
if (symtab->state == CONSTRUCTION
@@ -857,8 +861,8 @@ varpool_node::finalize_decl (tree decl)
/* Some frontends produce various interface variables after compilation
finished. */
if (symtab->state == FINISHED
- || (!flag_toplevel_reorder
- && symtab->state == EXPANSION))
+ || (node->no_reorder
+ && symtab->state == EXPANSION))
node->assemble_decl ();
if (DECL_INITIAL (decl))
@@ -2226,11 +2230,10 @@ struct cgraph_order_sort
according to their order fields, which is the order in which they
appeared in the file. This implements -fno-toplevel-reorder. In
this mode we may output functions and variables which don't really
- need to be output.
- When NO_REORDER is true only do this for symbols marked no reorder. */
+ need to be output. */
static void
-output_in_order (bool no_reorder)
+output_in_order (void)
{
int max;
cgraph_order_sort *nodes;
@@ -2245,7 +2248,7 @@ output_in_order (bool no_reorder)
{
if (pf->process && !pf->thunk.thunk_p && !pf->alias)
{
- if (no_reorder && !pf->no_reorder)
+ if (!pf->no_reorder)
continue;
i = pf->order;
gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
@@ -2258,7 +2261,7 @@ output_in_order (bool no_reorder)
Please keep them in sync. */
FOR_EACH_VARIABLE (pv)
{
- if (no_reorder && !pv->no_reorder)
+ if (!pv->no_reorder)
continue;
if (DECL_HARD_REGISTER (pv->decl)
|| DECL_HAS_VALUE_EXPR_P (pv->decl))
@@ -2532,16 +2535,11 @@ symbol_table::compile (void)
state = EXPANSION;
- if (!flag_toplevel_reorder)
- output_in_order (false);
- else
- {
- /* Output first asm statements and anything ordered. The process
- flag is cleared for these nodes, so we skip them later. */
- output_in_order ();
- expand_all_functions ();
- output_variables ();
- }
+ /* Output first asm statements and anything ordered. The process
+ flag is cleared for these nodes, so we skip them later. */
+ output_in_order (true);
+ expand_all_functions ();
+ output_variables ();
process_new_functions ();
state = FINISHED;
