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_analyze_function (struct cgraph_node *node);
+static void cgraph_output_pending_asms (void);
/* Records tree nodes seen in record_reference. Simply using
walk_tree_without_duplicates doesn't guarantee each node is visited
if (flag_unit_at_a_time)
return false;
+ cgraph_output_pending_asms ();
+
while (cgraph_nodes_queue)
{
struct cgraph_node *n = cgraph_nodes_queue;
}
}
+ /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
+ the expansion process. Note that this queue may grow as its
+ being processed, as the new functions may generate new ones. */
+ while (cgraph_expand_queue)
+ {
+ struct cgraph_node *n = cgraph_expand_queue;
+ cgraph_expand_queue = cgraph_expand_queue->next_needed;
+ n->next_needed = NULL;
+ cgraph_finalize_function (n->decl, false);
+ output = true;
+ }
+
return output;
}
+
+
/* As an GCC extension we allow redefinition of the function. The
semantics when both copies of bodies differ is not well defined.
We replace the old body with new body so in unit at a time mode
}
}
+static void
+cgraph_lower_function (struct cgraph_node *node)
+{
+ if (node->lowered)
+ return;
+ tree_lowering_passes (node->decl);
+ node->lowered = true;
+}
+
/* DECL has been parsed. Take it, queue it, compile it at the whim of the
logic in effect. If NESTED is true, then our caller cannot stand to have
the garbage collector run at the moment. We would need to either create
do_warn_unused_parameter (decl);
}
-void
-cgraph_lower_function (struct cgraph_node *node)
-{
- if (node->lowered)
- return;
- tree_lowering_passes (node->decl);
- node->lowered = true;
-}
-
/* Walk tree and record all calls. Called via walk_tree. */
static tree
record_reference (tree *tp, int *walk_subtrees, void *data)
/* Rebuild call edges from current function after a passes not aware
of cgraph updating. */
-static void
+static unsigned int
rebuild_cgraph_edges (void)
{
basic_block bb;
}
initialize_inline_failed (node);
gcc_assert (!node->global.inlined_to);
+ return 0;
}
struct tree_opt_pass pass_rebuild_cgraph_edges =
verify_cgraph_node (node);
}
+/* Output one variable, if necessary. Return whether we output it. */
+static bool
+cgraph_varpool_assemble_decl (struct cgraph_varpool_node *node)
+{
+ tree decl = node->decl;
+
+ if (!TREE_ASM_WRITTEN (decl)
+ && !node->alias
+ && !DECL_EXTERNAL (decl)
+ && (TREE_CODE (decl) != VAR_DECL || !DECL_HAS_VALUE_EXPR_P (decl)))
+ {
+ assemble_variable (decl, 0, 1, 0);
+ /* Local static variables are never seen by check_global_declarations
+ so we need to output debug info by hand. */
+ if (DECL_CONTEXT (decl)
+ && (TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
+ || TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
+ && errorcount == 0 && sorrycount == 0)
+ {
+ timevar_push (TV_SYMOUT);
+ (*debug_hooks->global_decl) (decl);
+ timevar_pop (TV_SYMOUT);
+ }
+ return true;
+ }
+
+ return false;
+}
/* Output all variables enqueued to be assembled. */
bool
while (cgraph_varpool_nodes_queue)
{
- tree decl = cgraph_varpool_nodes_queue->decl;
struct cgraph_varpool_node *node = cgraph_varpool_nodes_queue;
cgraph_varpool_nodes_queue = cgraph_varpool_nodes_queue->next_needed;
- if (!TREE_ASM_WRITTEN (decl) && !node->alias && !DECL_EXTERNAL (decl))
- {
- assemble_variable (decl, 0, 1, 0);
- /* Local static variables are never seen by check_global_declarations
- so we need to output debug info by hand. */
- if (DECL_CONTEXT (decl)
- && (TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
- || TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
- && errorcount == 0 && sorrycount == 0)
- {
- timevar_push (TV_SYMOUT);
- (*debug_hooks->global_decl) (decl);
- timevar_pop (TV_SYMOUT);
- }
- changed = true;
- }
+ if (cgraph_varpool_assemble_decl (node))
+ changed = true;
node->next_needed = NULL;
}
return changed;
}
-/* Analyze the function scheduled to be output. */
+/* Output all asm statements we have stored up to be output. */
+
static void
+cgraph_output_pending_asms (void)
+{
+ struct cgraph_asm_node *can;
+
+ if (errorcount || sorrycount)
+ return;
+
+ for (can = cgraph_asm_nodes; can; can = can->next)
+ assemble_asm (can->asm_str);
+ cgraph_asm_nodes = NULL;
+}
+
+/* Analyze the function scheduled to be output. */
+void
cgraph_analyze_function (struct cgraph_node *node)
{
tree decl = node->decl;
if (!flag_unit_at_a_time)
{
+ cgraph_output_pending_asms ();
cgraph_assemble_pending_functions ();
return;
}
cgraph_expand_all_functions (void)
{
struct cgraph_node *node;
- struct cgraph_node **order =
- xcalloc (cgraph_n_nodes, sizeof (struct cgraph_node *));
+ struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
int order_pos = 0, new_order_pos = 0;
int i;
cgraph_expand_function (node);
}
}
+
free (order);
+
+ /* Process CGRAPH_EXPAND_QUEUE, these are functions created during
+ the expansion process. Note that this queue may grow as its
+ being processed, as the new functions may generate new ones. */
+ while (cgraph_expand_queue)
+ {
+ node = cgraph_expand_queue;
+ cgraph_expand_queue = cgraph_expand_queue->next_needed;
+ node->next_needed = NULL;
+ node->output = 0;
+ node->lowered = DECL_STRUCT_FUNCTION (node->decl)->cfg != NULL;
+ cgraph_expand_function (node);
+ }
+}
+
+/* This is used to sort the node types by the cgraph order number. */
+
+struct cgraph_order_sort
+{
+ enum { ORDER_UNDEFINED = 0, ORDER_FUNCTION, ORDER_VAR, ORDER_ASM } kind;
+ union
+ {
+ struct cgraph_node *f;
+ struct cgraph_varpool_node *v;
+ struct cgraph_asm_node *a;
+ } u;
+};
+
+/* Output all functions, variables, and asm statements in the order
+ 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. */
+
+static void
+cgraph_output_in_order (void)
+{
+ int max;
+ size_t size;
+ struct cgraph_order_sort *nodes;
+ int i;
+ struct cgraph_node *pf;
+ struct cgraph_varpool_node *pv;
+ struct cgraph_asm_node *pa;
+
+ max = cgraph_order;
+ size = max * sizeof (struct cgraph_order_sort);
+ nodes = (struct cgraph_order_sort *) alloca (size);
+ memset (nodes, 0, size);
+
+ cgraph_varpool_analyze_pending_decls ();
+
+ for (pf = cgraph_nodes; pf; pf = pf->next)
+ {
+ if (pf->output)
+ {
+ i = pf->order;
+ gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
+ nodes[i].kind = ORDER_FUNCTION;
+ nodes[i].u.f = pf;
+ }
+ }
+
+ for (pv = cgraph_varpool_nodes_queue; pv; pv = pv->next_needed)
+ {
+ i = pv->order;
+ gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
+ nodes[i].kind = ORDER_VAR;
+ nodes[i].u.v = pv;
+ }
+
+ for (pa = cgraph_asm_nodes; pa; pa = pa->next)
+ {
+ i = pa->order;
+ gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
+ nodes[i].kind = ORDER_ASM;
+ nodes[i].u.a = pa;
+ }
+
+ for (i = 0; i < max; ++i)
+ {
+ switch (nodes[i].kind)
+ {
+ case ORDER_FUNCTION:
+ nodes[i].u.f->output = 0;
+ cgraph_expand_function (nodes[i].u.f);
+ break;
+
+ case ORDER_VAR:
+ cgraph_varpool_assemble_decl (nodes[i].u.v);
+ break;
+
+ case ORDER_ASM:
+ assemble_asm (nodes[i].u.a->asm_str);
+ break;
+
+ case ORDER_UNDEFINED:
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+ }
+
+ cgraph_asm_nodes = NULL;
}
/* Mark visibility of all functions.
#endif
if (!flag_unit_at_a_time)
{
+ cgraph_output_pending_asms ();
cgraph_varpool_assemble_pending_decls ();
return;
}
#ifdef ENABLE_CHECKING
verify_cgraph ();
#endif
-
+
cgraph_mark_functions_to_output ();
- cgraph_expand_all_functions ();
- cgraph_varpool_remove_unreferenced_decls ();
- cgraph_varpool_assemble_pending_decls ();
+ if (!flag_toplevel_reorder)
+ cgraph_output_in_order ();
+ else
+ {
+ cgraph_output_pending_asms ();
+
+ cgraph_expand_all_functions ();
+ cgraph_varpool_remove_unreferenced_decls ();
+
+ cgraph_varpool_assemble_pending_decls ();
+ }
if (cgraph_dump_file)
{
static struct cgraph_node *
cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
- tree new_decl, varray_type redirect_callers)
+ tree new_decl,
+ VEC(cgraph_edge_p,heap) *redirect_callers)
{
struct cgraph_node *new_version;
struct cgraph_edge *e, *new_e;
if (!next_callee)
break;
}
- if (redirect_callers)
- for (i = 0; i < VARRAY_ACTIVE_SIZE (redirect_callers); i++)
- {
- e = VARRAY_GENERIC_PTR (redirect_callers, i);
- /* Redirect calls to the old version node
- to point to it's new version. */
- cgraph_redirect_edge_callee (e, new_version);
- }
+ for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++)
+ {
+ /* Redirect calls to the old version node to point to its new
+ version. */
+ cgraph_redirect_edge_callee (e, new_version);
+ }
return new_version;
}
struct cgraph_node *
cgraph_function_versioning (struct cgraph_node *old_version_node,
- varray_type redirect_callers,
+ VEC(cgraph_edge_p,heap) *redirect_callers,
varray_type tree_map)
{
tree old_decl = old_version_node->decl;
cgraph_lower_function (node);
/* In non-unit-at-a-time we construct full fledged clone we never output to
- assembly file. This clone is pointed out by inline_decl of orginal function
+ assembly file. This clone is pointed out by inline_decl of original function
and inlining infrastructure knows how to deal with this. */
if (!flag_unit_at_a_time)
{