#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 "hash-set.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;
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;
}
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;
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;
}
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->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);
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->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.
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->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);
group = node->get_comdat_group ();
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);
/* Add all references in NODE to encoders. */
static void
-add_references (lto_symtab_encoder_t encoder, symtab_node *node)
+create_references (lto_symtab_encoder_t encoder, symtab_node *node)
{
int i;
struct ipa_ref *ref = NULL;
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.
!lsei_end_p (lsei); lsei_next_function_in_partition (&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);
+ create_references (encoder, node);
/* For proper debug info, we need to ship the origins, too. */
if (DECL_ABSTRACT_ORIGIN (node->decl))
{
{
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);
+ create_references (encoder, vnode);
/* For proper debug info, we need to ship the origins, too. */
if (DECL_ABSTRACT_ORIGIN (vnode->decl))
{
{
if (!lto_symtab_encoder_encode_initializer_p (encoder,
vnode)
- && vnode->ctor_useable_for_folding_p ())
+ && (vnode->ctor_useable_for_folding_p ()
+ || POINTER_BOUNDS_P (vnode->decl)))
{
lto_set_symtab_encoder_encode_initializer (encoder, vnode);
- add_references (encoder, vnode);
+ create_references (encoder, vnode);
}
}
}
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->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));
int i, count;
tree group;
const char *section;
-
order = streamer_read_hwi (ib) + order_base;
clone_ref = streamer_read_hwi (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 = cgraph_node::create_empty ();
+ node = symtab->create_empty ();
node->decl = fn_decl;
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->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->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;
}
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->alias_target = get_alias_symbol (node->decl);
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)
{
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 = referring_node->add_reference (node, use);
+ ref = referring_node->create_reference (node, use);
ref->speculative = speculative;
if (is_a <cgraph_node *> (referring_node))
ref->lto_stmt_uid = streamer_read_hwi (ib);
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)
= 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;
}
}
+/* 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
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,
projects / gcc.git / blobdiff