#define GCC_CGRAPH_H
#include "tree.h"
#include "basic-block.h"
-#include "ipa-ref.h"
enum availability
{
struct GTY(()) cgraph_local_info {
/* File stream where this node is being written to. */
- struct lto_file_decl_data * lto_file_data;
+ struct lto_file_decl_data * GTY ((skip)) lto_file_data;
struct inline_summary inline_summary;
/* False when there something makes inlining impossible (such as va_arg). */
unsigned inlinable : 1;
- /* False when there something makes versioning impossible.
- Currently computed and used only by ipa-cp. */
- unsigned versionable : 1;
-
/* True when function should be inlined independently on its size. */
unsigned disregard_inline_limits : 1;
redefined now. */
unsigned redefined_extern_inline : 1;
+ /* True if statics_read_for_function and
+ statics_written_for_function contain valid data. */
+ unsigned for_functions_valid : 1;
+
/* True if the function is going to be emitted in some other translation
unit, referenced from vtable. */
unsigned vtable_method : 1;
/* Estimated growth after inlining. INT_MIN if not computed. */
int estimated_growth;
+
+ /* Set iff the function has been inlined at least once. */
+ bool inlined;
};
/* Information about the function that is propagated by the RTL backend.
tree old_tree;
/* The new (replacing) tree. */
tree new_tree;
- /* Parameter number to replace, when old_tree is NULL. */
- int parm_num;
/* True when a substitution should be done, false otherwise. */
bool replace_p;
/* True when we replace a reference to old_tree. */
bitmap combined_args_to_skip;
};
-enum node_frequency {
- /* This function most likely won't be executed at all.
- (set only when profile feedback is available or via function attribute). */
- NODE_FREQUENCY_UNLIKELY_EXECUTED,
- /* For functions that are known to be executed once (i.e. constructors, destructors
- and main function. */
- NODE_FREQUENCY_EXECUTED_ONCE,
- /* The default value. */
- NODE_FREQUENCY_NORMAL,
- /* Optimize this function hard
- (set only when profile feedback is available or via function attribute). */
- NODE_FREQUENCY_HOT
-};
-
-
/* The cgraph data structure.
Each function decl has assigned cgraph_node listing callees and callers. */
struct cgraph_edge *callers;
struct cgraph_node *next;
struct cgraph_node *previous;
- /* List of edges representing indirect calls with a yet undetermined
- callee. */
- struct cgraph_edge *indirect_calls;
/* For nested functions points to function the node is nested in. */
struct cgraph_node *origin;
/* Points to first nested function, if any. */
per-function in order to allow IPA passes to introduce new functions. */
VEC(ipa_opt_pass,heap) * GTY((skip)) ipa_transforms_to_apply;
- struct ipa_ref_list ref_list;
struct cgraph_local_info local;
struct cgraph_global_info global;
struct cgraph_rtl_info rtl;
/* Set once the function has been instantiated and its callee
lists created. */
unsigned analyzed : 1;
- /* Set when function is available in the other LTRANS partition. */
+ /* Set when function is available in the other LTO partition. */
unsigned in_other_partition : 1;
/* Set when function is scheduled to be processed by local passes. */
unsigned process : 1;
/* Set for alias and thunk nodes, same_body points to the node they are alias
of and they are linked through the next/previous pointers. */
unsigned same_body_alias : 1;
- /* How commonly executed the node is. Initialized during branch
- probabilities pass. */
- ENUM_BITFIELD (node_frequency) frequency : 2;
};
typedef struct cgraph_node *cgraph_node_ptr;
PTR GTY ((skip)) aux;
};
-typedef struct varpool_node *varpool_node_ptr;
-
-DEF_VEC_P(varpool_node_ptr);
-DEF_VEC_ALLOC_P(varpool_node_ptr,heap);
-DEF_VEC_ALLOC_P(varpool_node_ptr,gc);
-
-/* A varpool node set is a collection of varpool nodes. A varpool node
- can appear in multiple sets. */
-struct GTY(()) varpool_node_set_def
-{
- htab_t GTY((param_is (struct varpool_node_set_element_def))) hashtab;
- VEC(varpool_node_ptr, gc) *nodes;
- PTR GTY ((skip)) aux;
-};
-
typedef struct cgraph_node_set_def *cgraph_node_set;
DEF_VEC_P(cgraph_node_set);
DEF_VEC_ALLOC_P(cgraph_node_set,gc);
DEF_VEC_ALLOC_P(cgraph_node_set,heap);
-typedef struct varpool_node_set_def *varpool_node_set;
-
-DEF_VEC_P(varpool_node_set);
-DEF_VEC_ALLOC_P(varpool_node_set,gc);
-DEF_VEC_ALLOC_P(varpool_node_set,heap);
-
/* A cgraph node set element contains an index in the vector of nodes in
the set. */
struct GTY(()) cgraph_node_set_element_def
unsigned index;
} cgraph_node_set_iterator;
-/* A varpool node set element contains an index in the vector of nodes in
- the set. */
-struct GTY(()) varpool_node_set_element_def
-{
- struct varpool_node *node;
- HOST_WIDE_INT index;
-};
-
-typedef struct varpool_node_set_element_def *varpool_node_set_element;
-typedef const struct varpool_node_set_element_def *const_varpool_node_set_element;
-
-/* Iterator structure for varpool node sets. */
-typedef struct
-{
- varpool_node_set set;
- unsigned index;
-} varpool_node_set_iterator;
-
#define DEFCIFCODE(code, string) CIF_ ## code,
/* Reasons for inlining failures. */
typedef enum {
CIF_N_REASONS
} cgraph_inline_failed_t;
-/* Structure containing additional information about an indirect call. */
-
-struct GTY(()) cgraph_indirect_call_info
-{
- /* Offset accumulated from ancestor jump functions of inlined call graph
- edges. */
- HOST_WIDE_INT anc_offset;
- /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */
- HOST_WIDE_INT otr_token;
- /* Type of the object from OBJ_TYPE_REF_OBJECT. */
- tree otr_type;
- /* Index of the parameter that is called. */
- int param_index;
- /* ECF flags determined from the caller. */
- int ecf_flags;
-
- /* Set when the call is a virtual call with the parameter being the
- associated object pointer rather than a simple direct call. */
- unsigned polymorphic : 1;
-};
-
struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) cgraph_edge {
/* Expected number of executions: calculated in profile.c. */
gcov_type count;
struct cgraph_edge *prev_callee;
struct cgraph_edge *next_callee;
gimple call_stmt;
- /* Additional information about an indirect call. Not cleared when an edge
- becomes direct. */
- struct cgraph_indirect_call_info *indirect_info;
PTR GTY ((skip (""))) aux;
/* When equal to CIF_OK, inline this call. Otherwise, points to the
explanation why function was not inlined. */
int uid;
/* Depth of loop nest, 1 means no loop nest. */
unsigned short int loop_nest;
- /* Whether this edge was made direct by indirect inlining. */
- unsigned int indirect_inlining_edge : 1;
- /* Whether this edge describes an indirect call with an undetermined
- callee. */
- unsigned int indirect_unknown_callee : 1;
- /* Whether this edge is still a dangling */
+ /* Whether this edge describes a call that was originally indirect. */
+ unsigned int indirect_call : 1;
/* True if the corresponding CALL stmt cannot be inlined. */
unsigned int call_stmt_cannot_inline_p : 1;
/* Can this call throw externally? */
/* The varpool data structure.
Each static variable decl has assigned varpool_node. */
-struct GTY((chain_next ("%h.next"), chain_prev ("%h.prev"))) varpool_node {
+struct GTY((chain_next ("%h.next"))) varpool_node {
tree decl;
/* Pointer to the next function in varpool_nodes. */
- struct varpool_node *next, *prev;
+ struct varpool_node *next;
/* Pointer to the next function in varpool_nodes_queue. */
- struct varpool_node *next_needed, *prev_needed;
+ struct varpool_node *next_needed;
/* For normal nodes a pointer to the first extra name alias. For alias
nodes a pointer to the normal node. */
struct varpool_node *extra_name;
- struct ipa_ref_list ref_list;
- PTR GTY ((skip)) aux;
/* Ordering of all cgraph nodes. */
int order;
/* Set for aliases once they got through assemble_alias. Also set for
extra name aliases in varpool_extra_name_alias. */
unsigned alias : 1;
- /* Set when variable is used from other LTRANS partition. */
- unsigned used_from_other_partition : 1;
- /* Set when variable is available in the other LTRANS partition. */
- unsigned in_other_partition : 1;
};
/* Every top level asm statement is put into a cgraph_asm_node. */
struct cgraph_edge *cgraph_create_edge (struct cgraph_node *,
struct cgraph_node *,
gimple, gcov_type, int, int);
-struct cgraph_edge *cgraph_create_indirect_edge (struct cgraph_node *, gimple, int,
- gcov_type, int, int);
+
struct cgraph_node * cgraph_get_node (tree);
struct cgraph_node *cgraph_node (tree);
bool cgraph_same_body_alias (tree, tree);
struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *,
struct cgraph_node *, gimple,
unsigned, gcov_type, int, int, bool);
-struct cgraph_node * cgraph_clone_node (struct cgraph_node *, tree, gcov_type, int,
+struct cgraph_node * cgraph_clone_node (struct cgraph_node *, gcov_type, int,
int, bool, VEC(cgraph_edge_p,heap) *);
void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *);
-void cgraph_make_edge_direct (struct cgraph_edge *, struct cgraph_node *);
struct cgraph_asm_node *cgraph_add_asm_node (tree);
gimple cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *);
/* In cgraphbuild.c */
unsigned int rebuild_cgraph_edges (void);
-void cgraph_rebuild_references (void);
void reset_inline_failed (struct cgraph_node *);
int compute_call_stmt_bb_frequency (tree, basic_block bb);
void dump_cgraph_node_set (FILE *, cgraph_node_set);
void debug_cgraph_node_set (cgraph_node_set);
-varpool_node_set varpool_node_set_new (void);
-varpool_node_set_iterator varpool_node_set_find (varpool_node_set,
- struct varpool_node *);
-void varpool_node_set_add (varpool_node_set, struct varpool_node *);
-void varpool_node_set_remove (varpool_node_set, struct varpool_node *);
-void dump_varpool_node_set (FILE *, varpool_node_set);
-void debug_varpool_node_set (varpool_node_set);
-void ipa_discover_readonly_nonaddressable_vars (void);
/* In predict.c */
bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
void cgraph_make_node_local (struct cgraph_node *);
bool cgraph_node_can_be_local_p (struct cgraph_node *);
-
-struct varpool_node * varpool_get_node (tree decl);
-void varpool_remove_node (struct varpool_node *node);
bool varpool_assemble_pending_decls (void);
bool varpool_assemble_decl (struct varpool_node *node);
bool varpool_analyze_pending_decls (void);
void varpool_empty_needed_queue (void);
bool varpool_extra_name_alias (tree, tree);
const char * varpool_node_name (struct varpool_node *node);
-void varpool_reset_queue (void);
/* Walk all reachable static variables. */
#define FOR_EACH_STATIC_VARIABLE(node) \
/* Create a new static variable of type TYPE. */
tree add_new_static_var (tree type);
+/* lto-cgraph.c */
+
+enum LTO_cgraph_tags
+{
+ /* Must leave 0 for the stopper. */
+ LTO_cgraph_avail_node = 1,
+ LTO_cgraph_overwritable_node,
+ LTO_cgraph_unavail_node,
+ LTO_cgraph_edge,
+ LTO_cgraph_last_tag
+};
+
+extern const char * LTO_cgraph_tag_names[LTO_cgraph_last_tag];
+
+#define LCC_NOT_FOUND (-1)
+
+
/* Return true if iterator CSI points to nothing. */
static inline bool
csi_end_p (cgraph_node_set_iterator csi)
return htab_elements (set->hashtab);
}
-/* Return true if iterator VSI points to nothing. */
-static inline bool
-vsi_end_p (varpool_node_set_iterator vsi)
-{
- return vsi.index >= VEC_length (varpool_node_ptr, vsi.set->nodes);
-}
-
-/* Advance iterator VSI. */
-static inline void
-vsi_next (varpool_node_set_iterator *vsi)
-{
- vsi->index++;
-}
-
-/* Return the node pointed to by VSI. */
-static inline struct varpool_node *
-vsi_node (varpool_node_set_iterator vsi)
-{
- return VEC_index (varpool_node_ptr, vsi.set->nodes, vsi.index);
-}
-
-/* Return an iterator to the first node in SET. */
-static inline varpool_node_set_iterator
-vsi_start (varpool_node_set set)
-{
- varpool_node_set_iterator vsi;
-
- vsi.set = set;
- vsi.index = 0;
- return vsi;
-}
-
-/* Return true if SET contains NODE. */
-static inline bool
-varpool_node_in_set_p (struct varpool_node *node, varpool_node_set set)
-{
- varpool_node_set_iterator vsi;
- vsi = varpool_node_set_find (set, node);
- return !vsi_end_p (vsi);
-}
-
-/* Return number of nodes in SET. */
-static inline size_t
-varpool_node_set_size (varpool_node_set set)
-{
- return htab_elements (set->hashtab);
-}
-
/* Uniquize all constants that appear in memory.
Each constant in memory thus far output is recorded
in `const_desc_table'. */
hashval_t hash;
};
-/* Return true if set is nonempty. */
-static inline bool
-cgraph_node_set_nonempty_p (cgraph_node_set set)
-{
- return VEC_length (cgraph_node_ptr, set->nodes);
-}
-
-/* Return true if set is nonempty. */
-static inline bool
-varpool_node_set_nonempty_p (varpool_node_set set)
-{
- return VEC_length (varpool_node_ptr, set->nodes);
-}
-
/* Return true when function NODE is only called directly.
i.e. it is not externally visible, address was not taken and
it is not used in any other non-standard way. */
static inline bool
cgraph_only_called_directly_p (struct cgraph_node *node)
{
- return !node->needed && !node->address_taken && !node->local.externally_visible;
+ return !node->needed && !node->local.externally_visible;
}
/* Return true when function NODE can be removed from callgraph
if all direct calls are eliminated. */
static inline bool
-cgraph_can_remove_if_no_direct_calls_and_refs_p (struct cgraph_node *node)
+cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node)
{
return (!node->needed && !node->reachable_from_other_partition
&& (DECL_COMDAT (node->decl) || !node->local.externally_visible));
}
-/* Return true when function NODE can be removed from callgraph
- if all direct calls are eliminated. */
-
-static inline bool
-cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node)
-{
- return !node->address_taken && cgraph_can_remove_if_no_direct_calls_and_refs_p (node);
-}
-
-/* Return true when all references to VNODE must be visible in ipa_ref_list.
- i.e. if the variable is not externally visible or not used in some magic
- way (asm statement or such).
- The magic uses are all sumarized in force_output flag. */
-
-static inline bool
-varpool_all_refs_explicit_p (struct varpool_node *vnode)
-{
- return (!vnode->externally_visible
- && !vnode->used_from_other_partition
- && !vnode->force_output);
-}
-
/* Constant pool accessor function. */
htab_t constant_pool_htab (void);
-#include "ipa-ref-inline.h"
-
#endif /* GCC_CGRAPH_H */
#include "flags.h"
#include "params.h"
#include "input.h"
+#include "varray.h"
#include "hashtab.h"
#include "langhooks.h"
#include "basic-block.h"
#include "lto-streamer.h"
#include "gcov-io.h"
-static void output_varpool (cgraph_node_set, varpool_node_set);
-static void output_cgraph_opt_summary (void);
-static void input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes);
-
-
-/* Cgraph streaming is organized as set of record whose type
- is indicated by a tag. */
-enum LTO_cgraph_tags
-{
- /* Must leave 0 for the stopper. */
-
- /* Cgraph node without body available. */
- LTO_cgraph_unavail_node = 1,
- /* Cgraph node with function body. */
- LTO_cgraph_analyzed_node,
- /* Cgraph edges. */
- LTO_cgraph_edge,
- LTO_cgraph_indirect_edge
-};
-
/* Create a new cgraph encoder. */
lto_cgraph_encoder_t
lto_cgraph_encoder_t encoder = XCNEW (struct lto_cgraph_encoder_d);
encoder->map = pointer_map_create ();
encoder->nodes = NULL;
- encoder->body = pointer_set_create ();
return encoder;
}
{
VEC_free (cgraph_node_ptr, heap, encoder->nodes);
pointer_map_destroy (encoder->map);
- pointer_set_destroy (encoder->body);
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 TRUE if we should encode initializer of NODE (if any). */
-
-bool
-lto_cgraph_encoder_encode_body_p (lto_cgraph_encoder_t encoder,
- struct cgraph_node *node)
-{
- return pointer_set_contains (encoder->body, node);
-}
-
-/* Return TRUE if we should encode body of NODE (if any). */
-
-static void
-lto_set_cgraph_encoder_encode_body (lto_cgraph_encoder_t encoder,
- struct cgraph_node *node)
-{
- pointer_set_insert (encoder->body, node);
-}
-
-/* Create a new varpool encoder. */
-
-lto_varpool_encoder_t
-lto_varpool_encoder_new (void)
-{
- lto_varpool_encoder_t encoder = XCNEW (struct lto_varpool_encoder_d);
- encoder->map = pointer_map_create ();
- encoder->initializer = pointer_set_create ();
- encoder->nodes = NULL;
- return encoder;
-}
-
-
-/* Delete ENCODER and its components. */
-
-void
-lto_varpool_encoder_delete (lto_varpool_encoder_t encoder)
-{
- VEC_free (varpool_node_ptr, heap, encoder->nodes);
- pointer_map_destroy (encoder->map);
- pointer_set_destroy (encoder->initializer);
- free (encoder);
-}
-
-
-/* Return the existing reference number of NODE in the varpool encoder in
- output block OB. Assign a new reference if this is the first time
- NODE is encoded. */
-
-int
-lto_varpool_encoder_encode (lto_varpool_encoder_t encoder,
- struct varpool_node *node)
-{
- int ref;
- void **slot;
-
- slot = pointer_map_contains (encoder->map, node);
- if (!slot)
- {
- ref = VEC_length (varpool_node_ptr, encoder->nodes);
- slot = pointer_map_insert (encoder->map, node);
- *slot = (void *) (intptr_t) ref;
- VEC_safe_push (varpool_node_ptr, heap, encoder->nodes, node);
- }
- else
- ref = (int) (intptr_t) *slot;
-
- return ref;
-}
-
-/* Look up NODE in encoder. Return NODE's reference if it has been encoded
- or LCC_NOT_FOUND if it is not there. */
-
-int
-lto_varpool_encoder_lookup (lto_varpool_encoder_t encoder,
- struct varpool_node *node)
-{
- void **slot = pointer_map_contains (encoder->map, node);
- return (slot ? (int) (intptr_t) *slot : LCC_NOT_FOUND);
-}
-
-
-/* Return the varpool node corresponding to REF using ENCODER. */
-
-struct varpool_node *
-lto_varpool_encoder_deref (lto_varpool_encoder_t encoder, int ref)
-{
- if (ref == LCC_NOT_FOUND)
- return NULL;
-
- return VEC_index (varpool_node_ptr, encoder->nodes, ref);
-}
-
-
/* Return number of encoded nodes in ENCODER. */
static int
-lto_varpool_encoder_size (lto_varpool_encoder_t encoder)
+lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
{
- return VEC_length (varpool_node_ptr, encoder->nodes);
+ return VEC_length (cgraph_node_ptr, encoder->nodes);
}
-/* Return TRUE if we should encode initializer of NODE (if any). */
-
-bool
-lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t encoder,
- struct varpool_node *node)
-{
- return pointer_set_contains (encoder->initializer, node);
-}
-
-/* Return TRUE if we should encode initializer of NODE (if any). */
-
-static void
-lto_set_varpool_encoder_encode_initializer (lto_varpool_encoder_t encoder,
- struct varpool_node *node)
-{
- pointer_set_insert (encoder->initializer, node);
-}
/* Output the cgraph EDGE to OB using ENCODER. */
intptr_t ref;
struct bitpack_d *bp;
- if (edge->indirect_unknown_callee)
- lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_indirect_edge);
- else
- lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
+ lto_output_uleb128_stream (ob->main_stream, LTO_cgraph_edge);
ref = lto_cgraph_encoder_lookup (encoder, edge->caller);
gcc_assert (ref != LCC_NOT_FOUND);
lto_output_sleb128_stream (ob->main_stream, ref);
- if (!edge->indirect_unknown_callee)
- {
- ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
- gcc_assert (ref != LCC_NOT_FOUND);
- lto_output_sleb128_stream (ob->main_stream, ref);
- }
+ ref = lto_cgraph_encoder_lookup (encoder, edge->callee);
+ gcc_assert (ref != LCC_NOT_FOUND);
+ lto_output_sleb128_stream (ob->main_stream, ref);
lto_output_sleb128_stream (ob->main_stream, edge->count);
bp_pack_value (bp, edge->inline_failed, HOST_BITS_PER_INT);
bp_pack_value (bp, edge->frequency, HOST_BITS_PER_INT);
bp_pack_value (bp, edge->loop_nest, 30);
- bp_pack_value (bp, edge->indirect_inlining_edge, 1);
+ bp_pack_value (bp, edge->indirect_call, 1);
bp_pack_value (bp, edge->call_stmt_cannot_inline_p, 1);
bp_pack_value (bp, edge->can_throw_external, 1);
- if (edge->indirect_unknown_callee)
- {
- int flags = edge->indirect_info->ecf_flags;
- bp_pack_value (bp, (flags & ECF_CONST) != 0, 1);
- bp_pack_value (bp, (flags & ECF_PURE) != 0, 1);
- bp_pack_value (bp, (flags & ECF_NORETURN) != 0, 1);
- bp_pack_value (bp, (flags & ECF_MALLOC) != 0, 1);
- bp_pack_value (bp, (flags & ECF_NOTHROW) != 0, 1);
- bp_pack_value (bp, (flags & ECF_RETURNS_TWICE) != 0, 1);
- /* Flags that should not appear on indirect calls. */
- gcc_assert (!(flags & (ECF_LOOPING_CONST_OR_PURE
- | ECF_MAY_BE_ALLOCA
- | ECF_SIBCALL
- | ECF_NOVOPS)));
- }
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
}
-/* 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)
-{
- int i;
- struct ipa_ref *ref;
- for (i = 0; ipa_ref_list_refering_iterate (list, i, ref); i++)
- {
- if (ref->refering_type == IPA_REF_CGRAPH)
- {
- if (!cgraph_node_in_set_p (ipa_ref_refering_node (ref), set))
- return true;
- }
- else
- {
- if (!varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref),
- vset))
- return true;
- }
- }
- return false;
-}
-
/* Return true when node is reachable from other partition. */
-bool
+static bool
reachable_from_other_partition_p (struct cgraph_node *node, cgraph_node_set set)
{
struct cgraph_edge *e;
+ if (node->needed)
+ return true;
if (!node->analyzed)
return false;
if (node->global.inlined_to)
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)
-{
- int i;
- struct ipa_ref *ref;
- for (i = 0; ipa_ref_list_refering_iterate (list, i, ref); i++)
- {
- if (ref->refering_type == IPA_REF_CGRAPH)
- {
- if (cgraph_node_in_set_p (ipa_ref_refering_node (ref), set))
- return true;
- }
- else
- {
- if (varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref),
- vset))
- 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)
-{
- 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 (cgraph_node_in_set_p (e->caller, set))
- return true;
- return false;
-}
-
/* Output the cgraph NODE to OB. ENCODER is used to find the
reference number of NODE->inlined_to. SET is the set of nodes we
are writing to the current file. If NODE is not in SET, then NODE
static void
lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
lto_cgraph_encoder_t encoder, cgraph_node_set set,
- varpool_node_set vset)
+ bitmap written_decls)
{
unsigned int tag;
struct bitpack_d *bp;
- bool boundary_p;
+ unsigned local, externally_visible, inlinable, analyzed;
+ bool boundary_p, wrote_decl_p;
intptr_t ref;
bool in_other_partition = false;
- struct cgraph_node *clone_of;
boundary_p = !cgraph_node_in_set_p (node, set);
+ wrote_decl_p = bitmap_bit_p (written_decls, DECL_UID (node->decl));
- if (node->analyzed && !boundary_p)
- tag = LTO_cgraph_analyzed_node;
- else
+ switch (cgraph_function_body_availability (node))
+ {
+ case AVAIL_NOT_AVAILABLE:
+ tag = LTO_cgraph_unavail_node;
+ break;
+
+ case AVAIL_AVAILABLE:
+ case AVAIL_LOCAL:
+ tag = LTO_cgraph_avail_node;
+ break;
+
+ case AVAIL_OVERWRITABLE:
+ tag = LTO_cgraph_overwritable_node;
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+
+ if (boundary_p)
tag = LTO_cgraph_unavail_node;
lto_output_uleb128_stream (ob->main_stream, tag);
+ local = node->local.local;
+ externally_visible = node->local.externally_visible;
+ inlinable = node->local.inlinable;
+ analyzed = node->analyzed;
+
/* In WPA mode, we only output part of the call-graph. Also, we
fake cgraph node attributes. There are two cases that we care.
Cherry-picked nodes: These are nodes we pulled from other
translation units into SET during IPA-inlining. We make them as
local static nodes to prevent clashes with other local statics. */
- if (boundary_p && node->analyzed)
+ if (boundary_p)
{
/* Inline clones can not be part of boundary.
gcc_assert (!node->global.inlined_to);
needs a bit extra work and will be promplty done by cgraph_remove_node
after reading back. */
in_other_partition = 1;
+ analyzed = 0;
}
- clone_of = node->clone_of;
- while (clone_of
- && (ref = lto_cgraph_encoder_lookup (encoder, node->clone_of)) == LCC_NOT_FOUND)
- if (clone_of->prev_sibling_clone)
- clone_of = clone_of->prev_sibling_clone;
- else
- clone_of = clone_of->clone_of;
- if (!clone_of)
- lto_output_sleb128_stream (ob->main_stream, LCC_NOT_FOUND);
- else
- lto_output_sleb128_stream (ob->main_stream, ref);
+ lto_output_uleb128_stream (ob->main_stream, wrote_decl_p);
+ if (!wrote_decl_p)
+ bitmap_set_bit (written_decls, DECL_UID (node->decl));
lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->decl);
lto_output_sleb128_stream (ob->main_stream, node->count);
bp = bitpack_create ();
- bp_pack_value (bp, node->local.local, 1);
- bp_pack_value (bp, node->local.externally_visible, 1);
+ bp_pack_value (bp, local, 1);
+ bp_pack_value (bp, externally_visible, 1);
bp_pack_value (bp, node->local.finalized, 1);
- bp_pack_value (bp, node->local.inlinable, 1);
- bp_pack_value (bp, node->local.versionable, 1);
+ bp_pack_value (bp, inlinable, 1);
bp_pack_value (bp, node->local.disregard_inline_limits, 1);
bp_pack_value (bp, node->local.redefined_extern_inline, 1);
+ bp_pack_value (bp, node->local.for_functions_valid, 1);
bp_pack_value (bp, node->local.vtable_method, 1);
bp_pack_value (bp, node->needed, 1);
bp_pack_value (bp, node->address_taken, 1);
bp_pack_value (bp, node->abstract_and_needed, 1);
- bp_pack_value (bp, tag == LTO_cgraph_analyzed_node
- && !DECL_EXTERNAL (node->decl)
- && (reachable_from_other_partition_p (node, set)
- || referenced_from_other_partition_p (&node->ref_list, set, vset)), 1);
+ bp_pack_value (bp, node->reachable, 1);
+ bp_pack_value (bp, analyzed && reachable_from_other_partition_p (node, set), 1);
bp_pack_value (bp, node->lowered, 1);
+ bp_pack_value (bp, analyzed, 1);
bp_pack_value (bp, in_other_partition, 1);
+ bp_pack_value (bp, node->process, 1);
bp_pack_value (bp, node->alias, 1);
bp_pack_value (bp, node->finalized_by_frontend, 1);
- bp_pack_value (bp, node->frequency, 2);
lto_output_bitpack (ob->main_stream, bp);
bitpack_delete (bp);
- if (tag == LTO_cgraph_analyzed_node)
+ if (tag != LTO_cgraph_unavail_node)
{
lto_output_sleb128_stream (ob->main_stream,
node->local.inline_summary.estimated_self_stack_size);
node->local.inline_summary.self_time);
lto_output_sleb128_stream (ob->main_stream,
node->local.inline_summary.time_inlining_benefit);
- if (node->global.inlined_to)
- {
- ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
- gcc_assert (ref != LCC_NOT_FOUND);
- }
- else
- ref = LCC_NOT_FOUND;
+ }
- lto_output_sleb128_stream (ob->main_stream, ref);
+ /* FIXME lto: Outputting global info is not neccesary until after
+ inliner was run. Global structure holds results of propagation
+ done by inliner. */
+ lto_output_sleb128_stream (ob->main_stream,
+ node->global.estimated_stack_size);
+ lto_output_sleb128_stream (ob->main_stream,
+ node->global.stack_frame_offset);
+ if (node->global.inlined_to && !boundary_p)
+ {
+ ref = lto_cgraph_encoder_lookup (encoder, node->global.inlined_to);
+ gcc_assert (ref != LCC_NOT_FOUND);
}
+ else
+ ref = LCC_NOT_FOUND;
+ lto_output_sleb128_stream (ob->main_stream, ref);
- if (node->same_comdat_group && !boundary_p)
+ lto_output_sleb128_stream (ob->main_stream, node->global.time);
+ lto_output_sleb128_stream (ob->main_stream, node->global.size);
+ lto_output_sleb128_stream (ob->main_stream,
+ node->global.estimated_growth);
+ lto_output_uleb128_stream (ob->main_stream, node->global.inlined);
+ if (node->same_comdat_group)
{
ref = lto_cgraph_encoder_lookup (encoder, node->same_comdat_group);
gcc_assert (ref != LCC_NOT_FOUND);
lto_output_uleb128_stream (ob->main_stream, 0);
}
-/* Output the varpool NODE to OB.
- If NODE is not in SET, then NODE is a boundary. */
-
-static void
-lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
- cgraph_node_set set, varpool_node_set vset)
-{
- bool boundary_p = !varpool_node_in_set_p (node, vset) && node->analyzed;
- struct bitpack_d *bp;
- struct varpool_node *alias;
- int count = 0;
-
- lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
- bp = bitpack_create ();
- bp_pack_value (bp, node->externally_visible, 1);
- bp_pack_value (bp, node->force_output, 1);
- bp_pack_value (bp, node->finalized, 1);
- bp_pack_value (bp, node->alias, 1);
- gcc_assert (!node->alias || !node->extra_name);
- gcc_assert (node->finalized || !node->analyzed);
- gcc_assert (node->needed);
- /* Constant pool initializers can be de-unified into individual ltrans units.
- FIXME: Alternatively at -Os we may want to avoid generating for them the local
- labels and share them across LTRANS partitions. */
- if (DECL_IN_CONSTANT_POOL (node->decl))
- {
- bp_pack_value (bp, 0, 1); /* used_from_other_parition. */
- bp_pack_value (bp, 0, 1); /* in_other_partition. */
- }
- else
- {
- bp_pack_value (bp, node->analyzed
- && referenced_from_other_partition_p (&node->ref_list,
- set, vset), 1);
- bp_pack_value (bp, boundary_p, 1); /* in_other_partition. */
- }
- /* Also emit any extra name aliases. */
- for (alias = node->extra_name; alias; alias = alias->next)
- count++;
- bp_pack_value (bp, count != 0, 1);
- lto_output_bitpack (ob->main_stream, bp);
- bitpack_delete (bp);
-
- if (count)
- {
- lto_output_uleb128_stream (ob->main_stream, count);
- for (alias = node->extra_name; alias; alias = alias->next)
- lto_output_var_decl_index (ob->decl_state, ob->main_stream, alias->decl);
- }
-}
-
-/* Output the varpool NODE to OB.
- If NODE is not in SET, then NODE is a boundary. */
-
-static void
-lto_output_ref (struct lto_simple_output_block *ob, struct ipa_ref *ref,
- lto_cgraph_encoder_t encoder,
- lto_varpool_encoder_t varpool_encoder)
-{
- struct bitpack_d *bp = bitpack_create ();
- bp_pack_value (bp, ref->refered_type, 1);
- bp_pack_value (bp, ref->use, 2);
- lto_output_bitpack (ob->main_stream, bp);
- bitpack_delete (bp);
- if (ref->refered_type == IPA_REF_CGRAPH)
- {
- int nref = lto_cgraph_encoder_lookup (encoder, ipa_ref_node (ref));
- gcc_assert (nref != LCC_NOT_FOUND);
- lto_output_sleb128_stream (ob->main_stream, nref);
- }
- else
- {
- int nref = lto_varpool_encoder_lookup (varpool_encoder,
- ipa_ref_varpool_node (ref));
- gcc_assert (nref != LCC_NOT_FOUND);
- lto_output_sleb128_stream (ob->main_stream, nref);
- }
-}
-
/* Stream out profile_summary to OB. */
static void
/* Add NODE into encoder as well as nodes it is cloned from.
Do it in a way so clones appear first. */
-
static void
-add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node,
- bool include_body)
+add_node_to (lto_cgraph_encoder_t encoder, struct cgraph_node *node)
{
if (node->clone_of)
- add_node_to (encoder, node->clone_of, include_body);
- else if (include_body)
- lto_set_cgraph_encoder_encode_body (encoder, node);
+ add_node_to (encoder, node->clone_of);
lto_cgraph_encoder_encode (encoder, node);
}
-/* Add all references in LIST to encoders. */
-
-static void
-add_references (lto_cgraph_encoder_t encoder,
- lto_varpool_encoder_t varpool_encoder,
- struct ipa_ref_list *list)
-{
- int i;
- struct ipa_ref *ref;
- for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
- if (ref->refered_type == IPA_REF_CGRAPH)
- add_node_to (encoder, ipa_ref_node (ref), false);
- else
- {
- struct varpool_node *vnode = ipa_ref_varpool_node (ref);
- lto_varpool_encoder_encode (varpool_encoder, vnode);
- }
-}
-
-/* Output all callees or indirect outgoing edges. EDGE must be the first such
- edge. */
-
-static void
-output_outgoing_cgraph_edges (struct cgraph_edge *edge,
- struct lto_simple_output_block *ob,
- lto_cgraph_encoder_t encoder)
-{
- if (!edge)
- return;
-
- /* Output edges in backward direction, so the reconstructed callgraph match
- and it is easy to associate call sites in the IPA pass summaries. */
- while (edge->next_callee)
- edge = edge->next_callee;
- for (; edge; edge = edge->prev_callee)
- lto_output_edge (ob, edge, encoder);
-}
-
/* Output the part of the cgraph in SET. */
-static void
-output_refs (cgraph_node_set set, varpool_node_set vset,
- lto_cgraph_encoder_t encoder,
- lto_varpool_encoder_t varpool_encoder)
-{
- cgraph_node_set_iterator csi;
- varpool_node_set_iterator vsi;
- struct lto_simple_output_block *ob;
- int count;
- struct ipa_ref *ref;
- int i;
-
- 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->ref_list);
- if (count)
- {
- lto_output_uleb128_stream (ob->main_stream, count);
- lto_output_uleb128_stream (ob->main_stream,
- lto_cgraph_encoder_lookup (encoder, node));
- for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
- lto_output_ref (ob, ref, encoder, varpool_encoder);
- }
- }
-
- lto_output_uleb128_stream (ob->main_stream, 0);
-
- for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
- {
- struct varpool_node *node = vsi_node (vsi);
-
- count = ipa_ref_list_nreferences (&node->ref_list);
- if (count)
- {
- lto_output_uleb128_stream (ob->main_stream, count);
- lto_output_uleb128_stream (ob->main_stream,
- lto_varpool_encoder_lookup (varpool_encoder,
- node));
- for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
- lto_output_ref (ob, ref, encoder, varpool_encoder);
- }
- }
-
- lto_output_uleb128_stream (ob->main_stream, 0);
-
- lto_destroy_simple_output_block (ob);
-}
-
-/* Find out all cgraph and varpool nodes we want to encode in current unit
- and insert them to encoders. */
void
-compute_ltrans_boundary (struct lto_out_decl_state *state,
- cgraph_node_set set, varpool_node_set vset)
+output_cgraph (cgraph_node_set set)
{
struct cgraph_node *node;
+ struct lto_simple_output_block *ob;
cgraph_node_set_iterator csi;
- varpool_node_set_iterator vsi;
struct cgraph_edge *edge;
- int i;
+ int i, n_nodes;
+ bitmap written_decls;
lto_cgraph_encoder_t encoder;
- lto_varpool_encoder_t varpool_encoder;
+ struct cgraph_asm_node *can;
+
+ ob = lto_create_simple_output_block (LTO_section_cgraph);
+
+ output_profile_summary (ob);
- encoder = state->cgraph_node_encoder = lto_cgraph_encoder_new ();
- varpool_encoder = state->varpool_node_encoder = lto_varpool_encoder_new ();
+ /* An encoder for cgraph nodes should have been created by
+ ipa_write_summaries_1. */
+ gcc_assert (ob->decl_state->cgraph_node_encoder);
+ encoder = ob->decl_state->cgraph_node_encoder;
+
+ /* The FUNCTION_DECLs for which we have written a node. The first
+ node found is written as the "original" node, the remaining nodes
+ are considered its clones. */
+ written_decls = lto_bitmap_alloc ();
/* Go over all the nodes in SET and assign references. */
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
{
node = csi_node (csi);
- add_node_to (encoder, node, true);
- add_references (encoder, varpool_encoder, &node->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);
- lto_varpool_encoder_encode (varpool_encoder, vnode);
- lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
- add_references (encoder, varpool_encoder, &vnode->ref_list);
- }
- /* Pickle in also the initializer of all referenced readonly variables
- to help folding. Constant pool variables are not shared, so we must
- pickle those too. */
- for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
- {
- struct varpool_node *vnode = lto_varpool_encoder_deref (varpool_encoder, i);
- if (DECL_INITIAL (vnode->decl)
- && !lto_varpool_encoder_encode_initializer_p (varpool_encoder,
- vnode)
- && (DECL_IN_CONSTANT_POOL (vnode->decl)
- || TREE_READONLY (vnode->decl)))
- {
- lto_set_varpool_encoder_encode_initializer (varpool_encoder, vnode);
- add_references (encoder, varpool_encoder, &vnode->ref_list);
- }
+ add_node_to (encoder, node);
}
/* Go over all the nodes again to include callees that are not in
{
/* We should have moved all the inlines. */
gcc_assert (!callee->global.inlined_to);
- add_node_to (encoder, callee, false);
+ add_node_to (encoder, callee);
+ /* Also with each included function include all other functions
+ in the same comdat group. */
+ if (callee->same_comdat_group)
+ {
+ struct cgraph_node *next;
+ for (next = callee->same_comdat_group;
+ next != callee;
+ next = next->same_comdat_group)
+ if (!cgraph_node_in_set_p (next, set))
+ add_node_to (encoder, next);
+ }
}
}
+ /* Also with each included function include all other functions
+ in the same comdat group. */
+ if (node->same_comdat_group)
+ {
+ struct cgraph_node *next;
+ for (next = node->same_comdat_group;
+ next != node;
+ next = next->same_comdat_group)
+ if (!cgraph_node_in_set_p (next, set))
+ add_node_to (encoder, next);
+ }
}
-}
-
-/* Output the part of the cgraph in SET. */
-
-void
-output_cgraph (cgraph_node_set set, varpool_node_set vset)
-{
- struct cgraph_node *node;
- struct lto_simple_output_block *ob;
- cgraph_node_set_iterator csi;
- int i, n_nodes;
- lto_cgraph_encoder_t encoder;
- lto_varpool_encoder_t varpool_encoder;
- struct cgraph_asm_node *can;
-
- if (flag_wpa)
- output_cgraph_opt_summary ();
-
- ob = lto_create_simple_output_block (LTO_section_cgraph);
-
- output_profile_summary (ob);
-
- /* An encoder for cgraph nodes should have been created by
- ipa_write_summaries_1. */
- gcc_assert (ob->decl_state->cgraph_node_encoder);
- gcc_assert (ob->decl_state->varpool_node_encoder);
- encoder = ob->decl_state->cgraph_node_encoder;
- varpool_encoder = ob->decl_state->varpool_node_encoder;
/* Write out the nodes. We must first output a node and then its clones,
otherwise at a time reading back the node there would be nothing to clone
for (i = 0; i < n_nodes; i++)
{
node = lto_cgraph_encoder_deref (encoder, i);
- lto_output_node (ob, node, encoder, set, vset);
+ lto_output_node (ob, node, encoder, set, written_decls);
}
+ lto_bitmap_free (written_decls);
+
/* Go over the nodes in SET again to write edges. */
for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
{
node = csi_node (csi);
- output_outgoing_cgraph_edges (node->callees, ob, encoder);
- output_outgoing_cgraph_edges (node->indirect_calls, ob, encoder);
+ if (node->callees)
+ {
+ /* Output edges in backward direction, so the reconstructed callgraph
+ match and it is easy to associate call sites in the IPA pass summaries. */
+ edge = node->callees;
+ while (edge->next_callee)
+ edge = edge->next_callee;
+ for (; edge; edge = edge->prev_callee)
+ lto_output_edge (ob, edge, encoder);
+ }
}
lto_output_uleb128_stream (ob->main_stream, 0);
lto_output_uleb128_stream (ob->main_stream, 0);
lto_destroy_simple_output_block (ob);
- output_varpool (set, vset);
- output_refs (set, vset, encoder, varpool_encoder);
}
+
/* Overwrite the information in NODE based on FILE_DATA, TAG, FLAGS,
STACK_SIZE, SELF_TIME and SELF_SIZE. This is called either to initialize
NODE or to replace the values in it, for instance because the first
node->local.inline_summary.size_inlining_benefit = size_inlining_benefit;
node->global.time = self_time;
node->global.size = self_size;
- node->global.estimated_stack_size = stack_size;
- node->global.estimated_growth = INT_MIN;
node->local.lto_file_data = file_data;
node->local.local = bp_unpack_value (bp, 1);
node->local.externally_visible = bp_unpack_value (bp, 1);
node->local.finalized = bp_unpack_value (bp, 1);
node->local.inlinable = bp_unpack_value (bp, 1);
- node->local.versionable = bp_unpack_value (bp, 1);
node->local.disregard_inline_limits = bp_unpack_value (bp, 1);
node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
+ node->local.for_functions_valid = bp_unpack_value (bp, 1);
node->local.vtable_method = bp_unpack_value (bp, 1);
node->needed = bp_unpack_value (bp, 1);
node->address_taken = bp_unpack_value (bp, 1);
node->abstract_and_needed = bp_unpack_value (bp, 1);
+ node->reachable = bp_unpack_value (bp, 1);
node->reachable_from_other_partition = bp_unpack_value (bp, 1);
node->lowered = bp_unpack_value (bp, 1);
- node->analyzed = tag == LTO_cgraph_analyzed_node;
+ node->analyzed = bp_unpack_value (bp, 1);
node->in_other_partition = bp_unpack_value (bp, 1);
+ node->process = bp_unpack_value (bp, 1);
node->alias = bp_unpack_value (bp, 1);
node->finalized_by_frontend = bp_unpack_value (bp, 1);
- node->frequency = (enum node_frequency)bp_unpack_value (bp, 2);
}
-/* Output the part of the cgraph in SET. */
-
-static void
-output_varpool (cgraph_node_set set, varpool_node_set vset)
-{
- struct lto_simple_output_block *ob = lto_create_simple_output_block (LTO_section_varpool);
- lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
- int len = lto_varpool_encoder_size (varpool_encoder), i;
-
- lto_output_uleb128_stream (ob->main_stream, len);
-
- /* Write out the nodes. We must first output a node and then its clones,
- otherwise at a time reading back the node there would be nothing to clone
- from. */
- for (i = 0; i < len; i++)
- {
- lto_output_varpool_node (ob, lto_varpool_encoder_deref (varpool_encoder, i),
- set, vset);
- }
-
- lto_destroy_simple_output_block (ob);
-}
/* Read a node from input_block IB. TAG is the node's tag just read.
Return the node read or overwriten. */
static struct cgraph_node *
input_node (struct lto_file_decl_data *file_data,
struct lto_input_block *ib,
- enum LTO_cgraph_tags tag,
- VEC(cgraph_node_ptr, heap) *nodes)
+ enum LTO_cgraph_tags tag)
{
tree fn_decl;
struct cgraph_node *node;
struct bitpack_d *bp;
int stack_size = 0;
unsigned decl_index;
+ bool clone_p;
+ int estimated_stack_size = 0;
+ int stack_frame_offset = 0;
int ref = LCC_NOT_FOUND, ref2 = LCC_NOT_FOUND;
+ int estimated_growth = 0;
+ int time = 0;
+ int size = 0;
int self_time = 0;
int self_size = 0;
int time_inlining_benefit = 0;
int size_inlining_benefit = 0;
unsigned long same_body_count = 0;
- int clone_ref;
+ bool inlined = false;
- clone_ref = lto_input_sleb128 (ib);
+ clone_p = (lto_input_uleb128 (ib) != 0);
decl_index = lto_input_uleb128 (ib);
fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- if (clone_ref != LCC_NOT_FOUND)
- {
- node = cgraph_clone_node (VEC_index (cgraph_node_ptr, nodes, clone_ref), fn_decl,
- 0, CGRAPH_FREQ_BASE, 0, false, NULL);
- }
+ if (clone_p)
+ node = cgraph_clone_node (cgraph_node (fn_decl), 0,
+ CGRAPH_FREQ_BASE, 0, false, NULL);
+
else
node = cgraph_node (fn_decl);
node->count = lto_input_sleb128 (ib);
bp = lto_input_bitpack (ib);
- if (tag == LTO_cgraph_analyzed_node)
+ if (tag != LTO_cgraph_unavail_node)
{
stack_size = lto_input_sleb128 (ib);
self_size = lto_input_sleb128 (ib);
size_inlining_benefit = lto_input_sleb128 (ib);
self_time = lto_input_sleb128 (ib);
time_inlining_benefit = lto_input_sleb128 (ib);
-
- ref = lto_input_sleb128 (ib);
}
+ estimated_stack_size = lto_input_sleb128 (ib);
+ stack_frame_offset = lto_input_sleb128 (ib);
+ ref = lto_input_sleb128 (ib);
+ time = lto_input_sleb128 (ib);
+ size = lto_input_sleb128 (ib);
+ estimated_growth = lto_input_sleb128 (ib);
+ inlined = lto_input_uleb128 (ib);
ref2 = lto_input_sleb128 (ib);
same_body_count = lto_input_uleb128 (ib);
size_inlining_benefit);
bitpack_delete (bp);
+ node->global.estimated_stack_size = estimated_stack_size;
+ node->global.stack_frame_offset = stack_frame_offset;
+ node->global.time = time;
+ node->global.size = size;
+
/* Store a reference for now, and fix up later to be a pointer. */
node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
+ node->global.estimated_growth = estimated_growth;
+ node->global.inlined = inlined;
+
/* Store a reference for now, and fix up later to be a pointer. */
node->same_comdat_group = (cgraph_node_ptr) (intptr_t) ref2;
return node;
}
-/* Read a node from input_block IB. TAG is the node's tag just read.
- Return the node read or overwriten. */
-
-static struct varpool_node *
-input_varpool_node (struct lto_file_decl_data *file_data,
- struct lto_input_block *ib)
-{
- int decl_index;
- tree var_decl;
- struct varpool_node *node;
- struct bitpack_d *bp;
- bool aliases_p;
- int count;
-
- decl_index = lto_input_uleb128 (ib);
- var_decl = lto_file_decl_data_get_var_decl (file_data, decl_index);
- node = varpool_node (var_decl);
-
- bp = lto_input_bitpack (ib);
- node->externally_visible = bp_unpack_value (bp, 1);
- node->force_output = bp_unpack_value (bp, 1);
- node->finalized = bp_unpack_value (bp, 1);
- node->alias = bp_unpack_value (bp, 1);
- node->analyzed = node->finalized;
- node->used_from_other_partition = bp_unpack_value (bp, 1);
- node->in_other_partition = bp_unpack_value (bp, 1);
- aliases_p = bp_unpack_value (bp, 1);
- if (node->finalized)
- varpool_mark_needed_node (node);
- bitpack_delete (bp);
- if (aliases_p)
- {
- count = lto_input_uleb128 (ib);
- for (; count > 0; count --)
- {
- tree decl = lto_file_decl_data_get_var_decl (file_data,
- lto_input_uleb128 (ib));
- varpool_extra_name_alias (decl, var_decl);
- }
- }
- return node;
-}
-
-/* Read a node from input_block IB. TAG is the node's tag just read.
- Return the node read or overwriten. */
-
-static void
-input_ref (struct lto_input_block *ib,
- struct cgraph_node *refering_node,
- struct varpool_node *refering_varpool_node,
- VEC(cgraph_node_ptr, heap) *nodes,
- VEC(varpool_node_ptr, heap) *varpool_nodes)
-{
- struct cgraph_node *node = NULL;
- struct varpool_node *varpool_node = NULL;
- struct bitpack_d *bp;
- enum ipa_ref_type type;
- enum ipa_ref_use use;
-
- bp = lto_input_bitpack (ib);
- type = (enum ipa_ref_type) bp_unpack_value (bp, 1);
- use = (enum ipa_ref_use) bp_unpack_value (bp, 2);
- bitpack_delete (bp);
- if (type == IPA_REF_CGRAPH)
- node = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
- else
- varpool_node = VEC_index (varpool_node_ptr, varpool_nodes, lto_input_sleb128 (ib));
- ipa_record_reference (refering_node, refering_varpool_node,
- node, varpool_node, use, NULL);
-}
-/* Read an edge from IB. NODES points to a vector of previously read nodes for
- decoding caller and callee of the edge to be read. If INDIRECT is true, the
- edge being read is indirect (in the sense that it has
- indirect_unknown_callee set). */
+/* Read an edge from IB. NODES points to a vector of previously read
+ nodes for decoding caller and callee of the edge to be read. */
static void
-input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes,
- bool indirect)
+input_edge (struct lto_input_block *ib, VEC(cgraph_node_ptr, heap) *nodes)
{
struct cgraph_node *caller, *callee;
struct cgraph_edge *edge;
cgraph_inline_failed_t inline_failed;
struct bitpack_d *bp;
enum ld_plugin_symbol_resolution caller_resolution;
- int ecf_flags = 0;
caller = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
if (caller == NULL || caller->decl == NULL_TREE)
internal_error ("bytecode stream: no caller found while reading edge");
- if (!indirect)
- {
- callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
- if (callee == NULL || callee->decl == NULL_TREE)
- internal_error ("bytecode stream: no callee found while reading edge");
- }
- else
- callee = NULL;
+ callee = VEC_index (cgraph_node_ptr, nodes, lto_input_sleb128 (ib));
+ if (callee == NULL || callee->decl == NULL_TREE)
+ internal_error ("bytecode stream: no callee found while reading edge");
count = (gcov_type) lto_input_sleb128 (ib);
|| caller_resolution == LDPR_PREEMPTED_IR)
return;
- if (indirect)
- edge = cgraph_create_indirect_edge (caller, NULL, 0, count, freq, nest);
- else
- edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
-
- edge->indirect_inlining_edge = bp_unpack_value (bp, 1);
+ edge = cgraph_create_edge (caller, callee, NULL, count, freq, nest);
edge->lto_stmt_uid = stmt_id;
edge->inline_failed = inline_failed;
+ edge->indirect_call = bp_unpack_value (bp, 1);
edge->call_stmt_cannot_inline_p = bp_unpack_value (bp, 1);
edge->can_throw_external = bp_unpack_value (bp, 1);
- if (indirect)
- {
- if (bp_unpack_value (bp, 1))
- ecf_flags |= ECF_CONST;
- if (bp_unpack_value (bp, 1))
- ecf_flags |= ECF_PURE;
- if (bp_unpack_value (bp, 1))
- ecf_flags |= ECF_NORETURN;
- if (bp_unpack_value (bp, 1))
- ecf_flags |= ECF_MALLOC;
- if (bp_unpack_value (bp, 1))
- ecf_flags |= ECF_NOTHROW;
- if (bp_unpack_value (bp, 1))
- ecf_flags |= ECF_RETURNS_TWICE;
- edge->indirect_info->ecf_flags = ecf_flags;
- }
bitpack_delete (bp);
}
/* Read a cgraph from IB using the info in FILE_DATA. */
-static VEC(cgraph_node_ptr, heap) *
+static void
input_cgraph_1 (struct lto_file_decl_data *file_data,
struct lto_input_block *ib)
{
while (tag)
{
if (tag == LTO_cgraph_edge)
- input_edge (ib, nodes, false);
- else if (tag == LTO_cgraph_indirect_edge)
- input_edge (ib, nodes, true);
+ input_edge (ib, nodes);
else
{
- node = input_node (file_data, ib, tag,nodes);
+ node = input_node (file_data, ib, tag);
if (node == NULL || node->decl == NULL_TREE)
internal_error ("bytecode stream: found empty cgraph node");
VEC_safe_push (cgraph_node_ptr, heap, nodes, node);
else
node->same_comdat_group = NULL;
}
- return nodes;
-}
-
-/* Read a varpool from IB using the info in FILE_DATA. */
-
-static VEC(varpool_node_ptr, heap) *
-input_varpool_1 (struct lto_file_decl_data *file_data,
- struct lto_input_block *ib)
-{
- unsigned HOST_WIDE_INT len;
- VEC(varpool_node_ptr, heap) *varpool = NULL;
- len = lto_input_uleb128 (ib);
- while (len)
- {
- VEC_safe_push (varpool_node_ptr, heap, varpool,
- input_varpool_node (file_data, ib));
- len--;
- }
- return varpool;
+ VEC_free (cgraph_node_ptr, heap, nodes);
}
-/* Input ipa_refs. */
-
-static void
-input_refs (struct lto_input_block *ib,
- VEC(cgraph_node_ptr, heap) *nodes,
- VEC(varpool_node_ptr, heap) *varpool)
-{
- int count;
- int idx;
- while (true)
- {
- struct cgraph_node *node;
- count = lto_input_uleb128 (ib);
- if (!count)
- break;
- idx = lto_input_uleb128 (ib);
- node = VEC_index (cgraph_node_ptr, nodes, idx);
- while (count)
- {
- input_ref (ib, node, NULL, nodes, varpool);
- count--;
- }
- }
- while (true)
- {
- struct varpool_node *node;
- count = lto_input_uleb128 (ib);
- if (!count)
- break;
- node = VEC_index (varpool_node_ptr, varpool, lto_input_uleb128 (ib));
- while (count)
- {
- input_ref (ib, NULL, node, nodes, varpool);
- count--;
- }
- }
-}
-
-
static struct gcov_ctr_summary lto_gcov_summary;
/* Input profile_info from IB. */
const char *data;
size_t len;
struct lto_input_block *ib;
- VEC(cgraph_node_ptr, heap) *nodes;
- VEC(varpool_node_ptr, heap) *varpool;
ib = lto_create_simple_input_block (file_data, LTO_section_cgraph,
&data, &len);
input_profile_summary (ib);
file_data->cgraph_node_encoder = lto_cgraph_encoder_new ();
- nodes = input_cgraph_1 (file_data, ib);
+ input_cgraph_1 (file_data, ib);
lto_destroy_simple_input_block (file_data, LTO_section_cgraph,
ib, data, len);
- ib = lto_create_simple_input_block (file_data, LTO_section_varpool,
- &data, &len);
- varpool = input_varpool_1 (file_data, ib);
- lto_destroy_simple_input_block (file_data, LTO_section_varpool,
- ib, data, len);
-
- ib = lto_create_simple_input_block (file_data, LTO_section_refs,
- &data, &len);
- input_refs (ib, nodes, varpool);
- lto_destroy_simple_input_block (file_data, LTO_section_refs,
- ib, data, len);
- if (flag_ltrans)
- input_cgraph_opt_summary (nodes);
- VEC_free (cgraph_node_ptr, heap, nodes);
- VEC_free (varpool_node_ptr, heap, varpool);
+ /* Assume that every file read needs to be processed by LTRANS. */
+ if (flag_wpa)
+ lto_mark_file_for_ltrans (file_data);
}
/* Clear out the aux field that was used to store enough state to
node->aux = NULL;
}
}
-
-/* True when we need optimization summary for NODE. */
-
-static int
-output_cgraph_opt_summary_p (struct cgraph_node *node)
-{
- if (!node->clone_of)
- return false;
- return (node->clone.tree_map
- || node->clone.args_to_skip
- || node->clone.combined_args_to_skip);
-}
-
-/* Output optimization summary for NODE to OB. */
-
-static void
-output_node_opt_summary (struct output_block *ob,
- struct cgraph_node *node)
-{
- unsigned int index;
- bitmap_iterator bi;
- struct ipa_replace_map *map;
- struct bitpack_d *bp;
- int i;
-
- lto_output_uleb128_stream (ob->main_stream,
- bitmap_count_bits (node->clone.args_to_skip));
- EXECUTE_IF_SET_IN_BITMAP (node->clone.args_to_skip, 0, index, bi)
- lto_output_uleb128_stream (ob->main_stream, index);
- lto_output_uleb128_stream (ob->main_stream,
- bitmap_count_bits (node->clone.combined_args_to_skip));
- EXECUTE_IF_SET_IN_BITMAP (node->clone.combined_args_to_skip, 0, index, bi)
- lto_output_uleb128_stream (ob->main_stream, index);
- lto_output_uleb128_stream (ob->main_stream,
- VEC_length (ipa_replace_map_p, node->clone.tree_map));
- for (i = 0; VEC_iterate (ipa_replace_map_p, node->clone.tree_map, i, map); i++)
- {
- int parm_num;
- tree parm;
-
- for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm;
- parm = TREE_CHAIN (parm), parm_num++)
- if (map->old_tree == parm)
- break;
- /* At the moment we assume all old trees to be PARM_DECLs, because we have no
- mechanism to store function local declarations into summaries. */
- gcc_assert (parm);
- lto_output_uleb128_stream (ob->main_stream, parm_num);
- lto_output_tree (ob, map->new_tree, true);
- bp = bitpack_create ();
- bp_pack_value (bp, map->replace_p, 1);
- bp_pack_value (bp, map->ref_p, 1);
- lto_output_bitpack (ob->main_stream, bp);
- bitpack_delete (bp);
- }
-}
-
-/* Output optimization summaries stored in callgraph.
- At the moment it is the clone info structure. */
-
-static void
-output_cgraph_opt_summary (void)
-{
- struct cgraph_node *node;
- int i, n_nodes;
- lto_cgraph_encoder_t encoder;
- struct output_block *ob = create_output_block (LTO_section_cgraph_opt_sum);
- unsigned count = 0;
-
- ob->cgraph_node = NULL;
- encoder = ob->decl_state->cgraph_node_encoder;
- n_nodes = lto_cgraph_encoder_size (encoder);
- for (i = 0; i < n_nodes; i++)
- if (output_cgraph_opt_summary_p (lto_cgraph_encoder_deref (encoder, i)))
- count++;
- lto_output_uleb128_stream (ob->main_stream, count);
- for (i = 0; i < n_nodes; i++)
- {
- node = lto_cgraph_encoder_deref (encoder, i);
- if (output_cgraph_opt_summary_p (node))
- {
- lto_output_uleb128_stream (ob->main_stream, i);
- output_node_opt_summary (ob, node);
- }
- }
- produce_asm (ob, NULL);
- destroy_output_block (ob);
-}
-
-/* Input optimiation summary of NODE. */
-
-static void
-input_node_opt_summary (struct cgraph_node *node,
- struct lto_input_block *ib_main,
- struct data_in *data_in)
-{
- int i;
- int count;
- int bit;
- struct bitpack_d *bp;
-
- count = lto_input_uleb128 (ib_main);
- if (count)
- node->clone.args_to_skip = BITMAP_GGC_ALLOC ();
- for (i = 0; i < count; i++)
- {
- bit = lto_input_uleb128 (ib_main);
- bitmap_set_bit (node->clone.args_to_skip, bit);
- }
- count = lto_input_uleb128 (ib_main);
- if (count)
- node->clone.combined_args_to_skip = BITMAP_GGC_ALLOC ();
- for (i = 0; i < count; i++)
- {
- bit = lto_input_uleb128 (ib_main);
- bitmap_set_bit (node->clone.combined_args_to_skip, bit);
- }
- count = lto_input_uleb128 (ib_main);
- for (i = 0; i < count; i++)
- {
- int parm_num;
- tree parm;
- struct ipa_replace_map *map = GGC_NEW (struct ipa_replace_map);
-
- VEC_safe_push (ipa_replace_map_p, gc, node->clone.tree_map, map);
- for (parm_num = 0, parm = DECL_ARGUMENTS (node->decl); parm_num;
- parm = TREE_CHAIN (parm))
- parm_num --;
- map->parm_num = lto_input_uleb128 (ib_main);
- map->old_tree = NULL;
- map->new_tree = lto_input_tree (ib_main, data_in);
- bp = lto_input_bitpack (ib_main);
- map->replace_p = bp_unpack_value (bp, 1);
- map->ref_p = bp_unpack_value (bp, 1);
- bitpack_delete (bp);
- }
-}
-
-/* Read section in file FILE_DATA of length LEN with data DATA. */
-
-static void
-input_cgraph_opt_section (struct lto_file_decl_data *file_data,
- const char *data, size_t len, VEC (cgraph_node_ptr,
- heap) * nodes)
-{
- const struct lto_function_header *header =
- (const struct lto_function_header *) data;
- const int32_t cfg_offset = sizeof (struct lto_function_header);
- const int32_t main_offset = cfg_offset + header->cfg_size;
- const int32_t string_offset = main_offset + header->main_size;
- struct data_in *data_in;
- struct lto_input_block ib_main;
- unsigned int i;
- unsigned int count;
-
- LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
- header->main_size);
-
- data_in =
- lto_data_in_create (file_data, (const char *) data + string_offset,
- header->string_size, NULL);
- count = lto_input_uleb128 (&ib_main);
-
- for (i = 0; i < count; i++)
- {
- int ref = lto_input_uleb128 (&ib_main);
- input_node_opt_summary (VEC_index (cgraph_node_ptr, nodes, ref),
- &ib_main, data_in);
- }
- lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
- len);
- lto_data_in_delete (data_in);
-}
-
-/* Input optimization summary of cgraph. */
-
-static void
-input_cgraph_opt_summary (VEC (cgraph_node_ptr, heap) * nodes)
-{
- struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
- struct lto_file_decl_data *file_data;
- unsigned int j = 0;
-
- while ((file_data = file_data_vec[j++]))
- {
- size_t len;
- const char *data =
- lto_get_section_data (file_data, LTO_section_cgraph_opt_sum, NULL,
- &len);
-
- if (data)
- input_cgraph_opt_section (file_data, data, len, nodes);
- }
-}
OSDN Git Service
