/* Write and read the cgraph to the memory mapped representation of a
.o file.
- Copyright (C) 2009-2013 Free Software Foundation, Inc.
+ Copyright (C) 2009-2014 Free Software Foundation, Inc.
Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
This file is part of GCC.
#include "tm.h"
#include "tree.h"
#include "stringpool.h"
+#include "predict.h"
+#include "vec.h"
+#include "hashtab.h"
+#include "hash-set.h"
+#include "machmode.h"
+#include "hard-reg-set.h"
+#include "input.h"
+#include "function.h"
#include "basic-block.h"
#include "tree-ssa-alias.h"
#include "internal-fn.h"
#include "expr.h"
#include "flags.h"
#include "params.h"
-#include "input.h"
-#include "hashtab.h"
#include "langhooks.h"
#include "bitmap.h"
-#include "function.h"
#include "diagnostic-core.h"
#include "except.h"
#include "timevar.h"
+#include "hash-map.h"
+#include "plugin-api.h"
+#include "ipa-ref.h"
+#include "cgraph.h"
#include "lto-streamer.h"
#include "data-streamer.h"
#include "tree-streamer.h"
#include "context.h"
#include "pass_manager.h"
#include "ipa-utils.h"
+#include "omp-low.h"
+
+/* True when asm nodes has been output. */
+bool asm_nodes_output = false;
static void output_cgraph_opt_summary (void);
static void input_cgraph_opt_summary (vec<symtab_node *> nodes);
lto_symtab_encoder_t encoder = XCNEW (struct lto_symtab_encoder_d);
if (!for_input)
- encoder->map = pointer_map_create ();
+ encoder->map = new hash_map<symtab_node *, size_t>;
encoder->nodes.create (0);
return encoder;
}
{
encoder->nodes.release ();
if (encoder->map)
- pointer_map_destroy (encoder->map);
+ delete encoder->map;
free (encoder);
}
symtab_node *node)
{
int ref;
- void **slot;
if (!encoder->map)
{
return ref;
}
- slot = pointer_map_contains (encoder->map, node);
+ size_t *slot = encoder->map->get (node);
if (!slot || !*slot)
{
lto_encoder_entry entry = {node, false, false, false};
ref = encoder->nodes.length ();
if (!slot)
- slot = pointer_map_insert (encoder->map, node);
- *slot = (void *) (intptr_t) (ref + 1);
+ encoder->map->put (node, ref + 1);
encoder->nodes.safe_push (entry);
}
else
- ref = (size_t) *slot - 1;
+ ref = *slot - 1;
return ref;
}
lto_symtab_encoder_delete_node (lto_symtab_encoder_t encoder,
symtab_node *node)
{
- void **slot, **last_slot;
int index;
lto_encoder_entry last_node;
- slot = pointer_map_contains (encoder->map, node);
+ size_t *slot = encoder->map->get (node);
if (slot == NULL || !*slot)
return false;
- index = (size_t) *slot - 1;
+ index = *slot - 1;
gcc_checking_assert (encoder->nodes[index].node == node);
/* Remove from vector. We do this by swapping node with the last element
last_node = encoder->nodes.pop ();
if (last_node.node != node)
{
- last_slot = pointer_map_contains (encoder->map, last_node.node);
- gcc_checking_assert (last_slot && *last_slot);
- *last_slot = (void *)(size_t) (index + 1);
+ gcc_assert (encoder->map->put (last_node.node, index + 1));
/* Move the last element to the original spot of NODE. */
encoder->nodes[index] = last_node;
}
/* Remove element from hash table. */
- *slot = NULL;
+ encoder->map->remove (node);
return true;
}
bool
lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t encoder,
- struct varpool_node *node)
+ varpool_node *node)
{
int index = lto_symtab_encoder_lookup (encoder, node);
if (index == LCC_NOT_FOUND)
static void
lto_set_symtab_encoder_encode_initializer (lto_symtab_encoder_t encoder,
- struct varpool_node *node)
+ varpool_node *node)
{
int index = lto_symtab_encoder_lookup (encoder, node);
encoder->nodes[index].initializer = true;
bp = bitpack_create (ob->main_stream);
uid = (!gimple_has_body_p (edge->caller->decl)
? edge->lto_stmt_uid : gimple_uid (edge->call_stmt) + 1);
- bp_pack_enum (&bp, cgraph_inline_failed_enum,
+ bp_pack_enum (&bp, cgraph_inline_failed_t,
CIF_N_REASONS, edge->inline_failed);
bp_pack_var_len_unsigned (&bp, uid);
bp_pack_var_len_unsigned (&bp, edge->frequency);
bp_pack_value (&bp, edge->speculative, 1);
bp_pack_value (&bp, edge->call_stmt_cannot_inline_p, 1);
bp_pack_value (&bp, edge->can_throw_external, 1);
+ bp_pack_value (&bp, edge->in_polymorphic_cdtor, 1);
if (edge->indirect_unknown_callee)
{
int flags = edge->indirect_info->ecf_flags;
}
}
-/* Return if LIST contain references from other partitions. */
+/* Return if NODE contain references from other partitions. */
bool
-referenced_from_other_partition_p (struct ipa_ref_list *list, lto_symtab_encoder_t encoder)
+referenced_from_other_partition_p (symtab_node *node, lto_symtab_encoder_t encoder)
{
int i;
- struct ipa_ref *ref;
- for (i = 0; ipa_ref_list_referring_iterate (list, i, ref); i++)
+ struct ipa_ref *ref = NULL;
+
+ for (i = 0; node->iterate_referring (i, ref); i++)
{
+ /* Ignore references from non-offloadable nodes while streaming NODE into
+ offload LTO section. */
+ if (!ref->referring->need_lto_streaming)
+ continue;
+
if (ref->referring->in_other_partition
|| !lto_symtab_encoder_in_partition_p (encoder, ref->referring))
return true;
if (node->global.inlined_to)
return false;
for (e = node->callers; e; e = e->next_caller)
- if (e->caller->in_other_partition
- || !lto_symtab_encoder_in_partition_p (encoder, e->caller))
- return true;
+ {
+ /* Ignore references from non-offloadable nodes while streaming NODE into
+ offload LTO section. */
+ if (!e->caller->need_lto_streaming)
+ continue;
+
+ if (e->caller->in_other_partition
+ || !lto_symtab_encoder_in_partition_p (encoder, e->caller))
+ return true;
+ }
return false;
}
-/* Return if LIST contain references from other partitions. */
+/* Return if NODE contain references from other partitions. */
bool
-referenced_from_this_partition_p (struct ipa_ref_list *list,
+referenced_from_this_partition_p (symtab_node *node,
lto_symtab_encoder_t encoder)
{
int i;
- struct ipa_ref *ref;
- for (i = 0; ipa_ref_list_referring_iterate (list, i, ref); i++)
+ struct ipa_ref *ref = NULL;
+
+ for (i = 0; node->iterate_referring (i, ref); i++)
if (lto_symtab_encoder_in_partition_p (encoder, ref->referring))
return true;
return false;
intptr_t ref;
bool in_other_partition = false;
struct cgraph_node *clone_of, *ultimate_clone_of;
- struct ipa_opt_pass_d *pass;
+ ipa_opt_pass_d *pass;
int i;
bool alias_p;
+ const char *comdat;
+ const char *section;
+ tree group;
boundary_p = !lto_symtab_encoder_in_partition_p (encoder, node);
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 && !DECL_EXTERNAL (node->decl))
+ if (boundary_p && node->analyzed
+ && node->get_partitioning_class () == SYMBOL_PARTITION)
{
/* Inline clones can not be part of boundary.
gcc_assert (!node->global.inlined_to);
streamer_write_hwi_stream (ob->main_stream, ref);
}
- if (node->same_comdat_group && !boundary_p)
+ group = node->get_comdat_group ();
+ if (group)
+ comdat = IDENTIFIER_POINTER (group);
+ else
+ comdat = "";
+ streamer_write_data_stream (ob->main_stream, comdat, strlen (comdat) + 1);
+
+ if (group)
{
- ref = lto_symtab_encoder_lookup (encoder,
- node->same_comdat_group);
- gcc_assert (ref != LCC_NOT_FOUND);
+ if (node->same_comdat_group && !boundary_p)
+ {
+ ref = lto_symtab_encoder_lookup (encoder,
+ node->same_comdat_group);
+ gcc_assert (ref != LCC_NOT_FOUND);
+ }
+ else
+ ref = LCC_NOT_FOUND;
+ streamer_write_hwi_stream (ob->main_stream, ref);
}
- else
- ref = LCC_NOT_FOUND;
- streamer_write_hwi_stream (ob->main_stream, ref);
+
+ section = node->get_section ();
+ if (!section)
+ section = "";
streamer_write_hwi_stream (ob->main_stream, node->tp_first_run);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, node->local.local, 1);
bp_pack_value (&bp, node->externally_visible, 1);
+ bp_pack_value (&bp, node->no_reorder, 1);
bp_pack_value (&bp, node->definition, 1);
bp_pack_value (&bp, node->local.versionable, 1);
bp_pack_value (&bp, node->local.can_change_signature, 1);
bp_pack_value (&bp, node->force_output, 1);
bp_pack_value (&bp, node->forced_by_abi, 1);
bp_pack_value (&bp, node->unique_name, 1);
+ bp_pack_value (&bp, node->body_removed, 1);
+ bp_pack_value (&bp, node->implicit_section, 1);
bp_pack_value (&bp, node->address_taken, 1);
bp_pack_value (&bp, tag == LTO_symtab_analyzed_node
- && !DECL_EXTERNAL (node->decl)
- && !DECL_COMDAT (node->decl)
+ && node->get_partitioning_class () == SYMBOL_PARTITION
&& (reachable_from_other_partition_p (node, encoder)
- || referenced_from_other_partition_p (&node->ref_list,
- encoder)), 1);
+ || referenced_from_other_partition_p (node, 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
bp_pack_value (&bp, node->only_called_at_startup, 1);
bp_pack_value (&bp, node->only_called_at_exit, 1);
bp_pack_value (&bp, node->tm_clone, 1);
+ bp_pack_value (&bp, node->calls_comdat_local, 1);
+ bp_pack_value (&bp, node->icf_merged, 1);
+ bp_pack_value (&bp, node->nonfreeing_fn, 1);
bp_pack_value (&bp, node->thunk.thunk_p && !boundary_p, 1);
bp_pack_enum (&bp, ld_plugin_symbol_resolution,
LDPR_NUM_KNOWN, node->resolution);
+ bp_pack_value (&bp, node->instrumentation_clone, 1);
streamer_write_bitpack (&bp);
+ streamer_write_data_stream (ob->main_stream, section, strlen (section) + 1);
if (node->thunk.thunk_p && !boundary_p)
{
streamer_write_uhwi_stream
(ob->main_stream,
1 + (node->thunk.this_adjusting != 0) * 2
- + (node->thunk.virtual_offset_p != 0) * 4);
+ + (node->thunk.virtual_offset_p != 0) * 4
+ + (node->thunk.add_pointer_bounds_args != 0) * 8);
streamer_write_uhwi_stream (ob->main_stream, node->thunk.fixed_offset);
streamer_write_uhwi_stream (ob->main_stream, node->thunk.virtual_value);
}
streamer_write_hwi_stream (ob->main_stream, node->profile_id);
+ if (DECL_STATIC_CONSTRUCTOR (node->decl))
+ streamer_write_hwi_stream (ob->main_stream, node->get_init_priority ());
+ if (DECL_STATIC_DESTRUCTOR (node->decl))
+ streamer_write_hwi_stream (ob->main_stream, node->get_fini_priority ());
+
+ if (node->instrumentation_clone)
+ lto_output_fn_decl_index (ob->decl_state, ob->main_stream, node->orig_decl);
}
/* 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,
+lto_output_varpool_node (struct lto_simple_output_block *ob, varpool_node *node,
lto_symtab_encoder_t encoder)
{
bool boundary_p = !lto_symtab_encoder_in_partition_p (encoder, node);
struct bitpack_d bp;
int ref;
bool alias_p;
+ const char *comdat;
+ const char *section;
+ tree group;
streamer_write_enum (ob->main_stream, LTO_symtab_tags, LTO_symtab_last_tag,
LTO_symtab_variable);
lto_output_var_decl_index (ob->decl_state, ob->main_stream, node->decl);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, node->externally_visible, 1);
+ bp_pack_value (&bp, node->no_reorder, 1);
bp_pack_value (&bp, node->force_output, 1);
bp_pack_value (&bp, node->forced_by_abi, 1);
bp_pack_value (&bp, node->unique_name, 1);
+ bp_pack_value (&bp, node->body_removed, 1);
+ bp_pack_value (&bp, node->implicit_section, 1);
+ bp_pack_value (&bp, node->writeonly, 1);
bp_pack_value (&bp, node->definition, 1);
alias_p = node->alias && (!boundary_p || node->weakref);
bp_pack_value (&bp, alias_p, 1);
/* 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)
- && !DECL_EXTERNAL (node->decl)
- && !DECL_COMDAT (node->decl))
+ if (node->get_partitioning_class () != SYMBOL_PARTITION)
{
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->definition
- && referenced_from_other_partition_p (&node->ref_list,
- encoder), 1);
+ && referenced_from_other_partition_p (node, encoder), 1);
bp_pack_value (&bp, node->analyzed
&& boundary_p && !DECL_EXTERNAL (node->decl), 1);
/* in_other_partition. */
}
+ bp_pack_value (&bp, node->tls_model, 3);
+ bp_pack_value (&bp, node->used_by_single_function, 1);
bp_pack_value (&bp, node->need_bounds_init, 1);
streamer_write_bitpack (&bp);
- if (node->same_comdat_group && !boundary_p)
+
+ group = node->get_comdat_group ();
+ if (group)
+ comdat = IDENTIFIER_POINTER (group);
+ else
+ comdat = "";
+ streamer_write_data_stream (ob->main_stream, comdat, strlen (comdat) + 1);
+
+ if (group)
{
- ref = lto_symtab_encoder_lookup (encoder,
- node->same_comdat_group);
- gcc_assert (ref != LCC_NOT_FOUND);
+ if (node->same_comdat_group && !boundary_p)
+ {
+ ref = lto_symtab_encoder_lookup (encoder,
+ node->same_comdat_group);
+ gcc_assert (ref != LCC_NOT_FOUND);
+ }
+ else
+ ref = LCC_NOT_FOUND;
+ streamer_write_hwi_stream (ob->main_stream, ref);
}
- else
- ref = LCC_NOT_FOUND;
- streamer_write_hwi_stream (ob->main_stream, ref);
+
+ section = node->get_section ();
+ if (!section)
+ section = "";
+ streamer_write_data_stream (ob->main_stream, section, strlen (section) + 1);
+
streamer_write_enum (ob->main_stream, ld_plugin_symbol_resolution,
LDPR_NUM_KNOWN, node->resolution);
}
struct cgraph_node *node;
bp = bitpack_create (ob->main_stream);
- bp_pack_value (&bp, ref->use, 2);
+ bp_pack_value (&bp, ref->use, 3);
bp_pack_value (&bp, ref->speculative, 1);
streamer_write_bitpack (&bp);
nref = lto_symtab_encoder_lookup (encoder, ref->referred);
gcc_assert (nref != LCC_NOT_FOUND);
streamer_write_hwi_stream (ob->main_stream, nref);
- node = dyn_cast <cgraph_node> (ref->referring);
+ node = dyn_cast <cgraph_node *> (ref->referring);
if (node)
{
if (ref->stmt)
{
symtab_node *node = lsei_node (lsei);
- count = ipa_ref_list_nreferences (&node->ref_list);
+ count = node->ref_list.nreferences ();
if (count)
{
streamer_write_gcov_count_stream (ob->main_stream, count);
streamer_write_uhwi_stream (ob->main_stream,
lto_symtab_encoder_lookup (encoder, node));
- for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list,
- i, ref); i++)
+ for (i = 0; node->iterate_reference (i, ref); i++)
lto_output_ref (ob, ref, encoder);
}
}
lto_symtab_encoder_encode (encoder, node);
}
-/* Add all references in LIST to encoders. */
+/* Add all references in NODE to encoders. */
static void
-add_references (lto_symtab_encoder_t encoder,
- struct ipa_ref_list *list)
+create_references (lto_symtab_encoder_t encoder, symtab_node *node)
{
int i;
- struct ipa_ref *ref;
- for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
- if (is_a <cgraph_node> (ref->referred))
- add_node_to (encoder, ipa_ref_node (ref), false);
+ struct ipa_ref *ref = NULL;
+ for (i = 0; node->iterate_reference (i, ref); i++)
+ if (is_a <cgraph_node *> (ref->referred))
+ add_node_to (encoder, dyn_cast <cgraph_node *> (ref->referred), false);
else
lto_symtab_encoder_encode (encoder, ref->referred);
}
+/* Select what needs to be streamed out. In regular lto mode stream everything.
+ In offload lto mode stream only nodes marked as offloadable. */
+void
+select_what_to_stream (bool offload_lto_mode)
+{
+ struct symtab_node *snode;
+ FOR_EACH_SYMBOL (snode)
+ snode->need_lto_streaming = !offload_lto_mode || snode->offloadable;
+}
+
/* Find all symbols we want to stream into given partition and insert them
to encoders.
lto_symtab_encoder_t
compute_ltrans_boundary (lto_symtab_encoder_t in_encoder)
{
- struct cgraph_node *node;
struct cgraph_edge *edge;
int i;
lto_symtab_encoder_t encoder;
lto_symtab_encoder_iterator lsei;
- struct pointer_set_t *reachable_call_targets = pointer_set_create ();
+ hash_set<void *> reachable_call_targets;
encoder = lto_symtab_encoder_new (false);
for (lsei = lsei_start_function_in_partition (in_encoder);
!lsei_end_p (lsei); lsei_next_function_in_partition (&lsei))
{
- node = lsei_cgraph_node (lsei);
+ struct cgraph_node *node = lsei_cgraph_node (lsei);
+ if (!node->need_lto_streaming)
+ continue;
add_node_to (encoder, node, true);
lto_set_symtab_encoder_in_partition (encoder, node);
- add_references (encoder, &node->ref_list);
+ create_references (encoder, node);
/* For proper debug info, we need to ship the origins, too. */
if (DECL_ABSTRACT_ORIGIN (node->decl))
{
struct cgraph_node *origin_node
- = cgraph_get_node (DECL_ABSTRACT_ORIGIN (node->decl));
+ = cgraph_node::get (DECL_ABSTRACT_ORIGIN (node->decl));
add_node_to (encoder, origin_node, true);
}
}
for (lsei = lsei_start_variable_in_partition (in_encoder);
!lsei_end_p (lsei); lsei_next_variable_in_partition (&lsei))
{
- struct varpool_node *vnode = lsei_varpool_node (lsei);
+ varpool_node *vnode = lsei_varpool_node (lsei);
+ if (!vnode->need_lto_streaming)
+ continue;
lto_set_symtab_encoder_in_partition (encoder, vnode);
lto_set_symtab_encoder_encode_initializer (encoder, vnode);
- add_references (encoder, &vnode->ref_list);
+ create_references (encoder, vnode);
/* For proper debug info, we need to ship the origins, too. */
if (DECL_ABSTRACT_ORIGIN (vnode->decl))
{
- struct varpool_node *origin_node
- = varpool_get_node (DECL_ABSTRACT_ORIGIN (node->decl));
+ varpool_node *origin_node
+ = varpool_node::get (DECL_ABSTRACT_ORIGIN (vnode->decl));
lto_set_symtab_encoder_in_partition (encoder, origin_node);
}
}
for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
{
symtab_node *node = lto_symtab_encoder_deref (encoder, i);
- if (varpool_node *vnode = dyn_cast <varpool_node> (node))
+ if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
{
if (!lto_symtab_encoder_encode_initializer_p (encoder,
vnode)
- && ctor_for_folding (vnode->decl) != error_mark_node)
+ && (vnode->ctor_useable_for_folding_p ()
+ || POINTER_BOUNDS_P (vnode->decl)))
{
lto_set_symtab_encoder_encode_initializer (encoder, vnode);
- add_references (encoder, &vnode->ref_list);
+ create_references (encoder, vnode);
}
}
}
for (lsei = lsei_start_function_in_partition (encoder);
!lsei_end_p (lsei); lsei_next_function_in_partition (&lsei))
{
- node = lsei_cgraph_node (lsei);
+ struct cgraph_node *node = lsei_cgraph_node (lsei);
for (edge = node->callees; edge; edge = edge->next_callee)
{
struct cgraph_node *callee = edge->callee;
vec <cgraph_node *>targets
= possible_polymorphic_call_targets
(edge, &final, &cache_token);
- if (!pointer_set_insert (reachable_call_targets,
- cache_token))
+ if (!reachable_call_targets.add (cache_token))
{
for (i = 0; i < targets.length (); i++)
{
}
}
lto_symtab_encoder_delete (in_encoder);
- pointer_set_destroy (reachable_call_targets);
return encoder;
}
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 ();
for (i = 0; i < n_nodes; i++)
{
symtab_node *node = lto_symtab_encoder_deref (encoder, i);
- if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+ if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
lto_output_node (ob, cnode, encoder);
else
- lto_output_varpool_node (ob, varpool (node), encoder);
-
+ lto_output_varpool_node (ob, dyn_cast<varpool_node *> (node), encoder);
}
/* Go over the nodes in SET again to write edges. */
output_refs (encoder);
}
+/* Return identifier encoded in IB as a plain string. */
+
+static tree
+read_identifier (struct lto_input_block *ib)
+{
+ unsigned int len = strnlen (ib->data + ib->p, ib->len - ib->p - 1);
+ tree id;
+
+ if (ib->data[ib->p + len])
+ lto_section_overrun (ib);
+ if (!len)
+ {
+ ib->p++;
+ return NULL;
+ }
+ id = get_identifier (ib->data + ib->p);
+ ib->p += len + 1;
+ return id;
+}
+
+/* Return string encoded in IB, NULL if string is empty. */
+
+static const char *
+read_string (struct lto_input_block *ib)
+{
+ unsigned int len = strnlen (ib->data + ib->p, ib->len - ib->p - 1);
+ const char *str;
+
+ if (ib->data[ib->p + len])
+ lto_section_overrun (ib);
+ if (!len)
+ {
+ ib->p++;
+ return NULL;
+ }
+ str = ib->data + ib->p;
+ ib->p += len + 1;
+ return str;
+}
+
+/* Output function/variable tables that will allow libgomp to look up offload
+ target code.
+ OFFLOAD_FUNCS is filled in expand_omp_target, OFFLOAD_VARS is filled in
+ varpool_node::get_create. In WHOPR (partitioned) mode during the WPA stage
+ both OFFLOAD_FUNCS and OFFLOAD_VARS are filled by input_offload_tables. */
+
+void
+output_offload_tables (void)
+{
+ if (vec_safe_is_empty (offload_funcs) && vec_safe_is_empty (offload_vars))
+ return;
+
+ struct lto_simple_output_block *ob
+ = lto_create_simple_output_block (LTO_section_offload_table);
+
+ for (unsigned i = 0; i < vec_safe_length (offload_funcs); i++)
+ {
+ streamer_write_enum (ob->main_stream, LTO_symtab_tags,
+ LTO_symtab_last_tag, LTO_symtab_unavail_node);
+ lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
+ (*offload_funcs)[i]);
+ }
+
+ for (unsigned i = 0; i < vec_safe_length (offload_vars); i++)
+ {
+ streamer_write_enum (ob->main_stream, LTO_symtab_tags,
+ LTO_symtab_last_tag, LTO_symtab_variable);
+ lto_output_var_decl_index (ob->decl_state, ob->main_stream,
+ (*offload_vars)[i]);
+ }
+
+ streamer_write_uhwi_stream (ob->main_stream, 0);
+ lto_destroy_simple_output_block (ob);
+
+ /* In WHOPR mode during the WPA stage the joint offload tables need to be
+ streamed to one partition only. That's why we free offload_funcs and
+ offload_vars after the first call of output_offload_tables. */
+ if (flag_wpa)
+ {
+ vec_free (offload_funcs);
+ vec_free (offload_vars);
+ }
+}
+
/* 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.local = bp_unpack_value (bp, 1);
node->externally_visible = bp_unpack_value (bp, 1);
+ node->no_reorder = bp_unpack_value (bp, 1);
node->definition = bp_unpack_value (bp, 1);
node->local.versionable = bp_unpack_value (bp, 1);
node->local.can_change_signature = bp_unpack_value (bp, 1);
node->force_output = bp_unpack_value (bp, 1);
node->forced_by_abi = bp_unpack_value (bp, 1);
node->unique_name = bp_unpack_value (bp, 1);
+ node->body_removed = bp_unpack_value (bp, 1);
+ node->implicit_section = bp_unpack_value (bp, 1);
node->address_taken = bp_unpack_value (bp, 1);
node->used_from_other_partition = bp_unpack_value (bp, 1);
node->lowered = bp_unpack_value (bp, 1);
node->only_called_at_startup = bp_unpack_value (bp, 1);
node->only_called_at_exit = bp_unpack_value (bp, 1);
node->tm_clone = bp_unpack_value (bp, 1);
+ node->calls_comdat_local = bp_unpack_value (bp, 1);
+ node->icf_merged = bp_unpack_value (bp, 1);
+ node->nonfreeing_fn = bp_unpack_value (bp, 1);
node->thunk.thunk_p = bp_unpack_value (bp, 1);
node->resolution = bp_unpack_enum (bp, ld_plugin_symbol_resolution,
LDPR_NUM_KNOWN);
+ node->instrumentation_clone = bp_unpack_value (bp, 1);
+ gcc_assert (flag_ltrans
+ || (!node->in_other_partition
+ && !node->used_from_other_partition));
}
/* Return string alias is alias of. */
int clone_ref;
int order;
int i, count;
-
+ tree group;
+ const char *section;
order = streamer_read_hwi (ib) + order_base;
clone_ref = streamer_read_hwi (ib);
if (clone_ref != LCC_NOT_FOUND)
{
- node = cgraph_clone_node (cgraph (nodes[clone_ref]), fn_decl,
- 0, CGRAPH_FREQ_BASE, false,
- vNULL, false, NULL);
+ node = dyn_cast<cgraph_node *> (nodes[clone_ref])->create_clone (fn_decl,
+ 0, CGRAPH_FREQ_BASE, false,
+ vNULL, false, NULL, NULL);
}
else
{
/* Declaration of functions can be already merged with a declaration
from other input file. We keep cgraph unmerged until after streaming
of ipa passes is done. Alays forcingly create a fresh node. */
- node = cgraph_create_empty_node ();
+ node = symtab->create_empty ();
node->decl = fn_decl;
- symtab_register_node (node);
+ node->register_symbol ();
}
node->order = order;
- if (order >= symtab_order)
- symtab_order = order + 1;
+ if (order >= symtab->order)
+ symtab->order = order + 1;
node->count = streamer_read_gcov_count (ib);
node->count_materialization_scale = streamer_read_hwi (ib);
node->ipa_transforms_to_apply = vNULL;
for (i = 0; i < count; i++)
{
- struct opt_pass *pass;
+ opt_pass *pass;
int pid = streamer_read_hwi (ib);
gcc_assert (pid < passes->passes_by_id_size);
pass = passes->passes_by_id[pid];
- node->ipa_transforms_to_apply.safe_push ((struct ipa_opt_pass_d *) pass);
+ node->ipa_transforms_to_apply.safe_push ((ipa_opt_pass_d *) pass);
}
if (tag == LTO_symtab_analyzed_node)
ref = streamer_read_hwi (ib);
- ref2 = streamer_read_hwi (ib);
+ group = read_identifier (ib);
+ if (group)
+ ref2 = streamer_read_hwi (ib);
/* Make sure that we have not read this node before. Nodes that
have already been read will have their tag stored in the 'aux'
input_overwrite_node (file_data, node, tag, &bp);
/* 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.inlined_to = (cgraph_node *) (intptr_t) ref;
- /* Store a reference for now, and fix up later to be a pointer. */
- node->same_comdat_group = (symtab_node *) (intptr_t) ref2;
+ if (group)
+ {
+ node->set_comdat_group (group);
+ /* Store a reference for now, and fix up later to be a pointer. */
+ node->same_comdat_group = (symtab_node *) (intptr_t) ref2;
+ }
+ else
+ node->same_comdat_group = (symtab_node *) (intptr_t) LCC_NOT_FOUND;
+ section = read_string (ib);
+ if (section)
+ node->set_section_for_node (section);
if (node->thunk.thunk_p)
{
node->thunk.this_adjusting = (type & 2);
node->thunk.virtual_value = virtual_value;
node->thunk.virtual_offset_p = (type & 4);
+ node->thunk.add_pointer_bounds_args = (type & 8);
}
if (node->alias && !node->analyzed && node->weakref)
node->alias_target = get_alias_symbol (node->decl);
node->profile_id = streamer_read_hwi (ib);
+ if (DECL_STATIC_CONSTRUCTOR (node->decl))
+ node->set_init_priority (streamer_read_hwi (ib));
+ if (DECL_STATIC_DESTRUCTOR (node->decl))
+ node->set_fini_priority (streamer_read_hwi (ib));
+
+ if (node->instrumentation_clone)
+ {
+ decl_index = streamer_read_uhwi (ib);
+ fn_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
+ node->orig_decl = fn_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 struct varpool_node *
+static 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;
+ varpool_node *node;
struct bitpack_d bp;
int ref = LCC_NOT_FOUND;
int order;
+ tree group;
+ const char *section;
order = streamer_read_hwi (ib) + order_base;
decl_index = streamer_read_uhwi (ib);
/* Declaration of functions can be already merged with a declaration
from other input file. We keep cgraph unmerged until after streaming
of ipa passes is done. Alays forcingly create a fresh node. */
- node = varpool_create_empty_node ();
+ node = varpool_node::create_empty ();
node->decl = var_decl;
- symtab_register_node (node);
+ node->register_symbol ();
node->order = order;
- if (order >= symtab_order)
- symtab_order = order + 1;
+ if (order >= symtab->order)
+ symtab->order = order + 1;
node->lto_file_data = file_data;
bp = streamer_read_bitpack (ib);
node->externally_visible = bp_unpack_value (&bp, 1);
+ node->no_reorder = bp_unpack_value (&bp, 1);
node->force_output = bp_unpack_value (&bp, 1);
node->forced_by_abi = bp_unpack_value (&bp, 1);
node->unique_name = bp_unpack_value (&bp, 1);
+ node->body_removed = bp_unpack_value (&bp, 1);
+ node->implicit_section = bp_unpack_value (&bp, 1);
+ node->writeonly = bp_unpack_value (&bp, 1);
node->definition = bp_unpack_value (&bp, 1);
node->alias = bp_unpack_value (&bp, 1);
node->weakref = bp_unpack_value (&bp, 1);
node->analyzed = bp_unpack_value (&bp, 1);
node->used_from_other_partition = bp_unpack_value (&bp, 1);
node->in_other_partition = bp_unpack_value (&bp, 1);
- node->need_bounds_init = bp_unpack_value (&bp, 1);
if (node->in_other_partition)
{
DECL_EXTERNAL (node->decl) = 1;
}
if (node->alias && !node->analyzed && node->weakref)
node->alias_target = get_alias_symbol (node->decl);
- ref = streamer_read_hwi (ib);
- /* Store a reference for now, and fix up later to be a pointer. */
- node->same_comdat_group = (symtab_node *) (intptr_t) ref;
+ node->tls_model = (enum tls_model)bp_unpack_value (&bp, 3);
+ node->used_by_single_function = (enum tls_model)bp_unpack_value (&bp, 1);
+ node->need_bounds_init = bp_unpack_value (&bp, 1);
+ group = read_identifier (ib);
+ if (group)
+ {
+ node->set_comdat_group (group);
+ ref = streamer_read_hwi (ib);
+ /* Store a reference for now, and fix up later to be a pointer. */
+ node->same_comdat_group = (symtab_node *) (intptr_t) ref;
+ }
+ else
+ node->same_comdat_group = (symtab_node *) (intptr_t) LCC_NOT_FOUND;
+ section = read_string (ib);
+ if (section)
+ node->set_section_for_node (section);
node->resolution = streamer_read_enum (ib, ld_plugin_symbol_resolution,
LDPR_NUM_KNOWN);
+ gcc_assert (flag_ltrans
+ || (!node->in_other_partition
+ && !node->used_from_other_partition));
return node;
}
struct ipa_ref *ref;
bp = streamer_read_bitpack (ib);
- use = (enum ipa_ref_use) bp_unpack_value (&bp, 2);
+ use = (enum ipa_ref_use) bp_unpack_value (&bp, 3);
speculative = (enum ipa_ref_use) bp_unpack_value (&bp, 1);
node = nodes[streamer_read_hwi (ib)];
- ref = ipa_record_reference (referring_node, node, use, NULL);
+ ref = referring_node->create_reference (node, use);
ref->speculative = speculative;
- if (is_a <cgraph_node> (referring_node))
+ if (is_a <cgraph_node *> (referring_node))
ref->lto_stmt_uid = streamer_read_hwi (ib);
}
struct bitpack_d bp;
int ecf_flags = 0;
- caller = cgraph (nodes[streamer_read_hwi (ib)]);
+ caller = dyn_cast<cgraph_node *> (nodes[streamer_read_hwi (ib)]);
if (caller == NULL || caller->decl == NULL_TREE)
internal_error ("bytecode stream: no caller found while reading edge");
if (!indirect)
{
- callee = cgraph (nodes[streamer_read_hwi (ib)]);
+ callee = dyn_cast<cgraph_node *> (nodes[streamer_read_hwi (ib)]);
if (callee == NULL || callee->decl == NULL_TREE)
internal_error ("bytecode stream: no callee found while reading edge");
}
count = streamer_read_gcov_count (ib);
bp = streamer_read_bitpack (ib);
- inline_failed = bp_unpack_enum (&bp, cgraph_inline_failed_enum, CIF_N_REASONS);
+ inline_failed = bp_unpack_enum (&bp, cgraph_inline_failed_t, CIF_N_REASONS);
stmt_id = bp_unpack_var_len_unsigned (&bp);
freq = (int) bp_unpack_var_len_unsigned (&bp);
if (indirect)
- edge = cgraph_create_indirect_edge (caller, NULL, 0, count, freq);
+ edge = caller->create_indirect_edge (NULL, 0, count, freq);
else
- edge = cgraph_create_edge (caller, callee, NULL, count, freq);
+ edge = caller->create_edge (callee, NULL, count, freq);
edge->indirect_inlining_edge = bp_unpack_value (&bp, 1);
edge->speculative = bp_unpack_value (&bp, 1);
edge->inline_failed = inline_failed;
edge->call_stmt_cannot_inline_p = bp_unpack_value (&bp, 1);
edge->can_throw_external = bp_unpack_value (&bp, 1);
+ edge->in_polymorphic_cdtor = bp_unpack_value (&bp, 1);
if (indirect)
{
if (bp_unpack_value (&bp, 1))
unsigned i;
tag = streamer_read_enum (ib, LTO_symtab_tags, LTO_symtab_last_tag);
- order_base = symtab_order;
+ order_base = symtab->order;
while (tag)
{
if (tag == LTO_symtab_edge)
/* AUX pointers should be all non-zero for function nodes read from the stream. */
#ifdef ENABLE_CHECKING
FOR_EACH_VEC_ELT (nodes, i, node)
- gcc_assert (node->aux || !is_a <cgraph_node> (node));
+ gcc_assert (node->aux || !is_a <cgraph_node *> (node));
#endif
FOR_EACH_VEC_ELT (nodes, i, node)
{
int ref;
- if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
+ if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
{
ref = (int) (intptr_t) cnode->global.inlined_to;
/* Fixup inlined_to from reference to pointer. */
if (ref != LCC_NOT_FOUND)
- cgraph (node)->global.inlined_to = cgraph (nodes[ref]);
+ dyn_cast<cgraph_node *> (node)->global.inlined_to
+ = dyn_cast<cgraph_node *> (nodes[ref]);
else
cnode->global.inlined_to = NULL;
+
+ /* Compute instrumented_version. */
+ if (cnode->instrumentation_clone)
+ {
+ gcc_assert (cnode->orig_decl);
+
+ cnode->instrumented_version = cgraph_node::get (cnode->orig_decl);
+ if (cnode->instrumented_version)
+ cnode->instrumented_version->instrumented_version = cnode;
+
+ /* Restore decl names reference. */
+ if (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (cnode->decl))
+ && !TREE_CHAIN (DECL_ASSEMBLER_NAME (cnode->decl)))
+ TREE_CHAIN (DECL_ASSEMBLER_NAME (cnode->decl))
+ = DECL_ASSEMBLER_NAME (cnode->orig_decl);
+ }
}
ref = (int) (intptr_t) node->same_comdat_group;
node->same_comdat_group = NULL;
}
FOR_EACH_VEC_ELT (nodes, i, node)
- node->aux = is_a <cgraph_node> (node) ? (void *)1 : NULL;
+ node->aux = is_a <cgraph_node *> (node) ? (void *)1 : NULL;
return nodes;
}
}
}
+/* Input function/variable tables that will allow libgomp to look up offload
+ target code, and store them into OFFLOAD_FUNCS and OFFLOAD_VARS. */
+
+void
+input_offload_tables (void)
+{
+ 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++]))
+ {
+ const char *data;
+ size_t len;
+ struct lto_input_block *ib
+ = lto_create_simple_input_block (file_data, LTO_section_offload_table,
+ &data, &len);
+ if (!ib)
+ continue;
+
+ enum LTO_symtab_tags tag
+ = streamer_read_enum (ib, LTO_symtab_tags, LTO_symtab_last_tag);
+ while (tag)
+ {
+ if (tag == LTO_symtab_unavail_node)
+ {
+ int decl_index = streamer_read_uhwi (ib);
+ tree fn_decl
+ = lto_file_decl_data_get_fn_decl (file_data, decl_index);
+ vec_safe_push (offload_funcs, fn_decl);
+ }
+ else if (tag == LTO_symtab_variable)
+ {
+ int decl_index = streamer_read_uhwi (ib);
+ tree var_decl
+ = lto_file_decl_data_get_var_decl (file_data, decl_index);
+ vec_safe_push (offload_vars, var_decl);
+ }
+ else
+ fatal_error ("invalid offload table in %s", file_data->file_name);
+
+ tag = streamer_read_enum (ib, LTO_symtab_tags, LTO_symtab_last_tag);
+ }
+
+ lto_destroy_simple_input_block (file_data, LTO_section_offload_table,
+ ib, data, len);
+ }
+}
+
/* True when we need optimization summary for NODE. */
static int
struct output_block *ob = create_output_block (LTO_section_cgraph_opt_sum);
unsigned count = 0;
- ob->cgraph_node = NULL;
+ ob->symbol = NULL;
encoder = ob->decl_state->symtab_node_encoder;
n_nodes = lto_symtab_encoder_size (encoder);
for (i = 0; i < n_nodes; i++)
{
symtab_node *node = lto_symtab_encoder_deref (encoder, i);
- cgraph_node *cnode = dyn_cast <cgraph_node> (node);
+ cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
if (cnode && output_cgraph_opt_summary_p (cnode))
count++;
}
for (i = 0; i < n_nodes; i++)
{
symtab_node *node = lto_symtab_encoder_deref (encoder, i);
- cgraph_node *cnode = dyn_cast <cgraph_node> (node);
+ cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
if (cnode && output_cgraph_opt_summary_p (cnode))
{
streamer_write_uhwi (ob, i);
count = streamer_read_uhwi (ib_main);
for (i = 0; i < count; i++)
{
- struct ipa_replace_map *map = ggc_alloc_ipa_replace_map ();
+ struct ipa_replace_map *map = ggc_alloc<ipa_replace_map> ();
vec_safe_push (node->clone.tree_map, map);
map->parm_num = streamer_read_uhwi (ib_main);
const int main_offset = cfg_offset + header->cfg_size;
const int 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);
+ lto_input_block ib_main ((const char *) data + main_offset,
+ header->main_size);
data_in =
lto_data_in_create (file_data, (const char *) data + string_offset,
for (i = 0; i < count; i++)
{
int ref = streamer_read_uhwi (&ib_main);
- input_node_opt_summary (cgraph (nodes[ref]),
+ input_node_opt_summary (dyn_cast<cgraph_node *> (nodes[ref]),
&ib_main, data_in);
}
lto_free_section_data (file_data, LTO_section_cgraph_opt_sum, NULL, data,