* lto-symtab.c (lto_symtab_entry_def): Add guessed field.
(lto_symtab_resolve_symbols): Set it.
(lto_symtab_merge_decls_1): Do not compute used_from_object_file;
store resolution field in cgraph/varpool.
* cgraph.c (cgraph_same_body_alias, cgraph_add_thunk): Return node.
(cgraph_get_node_or_alias, cgraph_get_node_or_alias): Constify.
(cgraph_dump_node): Drop used_from_object_file.
(cgraph_clone_node, cgraph_create_virtual_clone): Likewise.
(cgraph_function_body_availability): Use decl_replaceable_p.
(cgraph_make_node_local): Set resolution to LDPR_PREVAILING_DEF_IRONLY.
(cgraph_can_remove_if_no_direct_calls_and_refs): Use
cgraph_used_from_object_file_p.
(cgraph_will_be_removed_from_program_if_no_direct_calls): Use
cgraph_used_from_object_file_p.
(resolution_used_from_other_file_p): New functoin.
(cgraph_used_from_object_file_p): New predicate.
* cgraph.h: Include plugin-api.h
(struct cgraph_local_info): Remove used_from_object_file.
(struct cgraph_node): Add resolution field.
(struct varpool_node): Likewise; remove used_from_object_file;
reove const_value_known.
(cgraph_get_node, cgraph_get_node_or_alias, cgraph_node,
cgraph_same_body_alias, cgraph_add_thunk): Update prototypes.
(resolution_used_from_other_file_p, cgraph_used_from_object_file_p,
varpool_used_from_object_file_p): Declare.
(varpool_get_node, varpool_extra_name_alias): Update prototype.
* tree.h (DECL_REPLACEABLE_P): Remove.
(decl_replaceable_p, decl_binds_to_current_def_p): Declare.
* final.c (rest_of_clean_state): Use decl_binds_to_current_def_p.
* lto-cgraph.c (lto_output_node, lto_output_varpool_node,
input_overwrite_node, input_node, input_varpool_node): Stream
resolution.
* expr.c (expand_expr_real_1): Use const_value_known_p
* ipa.c (ipa_discover_readonly_nonaddressable_var): Do not set
const_value_known.
(cgraph_externally_visible_p): Use cgraph_used_from_object_file_p.
(function_and_variable_visibility): Set resolution for local vars
and functions.
use varpool_used_from_object_file_p.
* varasm.c (resolution_to_local_definition_p, resolution_local_p): New
static functions.
(default_binds_local_p_1): Use resolutoin info.
(decl_binds_to_current_def_p, decl_replaceable_p): New functions.
* varpool.c (varpool_get_node): Constify.
(const_value_known_p): Do not use vnode->const_value_known;
use decl_replaceable_p.
(varpool_finalize_decl): Do not set const_value_known.
(cgraph_variable_initializer_availability): Use decl_replaceable_p
(varpool_extra_name_alias): Return new node.
(varpool_used_from_object_file_p): New function.
* decl.c (finish_function): Use decl_replaceable_p
* method.c (make_alias_for_thunk): Update call of cgraph_same_body_alias.
* lto.c (lto_promote_cross_file_statics): Use const_value_known_p.
From-SVN: r164610
+2010-09-24 Jan Hubicka <jh@suse.cz>
+
+ * lto-symtab.c (lto_symtab_entry_def): Add guessed field.
+ (lto_symtab_resolve_symbols): Set it.
+ (lto_symtab_merge_decls_1): Do not compute used_from_object_file;
+ store resolution field in cgraph/varpool.
+ * cgraph.c (cgraph_same_body_alias, cgraph_add_thunk): Return node.
+ (cgraph_get_node_or_alias, cgraph_get_node_or_alias): Constify.
+ (cgraph_dump_node): Drop used_from_object_file.
+ (cgraph_clone_node, cgraph_create_virtual_clone): Likewise.
+ (cgraph_function_body_availability): Use decl_replaceable_p.
+ (cgraph_make_node_local): Set resolution to LDPR_PREVAILING_DEF_IRONLY.
+ (cgraph_can_remove_if_no_direct_calls_and_refs): Use
+ cgraph_used_from_object_file_p.
+ (cgraph_will_be_removed_from_program_if_no_direct_calls): Use
+ cgraph_used_from_object_file_p.
+ (resolution_used_from_other_file_p): New functoin.
+ (cgraph_used_from_object_file_p): New predicate.
+ * cgraph.h: Include plugin-api.h
+ (struct cgraph_local_info): Remove used_from_object_file.
+ (struct cgraph_node): Add resolution field.
+ (struct varpool_node): Likewise; remove used_from_object_file;
+ reove const_value_known.
+ (cgraph_get_node, cgraph_get_node_or_alias, cgraph_node,
+ cgraph_same_body_alias, cgraph_add_thunk): Update prototypes.
+ (resolution_used_from_other_file_p, cgraph_used_from_object_file_p,
+ varpool_used_from_object_file_p): Declare.
+ (varpool_get_node, varpool_extra_name_alias): Update prototype.
+ * tree.h (DECL_REPLACEABLE_P): Remove.
+ (decl_replaceable_p, decl_binds_to_current_def_p): Declare.
+ * final.c (rest_of_clean_state): Use decl_binds_to_current_def_p.
+ * lto-cgraph.c (lto_output_node, lto_output_varpool_node,
+ input_overwrite_node, input_node, input_varpool_node): Stream
+ resolution.
+ * expr.c (expand_expr_real_1): Use const_value_known_p
+ * ipa.c (ipa_discover_readonly_nonaddressable_var): Do not set
+ const_value_known.
+ (cgraph_externally_visible_p): Use cgraph_used_from_object_file_p.
+ (function_and_variable_visibility): Set resolution for local vars
+ and functions.
+ use varpool_used_from_object_file_p.
+ * varasm.c (resolution_to_local_definition_p, resolution_local_p): New
+ static functions.
+ (default_binds_local_p_1): Use resolutoin info.
+ (decl_binds_to_current_def_p, decl_replaceable_p): New functions.
+ * varpool.c (varpool_get_node): Constify.
+ (const_value_known_p): Do not use vnode->const_value_known;
+ use decl_replaceable_p.
+ (varpool_finalize_decl): Do not set const_value_known.
+ (cgraph_variable_initializer_availability): Use decl_replaceable_p
+ (varpool_extra_name_alias): Return new node.
+ (varpool_used_from_object_file_p): New function.
+
2010-09-24 Richard Henderson <rth@redhat.com>
* config/ia64/ia64.c (ia64_dwarf_handle_frame_unspec): New.
IPA_REFERENCE_H = ipa-reference.h $(BITMAP_H) $(TREE_H)
IPA_TYPE_ESCAPE_H = ipa-type-escape.h $(TREE_H)
CGRAPH_H = cgraph.h $(VEC_H) $(TREE_H) $(BASIC_BLOCK_H) $(FUNCTION_H) \
- cif-code.def ipa-ref.h ipa-ref-inline.h
+ cif-code.def ipa-ref.h ipa-ref-inline.h $(LINKER_PLUGIN_API_H)
DF_H = df.h $(BITMAP_H) $(REGSET_H) sbitmap.h $(BASIC_BLOCK_H) \
alloc-pool.h $(TIMEVAR_H)
RESOURCE_H = resource.h hard-reg-set.h $(DF_H)
return alias_node;
}
-/* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
+/* Attempt to mark ALIAS as an alias to DECL. Return alias node if successful
+ and NULL otherwise.
Same body aliases are output whenever the body of DECL is output,
and cgraph_node (ALIAS) transparently returns cgraph_node (DECL). */
-bool
+struct cgraph_node *
cgraph_same_body_alias (tree alias, tree decl)
{
#ifndef ASM_OUTPUT_DEF
/* If aliases aren't supported by the assembler, fail. */
- return false;
+ return NULL;
#endif
/*gcc_assert (!assembler_name_hash);*/
- return cgraph_same_body_alias_1 (alias, decl) != NULL;
+ return cgraph_same_body_alias_1 (alias, decl);
}
-void
+/* Add thunk alias into callgraph. The alias declaration is ALIAS and it
+ alises DECL with an adjustments made into the first parameter.
+ See comments in thunk_adjust for detail on the parameters. */
+
+struct cgraph_node *
cgraph_add_thunk (tree alias, tree decl, bool this_adjusting,
HOST_WIDE_INT fixed_offset, HOST_WIDE_INT virtual_value,
tree virtual_offset,
node->thunk.virtual_offset_p = virtual_offset != NULL;
node->thunk.alias = real_alias;
node->thunk.thunk_p = true;
+ return node;
}
/* Returns the cgraph node assigned to DECL or NULL if no cgraph node
is assigned. */
struct cgraph_node *
-cgraph_get_node_or_alias (tree decl)
+cgraph_get_node_or_alias (const_tree decl)
{
struct cgraph_node key, *node = NULL, **slot;
if (!cgraph_hash)
return NULL;
- key.decl = decl;
+ key.decl = CONST_CAST2 (tree, const_tree, decl);
slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key,
NO_INSERT);
is assigned. */
struct cgraph_node *
-cgraph_get_node (tree decl)
+cgraph_get_node (const_tree decl)
{
struct cgraph_node key, *node = NULL, **slot;
if (!cgraph_hash)
return NULL;
- key.decl = decl;
+ key.decl = CONST_CAST2 (tree, const_tree, decl);
slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key,
NO_INSERT);
fprintf (f, " local");
if (node->local.externally_visible)
fprintf (f, " externally_visible");
- if (node->local.used_from_object_file)
- fprintf (f, " used_from_object_file");
if (node->local.finalized)
fprintf (f, " finalized");
if (node->local.disregard_inline_limits)
new_node->analyzed = n->analyzed;
new_node->local = n->local;
new_node->local.externally_visible = false;
- new_node->local.used_from_object_file = false;
new_node->local.local = true;
new_node->local.vtable_method = false;
new_node->global = n->global;
else
new_node->clone.combined_args_to_skip = args_to_skip;
new_node->local.externally_visible = 0;
- new_node->local.used_from_object_file = 0;
new_node->local.local = 1;
new_node->lowered = true;
new_node->reachable = true;
AVAIL_AVAILABLE here? That would be good reason to preserve this
bit. */
- else if (DECL_REPLACEABLE_P (node->decl) && !DECL_EXTERNAL (node->decl))
+ else if (decl_replaceable_p (node->decl) && !DECL_EXTERNAL (node->decl))
avail = AVAIL_OVERWRITABLE;
else avail = AVAIL_AVAILABLE;
node->local.externally_visible = false;
node->local.local = true;
+ node->resolution = LDPR_PREVAILING_DEF_IRONLY;
gcc_assert (cgraph_function_body_availability (node) == AVAIL_LOCAL);
}
}
return false;
/* Only COMDAT functions can be removed if externally visible. */
if (node->local.externally_visible
- && (!DECL_COMDAT (node->decl) || node->local.used_from_object_file))
+ && (!DECL_COMDAT (node->decl)
+ || cgraph_used_from_object_file_p (node)))
return false;
/* Constructors and destructors are executed by the runtime, however
we can get rid of all pure constructors and destructors. */
bool
cgraph_will_be_removed_from_program_if_no_direct_calls (struct cgraph_node *node)
{
- if (node->local.used_from_object_file)
+ if (cgraph_used_from_object_file_p (node))
return false;
if (!in_lto_p && !flag_whole_program)
return cgraph_only_called_directly_p (node);
return cgraph_can_remove_if_no_direct_calls_p (node);
}
+/* Return true when RESOLUTION indicate that linker will use
+ the symbol from non-LTo object files. */
+
+bool
+resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
+{
+ return (resolution == LDPR_PREVAILING_DEF
+ || resolution == LDPR_PREEMPTED_REG
+ || resolution == LDPR_RESOLVED_EXEC
+ || resolution == LDPR_RESOLVED_DYN);
+}
+
+/* Return true when NODE is known to be used from other (non-LTO) object file.
+ Known only when doing LTO via linker plugin. */
+
+bool
+cgraph_used_from_object_file_p (struct cgraph_node *node)
+{
+ struct cgraph_node *alias;
+
+ if (!TREE_PUBLIC (node->decl))
+ return false;
+ if (resolution_used_from_other_file_p (node->resolution))
+ return true;
+ for (alias = node->same_body; alias; alias = alias->next)
+ if (TREE_PUBLIC (alias->decl)
+ && resolution_used_from_other_file_p (alias->resolution))
+ return true;
+ return false;
+}
+
#include "gt-cgraph.h"
#ifndef GCC_CGRAPH_H
#define GCC_CGRAPH_H
+#include "plugin-api.h"
#include "vec.h"
#include "tree.h"
#include "basic-block.h"
/* Set when function is visible by other units. */
unsigned externally_visible : 1;
-
- /* Set when resolver determines that function is visible by other units. */
- unsigned used_from_object_file : 1;
/* Set once it has been finalized so we consider it to be output. */
unsigned finalized : 1;
/* unique id for profiling. pid is not suitable because of different
number of cfg nodes with -fprofile-generate and -fprofile-use */
int pid;
+ enum ld_plugin_symbol_resolution resolution;
/* Set when function must be output for some reason. The primary
use of this flag is to mark functions needed to be output for
PTR GTY ((skip)) aux;
/* Ordering of all cgraph nodes. */
int order;
+ enum ld_plugin_symbol_resolution resolution;
/* Set when function must be output - it is externally visible
or its address is taken. */
unsigned output : 1;
/* Set when function is visible by other units. */
unsigned externally_visible : 1;
- /* Set when resolver determines that variable is visible by other units. */
- unsigned used_from_object_file : 1;
/* Set for aliases once they got through assemble_alias. Also set for
extra name aliases in varpool_extra_name_alias. */
unsigned alias : 1;
During WPA output it is used to mark nodes that are present in
multiple partitions. */
unsigned in_other_partition : 1;
- /* True when variable is constant and its value is known. */
- unsigned int const_value_known : 1;
};
/* Every top level asm statement is put into a cgraph_asm_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_get_node_or_alias (tree);
-struct cgraph_node *cgraph_node (tree);
-bool cgraph_same_body_alias (tree, tree);
-void cgraph_add_thunk (tree, tree, bool, HOST_WIDE_INT, HOST_WIDE_INT, tree, tree);
+struct cgraph_node * cgraph_get_node (const_tree);
+struct cgraph_node * cgraph_get_node_or_alias (const_tree);
+struct cgraph_node * cgraph_node (tree);
+struct cgraph_node * cgraph_same_body_alias (tree, tree);
+struct cgraph_node * cgraph_add_thunk (tree, tree, bool, HOST_WIDE_INT,
+ HOST_WIDE_INT, tree, tree);
void cgraph_remove_same_body_alias (struct cgraph_node *);
struct cgraph_node *cgraph_node_for_asm (tree);
struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple);
(struct cgraph_node *node);
bool cgraph_can_remove_if_no_direct_calls_and_refs_p
(struct cgraph_node *node);
+bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution);
+bool cgraph_used_from_object_file_p (struct cgraph_node *node);
+bool varpool_used_from_object_file_p (struct varpool_node *node);
/* In cgraphunit.c */
extern FILE *cgraph_dump_file;
bool cgraph_node_can_be_local_p (struct cgraph_node *);
-struct varpool_node * varpool_get_node (tree decl);
+struct varpool_node * varpool_get_node (const_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_remove_unreferenced_decls (void);
void varpool_empty_needed_queue (void);
-bool varpool_extra_name_alias (tree, tree);
+struct varpool_node * varpool_extra_name_alias (tree, tree);
const char * varpool_node_name (struct varpool_node *node);
void varpool_reset_queue (void);
bool const_value_known_p (tree);
+2010-09-24 Jan Hubicka <jh@suse.cz>
+
+ * decl.c (finish_function): Use decl_replaceable_p
+ * method.c (make_alias_for_thunk): Update call of cgraph_same_body_alias.
+
2010-09-24 Jason Merrill <jason@redhat.com>
* decl.c (compute_array_index_type): Remember type dependence of
if (!processing_template_decl
&& !cp_function_chain->can_throw
&& !flag_non_call_exceptions
- && !DECL_REPLACEABLE_P (fndecl))
+ && !decl_replaceable_p (fndecl))
TREE_NOTHROW (fndecl) = 1;
/* This must come after expand_function_end because cleanups might
if (!flag_syntax_only)
{
- bool ok = cgraph_same_body_alias (alias, function);
+ struct cgraph_node *aliasn = cgraph_same_body_alias (alias, function);
DECL_ASSEMBLER_NAME (function);
- gcc_assert (ok);
+ gcc_assert (aliasn != NULL);
}
return alias;
&& TREE_READONLY (array) && ! TREE_SIDE_EFFECTS (array)
&& TREE_CODE (array) == VAR_DECL && DECL_INITIAL (array)
&& TREE_CODE (DECL_INITIAL (array)) != ERROR_MARK
- && targetm.binds_local_p (array))
+ && const_value_known_p (array))
{
if (TREE_CODE (index) == INTEGER_CST)
{
delete_tree_ssa ();
- if (targetm.binds_local_p (current_function_decl))
+ /* We can reduce stack alignment on call site only when we are sure that
+ the function body just produced will be actually used in the final
+ executable. */
+ if (decl_binds_to_current_def_p (current_function_decl))
{
unsigned int pref = crtl->preferred_stack_boundary;
if (crtl->stack_alignment_needed > crtl->preferred_stack_boundary)
if (dump_file)
fprintf (dump_file, " %s (read-only)", varpool_node_name (vnode));
TREE_READONLY (vnode->decl) = 1;
- vnode->const_value_known |= const_value_known_p (vnode->decl);
}
}
if (dump_file)
return true;
}
}
- if (node->local.used_from_object_file)
+ if (cgraph_used_from_object_file_p (node))
return true;
if (DECL_PRESERVE_P (node->decl))
return true;
struct cgraph_node *alias;
gcc_assert (whole_program || in_lto_p || !TREE_PUBLIC (node->decl));
cgraph_make_decl_local (node->decl);
+ node->resolution = LDPR_PREVAILING_DEF_IRONLY;
for (alias = node->same_body; alias; alias = alias->next)
cgraph_make_decl_local (alias->decl);
if (node->same_comdat_group)
|| ! (ADDR_SPACE_GENERIC_P
(TYPE_ADDR_SPACE (TREE_TYPE (vnode->decl))))))
DECL_COMMON (vnode->decl) = 0;
- /* Even extern variables might have initializers known.
- See, for example testsuite/g++.dg/opt/static3.C */
- vnode->const_value_known |= const_value_known_p (vnode->decl);
}
for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
{
In this case we do not sed used_from_object_file. */
|| !vnode->finalized))
|| DECL_PRESERVE_P (vnode->decl)
- || vnode->used_from_object_file
+ || varpool_used_from_object_file_p (vnode)
|| pointer_set_contains (aliased_vnodes, vnode)
|| lookup_attribute ("externally_visible",
DECL_ATTRIBUTES (vnode->decl))))
{
gcc_assert (in_lto_p || whole_program || !TREE_PUBLIC (vnode->decl));
cgraph_make_decl_local (vnode->decl);
+ vnode->resolution = LDPR_PREVAILING_DEF_IRONLY;
}
- vnode->const_value_known |= const_value_known_p (vnode->decl);
gcc_assert (TREE_STATIC (vnode->decl));
}
pointer_set_destroy (aliased_nodes);
bp_pack_value (&bp, node->finalized_by_frontend, 1);
bp_pack_value (&bp, node->frequency, 2);
lto_output_bitpack (&bp);
+ lto_output_uleb128_stream (ob->main_stream, node->resolution);
if (node->same_body)
{
lto_output_fn_decl_index (ob->decl_state, ob->main_stream,
alias->thunk.alias);
}
+ lto_output_uleb128_stream (ob->main_stream, alias->resolution);
alias = alias->previous;
}
while (alias);
bp_pack_value (&bp, node->force_output, 1);
bp_pack_value (&bp, node->finalized, 1);
bp_pack_value (&bp, node->alias, 1);
- bp_pack_value (&bp, node->const_value_known, 1);
gcc_assert (!node->alias || !node->extra_name);
gcc_assert (node->finalized || !node->analyzed);
gcc_assert (node->needed);
else
ref = LCC_NOT_FOUND;
lto_output_sleb128_stream (ob->main_stream, ref);
+ lto_output_uleb128_stream (ob->main_stream, node->resolution);
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);
+ {
+ lto_output_var_decl_index (ob->decl_state, ob->main_stream, alias->decl);
+ lto_output_uleb128_stream (ob->main_stream, alias->resolution);
+ }
}
}
unsigned int self_time,
unsigned int time_inlining_benefit,
unsigned int self_size,
- unsigned int size_inlining_benefit)
+ unsigned int size_inlining_benefit,
+ enum ld_plugin_symbol_resolution resolution)
{
node->aux = (void *) tag;
node->local.inline_summary.estimated_self_stack_size = stack_size;
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);
+ node->resolution = resolution;
}
/* Output the part of the cgraph in SET. */
int size_inlining_benefit = 0;
unsigned long same_body_count = 0;
int clone_ref;
+ enum ld_plugin_symbol_resolution resolution;
clone_ref = lto_input_sleb128 (ib);
"node %d", node->uid);
bp = lto_input_bitpack (ib);
+ resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
input_overwrite_node (file_data, node, tag, &bp, stack_size, self_time,
time_inlining_benefit, self_size,
- size_inlining_benefit);
+ size_inlining_benefit, resolution);
/* Store a reference for now, and fix up later to be a pointer. */
node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
{
tree alias_decl;
int type;
+ struct cgraph_node *alias;
decl_index = lto_input_uleb128 (ib);
alias_decl = lto_file_decl_data_get_fn_decl (file_data, decl_index);
type = lto_input_uleb128 (ib);
tree real_alias;
decl_index = lto_input_uleb128 (ib);
real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- cgraph_same_body_alias (alias_decl, real_alias);
+ alias = cgraph_same_body_alias (alias_decl, real_alias);
}
else
{
tree real_alias;
decl_index = lto_input_uleb128 (ib);
real_alias = lto_file_decl_data_get_fn_decl (file_data, decl_index);
- cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
- virtual_value,
- (type & 4) ? size_int (virtual_value) : NULL_TREE,
- real_alias);
+ alias = cgraph_add_thunk (alias_decl, fn_decl, type & 2, fixed_offset,
+ virtual_value,
+ (type & 4) ? size_int (virtual_value) : NULL_TREE,
+ real_alias);
}
+ alias->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
}
return node;
}
node->force_output = bp_unpack_value (&bp, 1);
node->finalized = bp_unpack_value (&bp, 1);
node->alias = bp_unpack_value (&bp, 1);
- node->const_value_known = 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);
ref = lto_input_sleb128 (ib);
/* Store a reference for now, and fix up later to be a pointer. */
node->same_comdat_group = (struct varpool_node *) (intptr_t) ref;
+ node->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
if (aliases_p)
{
count = lto_input_uleb128 (ib);
{
tree decl = lto_file_decl_data_get_var_decl (file_data,
lto_input_uleb128 (ib));
- varpool_extra_name_alias (decl, var_decl);
+ struct varpool_node *alias;
+ alias = varpool_extra_name_alias (decl, var_decl);
+ alias->resolution = (enum ld_plugin_symbol_resolution)lto_input_uleb128 (ib);
}
}
return node;
/* LTO file-data and symbol resolution for this decl. */
struct lto_file_decl_data * GTY((skip (""))) file_data;
enum ld_plugin_symbol_resolution resolution;
+ /* True when resolution was guessed and not read from the file. */
+ bool guessed;
/* Pointer to the next entry with the same key. Before decl merging
this links all symbols from the different TUs. After decl merging
this links merged but incompatible decls, thus all prevailing ones
if (!lto_symtab_resolve_can_prevail_p (e))
{
e->resolution = LDPR_RESOLVED_IR;
+ e->guessed = true;
continue;
}
/* Set a default resolution - the final prevailing one will get
adjusted later. */
e->resolution = LDPR_PREEMPTED_IR;
+ e->guessed = true;
if (!lto_symtab_resolve_replaceable_p (e))
{
if (prevailing)
resolution file. These variables still need manual
externally_visible attribute. */
prevailing->resolution = LDPR_PREVAILING_DEF_IRONLY;
+ prevailing->guessed = true;
}
/* Merge all decls in the symbol table chain to the prevailing decl and
&& TREE_CODE (prevailing->decl) != VAR_DECL)
prevailing->next = NULL;
- /* Set used_from_object_file flags. */
- if (prevailing->resolution == LDPR_PREVAILING_DEF
- || prevailing->resolution == LDPR_PREEMPTED_REG
- || prevailing->resolution == LDPR_RESOLVED_EXEC
- || prevailing->resolution == LDPR_RESOLVED_DYN)
- {
- if (TREE_CODE (prevailing->decl) == FUNCTION_DECL)
- {
- if (prevailing->node->same_body_alias)
- prevailing->node->same_body->local.used_from_object_file = true;
- else
- prevailing->node->local.used_from_object_file = true;
- }
- else
- {
- if (prevailing->vnode->alias)
- prevailing->vnode->extra_name->used_from_object_file = true;
- else
- prevailing->vnode->used_from_object_file = true;
- }
- }
+ /* Store resolution decision into the callgraph.
+ In LTRANS don't overwrite information we stored into callgraph at
+ WPA stage.
+
+ Do not bother to store guessed decisions. Generic code knows how
+ to handle UNKNOWN relocation well.
+
+ The problem with storing guessed decision is whether to use
+ PREVAILING_DEF or PREVAILING_DEF_IRONLY. First one would disable
+ some whole program optimizations, while ther second would imply
+ to many whole program assumptions. */
+ if (prevailing->node && !flag_ltrans && !prevailing->guessed)
+ prevailing->node->resolution = prevailing->resolution;
+ else if (prevailing->vnode && !flag_ltrans && !prevailing->guessed)
+ prevailing->vnode->resolution = prevailing->resolution;
return 1;
}
+2010-09-24 Jan Hubicka <jh@suse.cz>
+
+ * lto.c (lto_promote_cross_file_statics): Use const_value_known_p.
+
2010-09-20 Jan Hubicka <jh@suse.cz>
PR tree-optimize/45605
&& !v->externally_visible && v->analyzed)
{
if (promote_var (v)
- && DECL_INITIAL (v->decl) && v->const_value_known
+ && DECL_INITIAL (v->decl)
+ && const_value_known_p (v->decl)
&& !pointer_set_insert (inserted, vnode))
VEC_safe_push (varpool_node_ptr, heap,
promoted_initializers, v);
multiple translation units should be merged. */
#define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE)
-/* A replaceable function is one which may be replaced at link-time
- with an entirely different definition, provided that the
- replacement has the same type. For example, functions declared
- with __attribute__((weak)) on most systems are replaceable.
-
- COMDAT functions are not replaceable, since all definitions of the
- function must be equivalent. It is important that COMDAT functions
- not be treated as replaceable so that use of C++ template
- instantiations is not penalized.
-
- In other respects, the condition is usually equivalent to whether
- the function binds to the current module (shared library or executable).
- However, weak functions can always be overridden by earlier TUs
- in the same module, even if they bind locally to that module.
-
- For example, DECL_REPLACEABLE is used to determine whether or not a
- function (including a template instantiation) which is not
- explicitly declared "inline" can be inlined. If the function is
- DECL_REPLACEABLE then it is not safe to do the inlining, since the
- implementation chosen at link-time may be different. However, a
- function that is not DECL_REPLACEABLE can be inlined, since all
- versions of the function will be functionally identical. */
-#define DECL_REPLACEABLE_P(NODE) \
- (!DECL_COMDAT (NODE) && (DECL_WEAK (NODE) || !targetm.binds_local_p (NODE)))
-
/* The name of the object as the assembler will see it (but before any
translations made by ASM_OUTPUT_LABELREF). Often this is the same
as DECL_NAME. It is an IDENTIFIER_NODE. */
extern void finish_aliases_1 (void);
extern void finish_aliases_2 (void);
extern void remove_unreachable_alias_pairs (void);
+extern bool decl_replaceable_p (tree);
+extern bool decl_binds_to_current_def_p (tree);
/* In stmt.c */
extern void expand_computed_goto (tree);
return true;
}
+/* Return true when RESOLUTION indicate that symbol will be bound to the
+ definition provided by current .o file. */
+
+static bool
+resolution_to_local_definition_p (enum ld_plugin_symbol_resolution resolution)
+{
+ return (resolution == LDPR_PREVAILING_DEF
+ || resolution == LDPR_PREVAILING_DEF_IRONLY);
+}
+
+/* Return true when RESOLUTION indicate that symbol will be bound locally
+ within current executable or DSO. */
+
+static bool
+resolution_local_p (enum ld_plugin_symbol_resolution resolution)
+{
+ return (resolution == LDPR_PREVAILING_DEF
+ || resolution == LDPR_PREVAILING_DEF_IRONLY
+ || resolution == LDPR_PREEMPTED_REG
+ || resolution == LDPR_PREEMPTED_IR
+ || resolution == LDPR_RESOLVED_IR
+ || resolution == LDPR_RESOLVED_EXEC);
+}
+
/* Assume ELF-ish defaults, since that's pretty much the most liberal
wrt cross-module name binding. */
default_binds_local_p_1 (const_tree exp, int shlib)
{
bool local_p;
+ bool resolved_locally = false;
+ bool resolved_to_local_def = false;
+
+ /* With resolution file in hands, take look into resolutions.
+ We can't just return true for resolved_localy symbols,
+ because dynamic linking might overwrite symbols
+ in shared libraries. */
+ if (TREE_CODE (exp) == VAR_DECL && TREE_PUBLIC (exp)
+ && (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
+ {
+ struct varpool_node *vnode = varpool_get_node (exp);
+ if (vnode && resolution_local_p (vnode->resolution))
+ resolved_locally = true;
+ if (vnode
+ && resolution_to_local_definition_p (vnode->resolution))
+ resolved_to_local_def = true;
+ }
+ else if (TREE_CODE (exp) == FUNCTION_DECL && TREE_PUBLIC (exp))
+ {
+ struct cgraph_node *node = cgraph_get_node_or_alias (exp);
+ if (node
+ && resolution_local_p (node->resolution))
+ resolved_locally = true;
+ if (node
+ && resolution_to_local_definition_p (node->resolution))
+ resolved_to_local_def = true;
+ }
/* A non-decl is an entry in the constant pool. */
if (!DECL_P (exp))
local_p = true;
/* Weakrefs may not bind locally, even though the weakref itself is
- always static and therefore local. */
+ always static and therefore local.
+ FIXME: We can resolve this more curefuly by looking at the weakref
+ alias. */
else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp)))
local_p = false;
/* Static variables are always local. */
local_p = true;
/* A variable is local if the user has said explicitly that it will
be. */
- else if (DECL_VISIBILITY_SPECIFIED (exp)
+ else if ((DECL_VISIBILITY_SPECIFIED (exp)
+ || resolved_to_local_def)
&& DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
local_p = true;
/* Variables defined outside this object might not be local. */
- else if (DECL_EXTERNAL (exp))
+ else if (DECL_EXTERNAL (exp) && !resolved_locally)
local_p = false;
/* If defined in this object and visibility is not default, must be
local. */
local_p = true;
/* Default visibility weak data can be overridden by a strong symbol
in another module and so are not local. */
- else if (DECL_WEAK (exp))
+ else if (DECL_WEAK (exp)
+ && !resolved_locally)
local_p = false;
/* If PIC, then assume that any global name can be overridden by
- symbols resolved from other modules, unless we are compiling with
- -fwhole-program, which assumes that names are local. */
+ symbols resolved from other modules. */
else if (shlib)
- local_p = flag_whole_program;
+ local_p = false;
/* Uninitialized COMMON variable may be unified with symbols
resolved from other modules. */
else if (DECL_COMMON (exp)
+ && !resolved_locally
&& (DECL_INITIAL (exp) == NULL
|| DECL_INITIAL (exp) == error_mark_node))
local_p = false;
return local_p;
}
+/* Return true when references to DECL must bind to current definition in
+ final executable.
+
+ The condition is usually equivalent to whether the function binds to the
+ current module (shared library or executable), that is to binds_local_p.
+ We use this fact to avoid need for another target hook and implement
+ the logic using binds_local_p and just special cases where
+ decl_binds_to_current_def_p is stronger than binds local_p. In particular
+ the weak definitions (that can be overwritten at linktime by other
+ definition from different object file) and when resolution info is available
+ we simply use the knowledge passed to us by linker plugin. */
+bool
+decl_binds_to_current_def_p (tree decl)
+{
+ gcc_assert (DECL_P (decl));
+ if (!TREE_PUBLIC (decl))
+ return true;
+ if (!targetm.binds_local_p (decl))
+ return false;
+ /* When resolution is available, just use it. */
+ if (TREE_CODE (decl) == VAR_DECL && TREE_PUBLIC (decl)
+ && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
+ {
+ struct varpool_node *vnode = varpool_get_node (decl);
+ if (vnode
+ && vnode->resolution != LDPR_UNKNOWN)
+ return resolution_to_local_definition_p (vnode->resolution);
+ }
+ else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_PUBLIC (decl))
+ {
+ struct cgraph_node *node = cgraph_get_node_or_alias (decl);
+ if (node
+ && node->resolution != LDPR_UNKNOWN)
+ return resolution_to_local_definition_p (node->resolution);
+ }
+ /* Otherwise we have to assume the worst for DECL_WEAK (hidden weaks
+ binds localy but still can be overwritten).
+ This rely on fact that binds_local_p behave as decl_replaceable_p
+ for all other declaration types. */
+ return !DECL_WEAK (decl);
+}
+
+/* A replaceable function or variable is one which may be replaced
+ at link-time with an entirely different definition, provided that the
+ replacement has the same type. For example, functions declared
+ with __attribute__((weak)) on most systems are replaceable.
+
+ COMDAT functions are not replaceable, since all definitions of the
+ function must be equivalent. It is important that COMDAT functions
+ not be treated as replaceable so that use of C++ template
+ instantiations is not penalized. */
+
+bool
+decl_replaceable_p (tree decl)
+{
+ gcc_assert (DECL_P (decl));
+ if (!TREE_PUBLIC (decl) || DECL_COMDAT (decl))
+ return false;
+ return !decl_binds_to_current_def_p (decl);
+}
+
/* Default function to output code that will globalize a label. A
target must define GLOBAL_ASM_OP or provide its own function to
globalize a label. */
/* Return varpool node assigned to DECL without creating new one. */
struct varpool_node *
-varpool_get_node (tree decl)
+varpool_get_node (const_tree decl)
{
struct varpool_node key, **slot;
if (!varpool_hash)
return NULL;
- key.decl = decl;
+ key.decl = CONST_CAST2 (tree, const_tree, decl);
slot = (struct varpool_node **)
htab_find_slot (varpool_hash, &key, NO_INSERT);
if (!slot)
bool
const_value_known_p (tree decl)
{
- struct varpool_node *vnode;
-
if (TREE_CODE (decl) != VAR_DECL
&&TREE_CODE (decl) != CONST_DECL)
return false;
gcc_assert (TREE_STATIC (decl) || DECL_EXTERNAL (decl));
- /* In WHOPR mode we can put variable into one partition
- and make it external in the other partition. In this
- case we still know the value, but it can't be determined
- from DECL flags. For this reason we keep const_value_known
- flag in varpool nodes. */
- if ((vnode = varpool_get_node (decl))
- && vnode->const_value_known)
- return true;
-
/* Variables declared 'const' without an initializer
have zero as the initializer if they may not be
overridden at link or run time. */
if (!DECL_INITIAL (decl)
&& (DECL_EXTERNAL (decl)
- || DECL_REPLACEABLE_P (decl)))
+ || decl_replaceable_p (decl)))
return false;
/* Variables declared `const' with an initializer are considered
there. */
else if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
varpool_mark_needed_node (node);
- node->const_value_known |= const_value_known_p (node->decl);
if (cgraph_global_info_ready)
varpool_assemble_pending_decls ();
}
/* If the variable can be overwritten, return OVERWRITABLE. Takes
care of at least two notable extensions - the COMDAT variables
used to share template instantiations in C++. */
- if (!(*targetm.binds_local_p) (node->decl) && !DECL_COMDAT (node->decl))
+ if (!decl_replaceable_p (node->decl))
return AVAIL_OVERWRITABLE;
return AVAIL_AVAILABLE;
}
/* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
Extra name aliases are output whenever DECL is output. */
-bool
+struct varpool_node *
varpool_extra_name_alias (tree alias, tree decl)
{
struct varpool_node key, *alias_node, *decl_node, **slot;
/* If the varpool_node has been already created, fail. */
if (*slot)
- return false;
+ return NULL;
alias_node = ggc_alloc_cleared_varpool_node ();
alias_node->decl = alias;
decl_node->extra_name->prev = alias_node;
decl_node->extra_name = alias_node;
*slot = alias_node;
- return true;
+ return alias_node;
+}
+
+/* Return true when NODE is known to be used from other (non-LTO) object file.
+ Known only when doing LTO via linker plugin. */
+
+bool
+varpool_used_from_object_file_p (struct varpool_node *node)
+{
+ struct varpool_node *alias;
+
+ if (!TREE_PUBLIC (node->decl))
+ return false;
+ if (resolution_used_from_other_file_p (node->resolution))
+ return true;
+ for (alias = node->extra_name; alias; alias = alias->next)
+ if (TREE_PUBLIC (alias->decl)
+ && resolution_used_from_other_file_p (alias->resolution))
+ return true;
+ return false;
}
#include "gt-varpool.h"
projects / gcc.git / commitdiff