+2012-08-12 Jan Hubicka <jh@suse.cz>
+
+ * tree-pass.h (write_summary, write_optimization_summary): Remove
+ set and vset arguments.
+ * ipa-cp.c (ipcp_write_summary): Remove set and vset arugments.
+ (write_node_summary_p): Likewise; use the encoder.
+ (ipa_reference_write_optimization_summary): Likewise.
+ * lto-cgraph.c (output_cgraph_opt_summary): Use encoder.
+ (lto_symtab_encoder_new): Initialize in_partition field.
+ (lto_symtab_encoder_delete): Destroy in_partition field.
+ (LCC_NOT_FOUND): Move to lto-streamer.h
+ (lto_symtab_encoder_deref): Likewise.
+ (lto_symtab_encoder_in_partition_p,
+ lto_set_symtab_encoder_in_partition): New functions.
+ (referenced_from_other_partition_p): Rewrite to use encoder.
+ (reachable_from_other_partition_p): Likewise.
+ (referenced_from_this_partition_p): Likewise.
+ (reachable_from_this_partition_p): Likewise.
+ (lto_output_node): Likewise.
+ (lto_output_varpool_node): Likewise.
+ (output_refs): Likewise.
+ (compute_ltrans_boundary): Initialize in_partition fileds of
+ the encoder.
+ (output_symtab): Likewise.
+ (input_refs): Match the changes in output_refs.
+ (output_cgraph_opt_summary_p): Remove set argument.
+ (output_node_opt_summary): Replace set by encoder.
+ (output_cgraph_opt_summary): Remove set argument; use
+ the encoder.
+ * ipa-pure-const.c (pure_const_write_summary): Remove set and vset
+ arguments; use the encoder.
+ * lto-streamer-out.c (lto_output): Remove set and vset argument; use
+ the encoder.
+ (produce_symtab): Likewise.
+ * ipa-inline.h (inline_write_summary): Remove set and vset arguments.
+ * ipa-inline-analysis.c (inline_write_summary): Likewise.
+ * ipa-prop.c (ipa_prop_write_jump_functions): Remove set argument;
+ use encoder.
+ * ipa-prop.h (ipa_prop_write_jump_functions): Likewise.
+ * passes.c (ipa_write_summaries_2): Remove set and vset arguments.
+ (ipa_write_summaries_1): Update.
+ (ipa_write_optimization_summaries_1): Likewise.
+ (ipa_write_optimization_summaries): Likewise.
+ * lto-streamer.h (lto_symtab_encoder_t): Add in_partition.
+ (lto_symtab_encoder_iterator): New type.
+ (lto_symtab_encoder_deref): Make inline.
+ (output_symtab, referenced_from_other_partition_p,
+ reachable_from_other_partition_p, referenced_from_this_partition_p,
+ reachable_from_this_partition_p): Update.
+ (lsei_end_p, lsei_next, lsei_node, lsei_cgraph_node, lsei_varpool_node): New
+ inline functions.
+ (LCC_NOT_FOUND): New macro.
+ (lto_symtab_encoder_deref, lsei_start, lsei_next_in_partition,
+ lsei_start_in_partition, lsei_next_function_in_partition,
+ lsei_start_function_in_partition, lsei_next_variable_in_partition,
+ lsei_start_variable_in_partition): New inline functions.
+
2012-08-12 Oleg Endo <olegendo@gcc.gnu.org>
* config/sh/sh.md (prefetch): Simplify expander. Fix condition to
/* Write ipcp summary for nodes in SET. */
static void
-ipcp_write_summary (cgraph_node_set set,
- varpool_node_set vset ATTRIBUTE_UNUSED)
+ipcp_write_summary (void)
{
- ipa_prop_write_jump_functions (set);
+ ipa_prop_write_jump_functions ();
}
/* Read ipcp summary. */
active, we don't need to write them twice. */
void
-inline_write_summary (cgraph_node_set set,
- varpool_node_set vset ATTRIBUTE_UNUSED)
+inline_write_summary (void)
{
struct cgraph_node *node;
symtab_node snode;
destroy_output_block (ob);
if (optimize && !flag_ipa_cp)
- ipa_prop_write_jump_functions (set);
+ ipa_prop_write_jump_functions ();
}
void dump_inline_summary (FILE * f, struct cgraph_node *node);
void inline_generate_summary (void);
void inline_read_summary (void);
-void inline_write_summary (cgraph_node_set, varpool_node_set);
+void inline_write_summary (void);
void inline_free_summary (void);
void initialize_inline_failed (struct cgraph_edge *);
int estimate_time_after_inlining (struct cgraph_node *, struct cgraph_edge *);
/* Write jump functions for nodes in SET. */
void
-ipa_prop_write_jump_functions (cgraph_node_set set)
+ipa_prop_write_jump_functions (void)
{
struct cgraph_node *node;
struct output_block *ob;
unsigned int count = 0;
- cgraph_node_set_iterator csi;
+ lto_symtab_encoder_iterator lsei;
+ lto_symtab_encoder_t encoder;
+
if (!ipa_node_params_vector)
return;
ob = create_output_block (LTO_section_jump_functions);
+ encoder = ob->decl_state->symtab_node_encoder;
ob->cgraph_node = NULL;
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
{
- node = csi_node (csi);
+ node = lsei_cgraph_node (lsei);
if (cgraph_function_with_gimple_body_p (node)
&& IPA_NODE_REF (node) != NULL)
count++;
streamer_write_uhwi (ob, count);
/* Process all of the functions. */
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
{
- node = csi_node (csi);
+ node = lsei_cgraph_node (lsei);
if (cgraph_function_with_gimple_body_p (node)
&& IPA_NODE_REF (node) != NULL)
ipa_write_node_info (ob, node);
ipa_parm_adjustment_vec);
void ipa_dump_param_adjustments (FILE *, ipa_parm_adjustment_vec, tree);
-void ipa_prop_write_jump_functions (cgraph_node_set set);
+void ipa_prop_write_jump_functions (void);
void ipa_prop_read_jump_functions (void);
void ipa_update_after_lto_read (void);
int ipa_get_param_decl_index (struct ipa_node_params *, tree);
/* Serialize the ipa info for lto. */
static void
-pure_const_write_summary (cgraph_node_set set,
- varpool_node_set vset ATTRIBUTE_UNUSED)
+pure_const_write_summary (void)
{
struct cgraph_node *node;
struct lto_simple_output_block *ob
= lto_create_simple_output_block (LTO_section_ipa_pure_const);
unsigned int count = 0;
- cgraph_node_set_iterator csi;
+ lto_symtab_encoder_iterator lsei;
+ lto_symtab_encoder_t encoder;
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ encoder = lto_get_out_decl_state ()->symtab_node_encoder;
+
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
{
- node = csi_node (csi);
+ node = lsei_cgraph_node (lsei);
if (node->analyzed && has_function_state (node))
count++;
}
streamer_write_uhwi_stream (ob->main_stream, count);
/* Process all of the functions. */
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
{
- node = csi_node (csi);
+ node = lsei_cgraph_node (lsei);
if (node->analyzed && has_function_state (node))
{
struct bitpack_d bp;
static bool
write_node_summary_p (struct cgraph_node *node,
- cgraph_node_set set,
- varpool_node_set vset,
+ lto_symtab_encoder_t encoder,
bitmap ltrans_statics)
{
ipa_reference_optimization_summary_t info;
In future we might also want to include summaries of functions references
by initializers of constant variables references in current unit. */
- if (!reachable_from_this_partition_p (node, set)
- && !referenced_from_this_partition_p (&node->symbol.ref_list, set, vset))
+ if (!reachable_from_this_partition_p (node, encoder)
+ && !referenced_from_this_partition_p (&node->symbol.ref_list, encoder))
return false;
/* See if the info has non-empty intersections with vars we want to encode. */
/* Serialize the ipa info for lto. */
static void
-ipa_reference_write_optimization_summary (cgraph_node_set set,
- varpool_node_set vset)
+ipa_reference_write_optimization_summary (void)
{
struct cgraph_node *node;
symtab_node snode;
continue;
vnode = varpool (snode);
if (bitmap_bit_p (all_module_statics, DECL_UID (vnode->symbol.decl))
- && referenced_from_this_partition_p (&vnode->symbol.ref_list, set, vset))
+ && referenced_from_this_partition_p (&vnode->symbol.ref_list, encoder))
{
tree decl = vnode->symbol.decl;
bitmap_set_bit (ltrans_statics, DECL_UID (decl));
for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
if (symtab_function_p (snode = lto_symtab_encoder_deref (encoder, i))
&& write_node_summary_p (cgraph (snode),
- set, vset, ltrans_statics))
+ encoder, ltrans_statics))
count++;
streamer_write_uhwi_stream (ob->main_stream, count);
if (!symtab_function_p (snode))
continue;
node = cgraph (snode);
- if (write_node_summary_p (node, set, vset, ltrans_statics))
+ if (write_node_summary_p (node, encoder, ltrans_statics))
{
ipa_reference_optimization_summary_t info;
int node_ref;
#include "tree-streamer.h"
#include "gcov-io.h"
-static void output_cgraph_opt_summary (cgraph_node_set set);
+static void output_cgraph_opt_summary (void);
static void input_cgraph_opt_summary (VEC (symtab_node, heap) * nodes);
/* Number of LDPR values known to GCC. */
encoder->nodes = NULL;
encoder->body = pointer_set_create ();
encoder->initializer = pointer_set_create ();
+ encoder->in_partition = pointer_set_create ();
return encoder;
}
pointer_map_destroy (encoder->map);
pointer_set_destroy (encoder->body);
pointer_set_destroy (encoder->initializer);
+ pointer_set_destroy (encoder->in_partition);
free (encoder);
}
return ref;
}
-#define LCC_NOT_FOUND (-1)
/* Look up NODE in encoder. Return NODE's reference if it has been encoded
or LCC_NOT_FOUND if it is not there. */
}
-/* Return the cgraph node corresponding to REF using ENCODER. */
-
-symtab_node
-lto_symtab_encoder_deref (lto_symtab_encoder_t encoder, int ref)
-{
- if (ref == LCC_NOT_FOUND)
- return NULL;
-
- return VEC_index (symtab_node, encoder->nodes, ref);
-}
-
-
/* Return TRUE if we should encode initializer of NODE (if any). */
bool
pointer_set_insert (encoder->initializer, node);
}
+/* Return TRUE if we should encode initializer of NODE (if any). */
+
+bool
+lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t encoder,
+ symtab_node node)
+{
+ return pointer_set_contains (encoder->in_partition, node);
+}
+
+/* Return TRUE if we should encode body of NODE (if any). */
+
+void
+lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t encoder,
+ symtab_node node)
+{
+ lto_symtab_encoder_encode (encoder, (symtab_node)node);
+ pointer_set_insert (encoder->in_partition, node);
+}
+
/* Output the cgraph EDGE to OB using ENCODER. */
static void
/* Return if LIST contain references from other partitions. */
bool
-referenced_from_other_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
- varpool_node_set vset)
+referenced_from_other_partition_p (struct ipa_ref_list *list, lto_symtab_encoder_t encoder)
{
int i;
struct ipa_ref *ref;
for (i = 0; ipa_ref_list_referring_iterate (list, i, ref); i++)
{
- if (symtab_function_p (ref->referring))
- {
- if (ipa_ref_referring_node (ref)->symbol.in_other_partition
- || !cgraph_node_in_set_p (ipa_ref_referring_node (ref), set))
- return true;
- }
- else
- {
- if (ipa_ref_referring_varpool_node (ref)->symbol.in_other_partition
- || !varpool_node_in_set_p (ipa_ref_referring_varpool_node (ref),
- vset))
- return true;
- }
+ if (ref->referring->symbol.in_other_partition
+ || !lto_symtab_encoder_in_partition_p (encoder, ref->referring))
+ return true;
}
return false;
}
/* Return true when node is reachable from other partition. */
bool
-reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
+reachable_from_other_partition_p (struct cgraph_node *node, lto_symtab_encoder_t encoder)
{
struct cgraph_edge *e;
if (!node->analyzed)
return false;
for (e = node->callers; e; e = e->next_caller)
if (e->caller->symbol.in_other_partition
- || !cgraph_node_in_set_p (e->caller, set))
+ || !lto_symtab_encoder_in_partition_p (encoder, (symtab_node)e->caller))
return true;
return false;
}
/* Return if LIST contain references from other partitions. */
bool
-referenced_from_this_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
- varpool_node_set vset)
+referenced_from_this_partition_p (struct ipa_ref_list *list,
+ lto_symtab_encoder_t encoder)
{
int i;
struct ipa_ref *ref;
for (i = 0; ipa_ref_list_referring_iterate (list, i, ref); i++)
- {
- if (symtab_function_p (ref->referring))
- {
- if (cgraph_node_in_set_p (ipa_ref_referring_node (ref), set))
- return true;
- }
- else
- {
- if (varpool_node_in_set_p (ipa_ref_referring_varpool_node (ref),
- vset))
- return true;
- }
- }
+ if (lto_symtab_encoder_in_partition_p (encoder, ref->referring))
+ return true;
return false;
}
/* Return true when node is reachable from other partition. */
bool
-reachable_from_this_partition_p (struct cgraph_node *node, cgraph_node_set set)
+reachable_from_this_partition_p (struct cgraph_node *node, lto_symtab_encoder_t encoder)
{
struct cgraph_edge *e;
for (e = node->callers; e; e = e->next_caller)
- if (cgraph_node_in_set_p (e->caller, set))
+ if (lto_symtab_encoder_in_partition_p (encoder, (symtab_node)e->caller))
return true;
return false;
}
static void
lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
- lto_symtab_encoder_t encoder, cgraph_node_set set,
- varpool_node_set vset)
+ lto_symtab_encoder_t encoder)
{
unsigned int tag;
struct bitpack_d bp;
bool in_other_partition = false;
struct cgraph_node *clone_of;
- boundary_p = !cgraph_node_in_set_p (node, set);
+ boundary_p = !lto_symtab_encoder_in_partition_p (encoder, (symtab_node)node);
if (node->analyzed && !boundary_p)
tag = LTO_symtab_analyzed_node;
bp_pack_value (&bp, tag == LTO_symtab_analyzed_node
&& !DECL_EXTERNAL (node->symbol.decl)
&& !DECL_COMDAT (node->symbol.decl)
- && (reachable_from_other_partition_p (node, set)
+ && (reachable_from_other_partition_p (node, encoder)
|| referenced_from_other_partition_p (&node->symbol.ref_list,
- set, vset)), 1);
+ encoder)), 1);
bp_pack_value (&bp, node->lowered, 1);
bp_pack_value (&bp, in_other_partition, 1);
/* Real aliases in a boundary become non-aliases. However we still stream
static void
lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
- lto_symtab_encoder_t encoder,
- cgraph_node_set set, varpool_node_set vset)
+ lto_symtab_encoder_t encoder)
{
- bool boundary_p = !varpool_node_in_set_p (node, vset) && node->analyzed;
+ bool boundary_p = (node->analyzed
+ && !lto_symtab_encoder_in_partition_p (encoder, (symtab_node)node));
struct bitpack_d bp;
int ref;
{
bp_pack_value (&bp, node->analyzed
&& referenced_from_other_partition_p (&node->symbol.ref_list,
- set, vset), 1);
+ encoder), 1);
bp_pack_value (&bp, boundary_p && !DECL_EXTERNAL (node->symbol.decl), 1);
/* in_other_partition. */
}
/* Output the part of the cgraph in SET. */
static void
-output_refs (cgraph_node_set set, varpool_node_set vset,
- lto_symtab_encoder_t encoder)
+output_refs (lto_symtab_encoder_t encoder)
{
- cgraph_node_set_iterator csi;
- varpool_node_set_iterator vsi;
+ lto_symtab_encoder_iterator lsei;
struct lto_simple_output_block *ob;
int count;
struct ipa_ref *ref;
ob = lto_create_simple_output_block (LTO_section_refs);
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
- {
- struct cgraph_node *node = csi_node (csi);
-
- count = ipa_ref_list_nreferences (&node->symbol.ref_list);
- if (count)
- {
- streamer_write_uhwi_stream (ob->main_stream, count);
- streamer_write_uhwi_stream (ob->main_stream,
- lto_symtab_encoder_lookup (encoder,
- (symtab_node)node));
- for (i = 0; ipa_ref_list_reference_iterate (&node->symbol.ref_list,
- i, ref); i++)
- lto_output_ref (ob, ref, encoder);
- }
- }
-
- streamer_write_uhwi_stream (ob->main_stream, 0);
-
- for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
+ for (lsei = lsei_start_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_in_partition (&lsei))
{
- struct varpool_node *node = vsi_node (vsi);
+ symtab_node node = lsei_node (lsei);
count = ipa_ref_list_nreferences (&node->symbol.ref_list);
if (count)
{
streamer_write_uhwi_stream (ob->main_stream, count);
streamer_write_uhwi_stream (ob->main_stream,
- lto_symtab_encoder_lookup (encoder,
- (symtab_node)node));
+ lto_symtab_encoder_lookup (encoder, node));
for (i = 0; ipa_ref_list_reference_iterate (&node->symbol.ref_list,
i, ref); i++)
lto_output_ref (ob, ref, encoder);
{
node = csi_node (csi);
add_node_to (encoder, node, true);
+ lto_set_symtab_encoder_in_partition (encoder, (symtab_node)node);
add_references (encoder, &node->symbol.ref_list);
}
for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
{
struct varpool_node *vnode = vsi_node (vsi);
gcc_assert (!vnode->alias || vnode->alias_of);
- lto_symtab_encoder_encode (encoder, (symtab_node)vnode);
+ lto_set_symtab_encoder_in_partition (encoder, (symtab_node)vnode);
lto_set_symtab_encoder_encode_initializer (encoder, vnode);
add_references (encoder, &vnode->symbol.ref_list);
}
/* Output the part of the symtab in SET and VSET. */
void
-output_symtab (cgraph_node_set set, varpool_node_set vset)
+output_symtab (void)
{
struct cgraph_node *node;
struct lto_simple_output_block *ob;
- cgraph_node_set_iterator csi;
+ lto_symtab_encoder_iterator lsei;
int i, n_nodes;
lto_symtab_encoder_t encoder;
static bool asm_nodes_output = false;
if (flag_wpa)
- output_cgraph_opt_summary (set);
+ output_cgraph_opt_summary ();
ob = lto_create_simple_output_block (LTO_section_symtab_nodes);
{
symtab_node node = lto_symtab_encoder_deref (encoder, i);
if (symtab_function_p (node))
- lto_output_node (ob, cgraph (node), encoder, set, vset);
+ lto_output_node (ob, cgraph (node), encoder);
else
- lto_output_varpool_node (ob, varpool (node), encoder,
- set, vset);
+ lto_output_varpool_node (ob, varpool (node), encoder);
}
/* Go over the nodes in SET again to write edges. */
- for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
+ lsei_next_function_in_partition (&lsei))
{
- node = csi_node (csi);
+ node = lsei_cgraph_node (lsei);
output_outgoing_cgraph_edges (node->callees, ob, encoder);
output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
}
lto_output_toplevel_asms ();
}
- output_refs (set, vset, encoder);
+ output_refs (encoder);
}
/* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
int idx;
while (true)
{
- struct cgraph_node *node;
+ symtab_node node;
count = streamer_read_uhwi (ib);
if (!count)
break;
idx = streamer_read_uhwi (ib);
- node = cgraph (VEC_index (symtab_node, nodes, idx));
- while (count)
- {
- input_ref (ib, (symtab_node) node, nodes);
- count--;
- }
- }
- while (true)
- {
- struct varpool_node *node;
- count = streamer_read_uhwi (ib);
- if (!count)
- break;
- node = varpool (VEC_index (symtab_node, nodes,
- streamer_read_uhwi (ib)));
+ node = VEC_index (symtab_node, nodes, idx);
while (count)
{
- input_ref (ib, (symtab_node) node, nodes);
+ input_ref (ib, node, nodes);
count--;
}
}
/* True when we need optimization summary for NODE. */
static int
-output_cgraph_opt_summary_p (struct cgraph_node *node,
- cgraph_node_set set ATTRIBUTE_UNUSED)
+output_cgraph_opt_summary_p (struct cgraph_node *node)
{
return (node->clone_of
&& (node->clone.tree_map
static void
output_node_opt_summary (struct output_block *ob,
struct cgraph_node *node,
- cgraph_node_set set)
+ lto_symtab_encoder_t encoder)
{
unsigned int index;
bitmap_iterator bi;
streamer_write_bitpack (&bp);
}
- if (cgraph_node_in_set_p (node, set))
+ if (lto_symtab_encoder_in_partition_p (encoder, (symtab_node) node))
{
for (e = node->callees; e; e = e->next_callee)
output_edge_opt_summary (ob, e);
At the moment it is the clone info structure. */
static void
-output_cgraph_opt_summary (cgraph_node_set set)
+output_cgraph_opt_summary (void)
{
symtab_node node;
int i, n_nodes;
n_nodes = lto_symtab_encoder_size (encoder);
for (i = 0; i < n_nodes; i++)
if (symtab_function_p (node = lto_symtab_encoder_deref (encoder, i))
- && output_cgraph_opt_summary_p (cgraph (node), set))
+ && output_cgraph_opt_summary_p (cgraph (node)))
count++;
streamer_write_uhwi (ob, count);
for (i = 0; i < n_nodes; i++)
{
node = lto_symtab_encoder_deref (encoder, i);
if (symtab_function_p (node)
- && output_cgraph_opt_summary_p (cgraph (node), set))
+ && output_cgraph_opt_summary_p (cgraph (node)))
{
streamer_write_uhwi (ob, i);
- output_node_opt_summary (ob, cgraph (node), set);
+ output_node_opt_summary (ob, cgraph (node), encoder);
}
}
produce_asm (ob, NULL);
/* Main entry point from the pass manager. */
static void
-lto_output (cgraph_node_set set, varpool_node_set vset)
+lto_output (void)
{
struct cgraph_node *node;
struct lto_out_decl_state *decl_state;
be done now to make sure that all the statements in every function
have been renumbered so that edges can be associated with call
statements using the statement UIDs. */
- output_symtab (set, vset);
+ output_symtab ();
#ifdef ENABLE_CHECKING
lto_bitmap_free (output);
recover these on other side. */
static void
-produce_asm_for_decls (cgraph_node_set set ATTRIBUTE_UNUSED,
- varpool_node_set vset ATTRIBUTE_UNUSED)
+produce_asm_for_decls (void)
{
struct lto_out_decl_state *out_state;
struct lto_out_decl_state *fn_out_state;
struct pointer_set_t *body;
/* Map of nodes where we want to output initializer. */
struct pointer_set_t *initializer;
+ /* Map of nodes in this partition. */
+ struct pointer_set_t *in_partition;
};
typedef struct lto_symtab_encoder_d *lto_symtab_encoder_t;
-/* Return number of encoded nodes in ENCODER. */
-
-static inline int
-lto_symtab_encoder_size (lto_symtab_encoder_t encoder)
+/* Iterator structure for cgraph node sets. */
+typedef struct
{
- return VEC_length (symtab_node, encoder->nodes);
-}
+ lto_symtab_encoder_t encoder;
+ unsigned index;
+} lto_symtab_encoder_iterator;
+
+
+
/* Mapping from indices to trees. */
struct GTY(()) lto_tree_ref_table
/* In lto-cgraph.c */
-symtab_node lto_symtab_encoder_deref (lto_symtab_encoder_t, int);
int lto_symtab_encoder_lookup (lto_symtab_encoder_t, symtab_node);
lto_symtab_encoder_t lto_symtab_encoder_new (void);
int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node);
void lto_symtab_encoder_delete (lto_symtab_encoder_t);
bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t,
struct cgraph_node *);
+bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t,
+ symtab_node);
+void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t,
+ symtab_node);
bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t,
struct varpool_node *);
-void output_symtab (cgraph_node_set, varpool_node_set);
+void output_symtab (void);
void input_symtab (void);
bool referenced_from_other_partition_p (struct ipa_ref_list *,
- cgraph_node_set,
- varpool_node_set vset);
+ lto_symtab_encoder_t);
bool reachable_from_other_partition_p (struct cgraph_node *,
- cgraph_node_set);
+ lto_symtab_encoder_t);
bool referenced_from_this_partition_p (struct ipa_ref_list *,
- cgraph_node_set,
- varpool_node_set vset);
+ lto_symtab_encoder_t);
bool reachable_from_this_partition_p (struct cgraph_node *,
- cgraph_node_set);
+ lto_symtab_encoder_t);
void compute_ltrans_boundary (struct lto_out_decl_state *state,
cgraph_node_set, varpool_node_set);
return DECL_NONLOCAL (label) || FORCED_LABEL (label);
}
+/* Return number of encoded nodes in ENCODER. */
+static inline int
+lto_symtab_encoder_size (lto_symtab_encoder_t encoder)
+{
+ return VEC_length (symtab_node, encoder->nodes);
+}
+
+/* Return true if iterator LSE points to nothing. */
+static inline bool
+lsei_end_p (lto_symtab_encoder_iterator lsei)
+{
+ return lsei.index >= (unsigned)lto_symtab_encoder_size (lsei.encoder);
+}
+
+/* Advance iterator LSE. */
+static inline void
+lsei_next (lto_symtab_encoder_iterator *lsei)
+{
+ lsei->index++;
+}
+
+/* Return the node pointed to by LSI. */
+static inline symtab_node
+lsei_node (lto_symtab_encoder_iterator lsei)
+{
+ return VEC_index (symtab_node, lsei.encoder->nodes, lsei.index);
+}
+
+/* Return the node pointed to by LSI. */
+static inline struct cgraph_node *
+lsei_cgraph_node (lto_symtab_encoder_iterator lsei)
+{
+ return cgraph (VEC_index (symtab_node, lsei.encoder->nodes, lsei.index));
+}
+
+/* Return the node pointed to by LSI. */
+static inline struct varpool_node *
+lsei_varpool_node (lto_symtab_encoder_iterator lsei)
+{
+ return varpool (VEC_index (symtab_node, lsei.encoder->nodes, lsei.index));
+}
+
+/* Value used to represent failure of lto_symtab_encoder_lookup. */
+#define LCC_NOT_FOUND (-1)
+
+/* Return the cgraph node corresponding to REF using ENCODER. */
+
+static inline symtab_node
+lto_symtab_encoder_deref (lto_symtab_encoder_t encoder, int ref)
+{
+ if (ref == LCC_NOT_FOUND)
+ return NULL;
+
+ return VEC_index (symtab_node, encoder->nodes, ref);
+}
+
+/* Return an iterator to the first node in LSI. */
+static inline lto_symtab_encoder_iterator
+lsei_start (lto_symtab_encoder_t encoder)
+{
+ lto_symtab_encoder_iterator lsei;
+
+ lsei.encoder = encoder;
+ lsei.index = 0;
+ return lsei;
+}
+
+/* Advance iterator LSE. */
+static inline void
+lsei_next_in_partition (lto_symtab_encoder_iterator *lsei)
+{
+ lsei_next (lsei);
+ while (!lsei_end_p (*lsei)
+ && !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei)))
+ lsei_next (lsei);
+}
+
+/* Return an iterator to the first node in LSI. */
+static inline lto_symtab_encoder_iterator
+lsei_start_in_partition (lto_symtab_encoder_t encoder)
+{
+ lto_symtab_encoder_iterator lsei = lsei_start (encoder);
+
+ if (lsei_end_p (lsei))
+ return lsei;
+ if (!lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
+ lsei_next_in_partition (&lsei);
+
+ return lsei;
+}
+
+/* Advance iterator LSE. */
+static inline void
+lsei_next_function_in_partition (lto_symtab_encoder_iterator *lsei)
+{
+ lsei_next (lsei);
+ while (!lsei_end_p (*lsei)
+ && (!symtab_function_p (lsei_node (*lsei))
+ || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
+ lsei_next (lsei);
+}
+
+/* Return an iterator to the first node in LSI. */
+static inline lto_symtab_encoder_iterator
+lsei_start_function_in_partition (lto_symtab_encoder_t encoder)
+{
+ lto_symtab_encoder_iterator lsei = lsei_start (encoder);
+
+ if (lsei_end_p (lsei))
+ return lsei;
+ if (!symtab_function_p (lsei_node (lsei))
+ || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
+ lsei_next_function_in_partition (&lsei);
+
+ return lsei;
+}
+
+/* Advance iterator LSE. */
+static inline void
+lsei_next_variable_in_partition (lto_symtab_encoder_iterator *lsei)
+{
+ lsei_next (lsei);
+ while (!lsei_end_p (*lsei)
+ && (!symtab_variable_p (lsei_node (*lsei))
+ || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
+ lsei_next (lsei);
+}
+
+/* Return an iterator to the first node in LSI. */
+static inline lto_symtab_encoder_iterator
+lsei_start_variable_in_partition (lto_symtab_encoder_t encoder)
+{
+ lto_symtab_encoder_iterator lsei = lsei_start (encoder);
+
+ if (lsei_end_p (lsei))
+ return lsei;
+ if (!symtab_variable_p (lsei_node (lsei))
+ || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
+ lsei_next_variable_in_partition (&lsei);
+
+ return lsei;
+}
+
DEFINE_DECL_STREAM_FUNCS (TYPE, type)
DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
+2012-08-12 Jan Hubicka <jh@suse.cz>
+
+ * lto-partition.c (set_referenced_from_other_partition_p,
+ set_reachable_from_other_partition_p, set_referenced_from_this_partition_p):
+ New functions.
+ (lto_promote_cross_file_statics): Use them.
+
2012-07-24 Jan Hubicka <jh@suse.cz>
* lto.c (read_cgraph_and_symbols): Use input_symtab.
return true;
}
+/* Return if LIST contain references from other partitions.
+ TODO: remove this once lto partitioning is using encoders. */
+
+static bool
+set_referenced_from_other_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
+ varpool_node_set vset)
+{
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_referring_iterate (list, i, ref); i++)
+ {
+ if (symtab_function_p (ref->referring))
+ {
+ if (ipa_ref_referring_node (ref)->symbol.in_other_partition
+ || !cgraph_node_in_set_p (ipa_ref_referring_node (ref), set))
+ return true;
+ }
+ else
+ {
+ if (ipa_ref_referring_varpool_node (ref)->symbol.in_other_partition
+ || !varpool_node_in_set_p (ipa_ref_referring_varpool_node (ref),
+ vset))
+ return true;
+ }
+ }
+ return false;
+}
+
+/* Return true when node is reachable from other partition.
+ TODO: remove this once lto partitioning is using encoders. */
+
+static bool
+set_reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
+{
+ struct cgraph_edge *e;
+ if (!node->analyzed)
+ return false;
+ if (node->global.inlined_to)
+ return false;
+ for (e = node->callers; e; e = e->next_caller)
+ if (e->caller->symbol.in_other_partition
+ || !cgraph_node_in_set_p (e->caller, set))
+ return true;
+ return false;
+}
+
+
+/* Return if LIST contain references from other partitions.
+ TODO: remove this once lto partitioning is using encoders. */
+
+static bool
+set_referenced_from_this_partition_p (struct ipa_ref_list *list, cgraph_node_set set,
+ varpool_node_set vset)
+{
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; ipa_ref_list_referring_iterate (list, i, ref); i++)
+ {
+ if (symtab_function_p (ref->referring))
+ {
+ if (cgraph_node_in_set_p (ipa_ref_referring_node (ref), set))
+ return true;
+ }
+ else
+ {
+ if (varpool_node_in_set_p (ipa_ref_referring_varpool_node (ref),
+ vset))
+ return true;
+ }
+ }
+ return false;
+}
+
/* Find out all static decls that need to be promoted to global because
of cross file sharing. This function must be run in the WPA mode after
all inlinees are added. */
continue;
if ((!DECL_EXTERNAL (node->symbol.decl)
&& !DECL_COMDAT (node->symbol.decl))
- && (referenced_from_other_partition_p (&node->symbol.ref_list, set, vset)
- || reachable_from_other_partition_p (node, set)))
+ && (set_referenced_from_other_partition_p (&node->symbol.ref_list, set, vset)
+ || set_reachable_from_other_partition_p (node, set)))
promote_fn (node);
}
for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
&& !DECL_EXTERNAL (vnode->symbol.decl)
&& !DECL_COMDAT (vnode->symbol.decl)
&& !vnode->symbol.externally_visible && vnode->analyzed
- && referenced_from_other_partition_p (&vnode->symbol.ref_list,
+ && set_referenced_from_other_partition_p (&vnode->symbol.ref_list,
set, vset))
promote_var (vnode);
}
if (const_value_known_p (vnode->symbol.decl)
&& DECL_INITIAL (vnode->symbol.decl)
&& !varpool_node_in_set_p (vnode, vset)
- && referenced_from_this_partition_p (&vnode->symbol.ref_list, set, vset)
+ && set_referenced_from_this_partition_p (&vnode->symbol.ref_list, set, vset)
&& !pointer_set_insert (inserted, vnode))
VEC_safe_push (varpool_node_ptr, heap, promoted_initializers, vnode);
those node in SET. */
static void
-ipa_write_summaries_2 (struct opt_pass *pass, cgraph_node_set set,
- varpool_node_set vset,
- struct lto_out_decl_state *state)
+ipa_write_summaries_2 (struct opt_pass *pass, struct lto_out_decl_state *state)
{
while (pass)
{
pass_init_dump_file (pass);
- ipa_pass->write_summary (set,vset);
+ ipa_pass->write_summary ();
pass_fini_dump_file (pass);
}
if (pass->sub && pass->sub->type != GIMPLE_PASS)
- ipa_write_summaries_2 (pass->sub, set, vset, state);
+ ipa_write_summaries_2 (pass->sub, state);
pass = pass->next;
}
lto_push_out_decl_state (state);
gcc_assert (!flag_wpa);
- ipa_write_summaries_2 (all_regular_ipa_passes, set, vset, state);
- ipa_write_summaries_2 (all_lto_gen_passes, set, vset, state);
+ ipa_write_summaries_2 (all_regular_ipa_passes, state);
+ ipa_write_summaries_2 (all_lto_gen_passes, state);
gcc_assert (lto_get_out_decl_state () == state);
lto_pop_out_decl_state ();
only those node in SET. */
static void
-ipa_write_optimization_summaries_1 (struct opt_pass *pass, cgraph_node_set set,
- varpool_node_set vset,
- struct lto_out_decl_state *state)
+ipa_write_optimization_summaries_1 (struct opt_pass *pass, struct lto_out_decl_state *state)
{
while (pass)
{
pass_init_dump_file (pass);
- ipa_pass->write_optimization_summary (set, vset);
+ ipa_pass->write_optimization_summary ();
pass_fini_dump_file (pass);
}
if (pass->sub && pass->sub->type != GIMPLE_PASS)
- ipa_write_optimization_summaries_1 (pass->sub, set, vset, state);
+ ipa_write_optimization_summaries_1 (pass->sub, state);
pass = pass->next;
}
}
gcc_assert (flag_wpa);
- ipa_write_optimization_summaries_1 (all_regular_ipa_passes, set, vset, state);
- ipa_write_optimization_summaries_1 (all_lto_gen_passes, set, vset, state);
+ ipa_write_optimization_summaries_1 (all_regular_ipa_passes, state);
+ ipa_write_optimization_summaries_1 (all_lto_gen_passes, state);
gcc_assert (lto_get_out_decl_state () == state);
lto_pop_out_decl_state ();
void (*generate_summary) (void);
/* This hook is used to serialize IPA summaries on disk. */
- void (*write_summary) (struct cgraph_node_set_def *,
- struct varpool_node_set_def *);
+ void (*write_summary) (void);
/* This hook is used to deserialize IPA summaries from disk. */
void (*read_summary) (void);
/* This hook is used to serialize IPA optimization summaries on disk. */
- void (*write_optimization_summary) (struct cgraph_node_set_def *,
- struct varpool_node_set_def *);
+ void (*write_optimization_summary) (void);
/* This hook is used to deserialize IPA summaries from disk. */
void (*read_optimization_summary) (void);
projects / thirdparty / gcc.git / commitdiff
