/* Symbol table.
- Copyright (C) 2012-2016 Free Software Foundation, Inc.
+ Copyright (C) 2012-2019 Free Software Foundation, Inc.
Contributed by Jan Hubicka
This file is part of GCC.
#include "output.h"
#include "ipa-utils.h"
#include "calls.h"
+#include "stringpool.h"
+#include "attribs.h"
+#include "builtins.h"
-static const char *ipa_ref_use_name[] = {"read","write","addr","alias","chkp"};
+static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
const char * const ld_plugin_symbol_resolution_names[]=
{
/* We can have user ASM names on things, like global register variables, that
are not in the symbol table. */
- if ((TREE_CODE (decl) == VAR_DECL
- && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
+ if ((VAR_P (decl) && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
|| TREE_CODE (decl) == FUNCTION_DECL)
node = symtab_node::get (decl);
if (!DECL_ASSEMBLER_NAME_SET_P (decl))
const char *old_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
&& DECL_RTL_SET_P (decl))
- warning (0, "%D renamed after being referenced in assembly", decl);
+ warning (0, "%qD renamed after being referenced in assembly", decl);
SET_DECL_ASSEMBLER_NAME (decl, name);
if (alias)
return lang_hooks.decl_printable_name (decl, 2);
}
+const char *
+symtab_node::get_dump_name (bool asm_name_p) const
+{
+#define EXTRA 16
+ const char *fname = asm_name_p ? asm_name () : name ();
+ unsigned l = strlen (fname);
+
+ char *s = (char *)ggc_internal_cleared_alloc (l + EXTRA);
+ snprintf (s, l + EXTRA, "%s/%d", fname, order);
+
+ return s;
+}
+
+const char *
+symtab_node::dump_name () const
+{
+ return get_dump_name (false);
+}
+
+const char *
+symtab_node::dump_asm_name () const
+{
+ return get_dump_name (true);
+}
+
/* Return ipa reference from this symtab_node to
REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
of the use. */
return ref;
}
-/* If VAL is a reference to a function or a variable, add a reference from
- this symtab_node to the corresponding symbol table node. USE_TYPE specify
- type of the use and STMT the statement (if it exists). Return the new
- reference or NULL if none was created. */
-
ipa_ref *
-symtab_node::maybe_create_reference (tree val, enum ipa_ref_use use_type,
- gimple *stmt)
+symtab_node::maybe_create_reference (tree val, gimple *stmt)
{
STRIP_NOPS (val);
- if (TREE_CODE (val) != ADDR_EXPR)
- return NULL;
+ ipa_ref_use use_type;
+
+ switch (TREE_CODE (val))
+ {
+ case VAR_DECL:
+ use_type = IPA_REF_LOAD;
+ break;
+ case ADDR_EXPR:
+ use_type = IPA_REF_ADDR;
+ break;
+ default:
+ gcc_assert (!handled_component_p (val));
+ return NULL;
+ }
+
val = get_base_var (val);
- if (val && (TREE_CODE (val) == FUNCTION_DECL
- || TREE_CODE (val) == VAR_DECL))
+ if (val && VAR_OR_FUNCTION_DECL_P (val))
{
symtab_node *referred = symtab_node::get (val);
gcc_checking_assert (referred);
int i;
for (i = 0; iterate_reference (i, ref); i++)
{
- fprintf (file, "%s/%i (%s)",
- ref->referred->asm_name (),
- ref->referred->order,
+ fprintf (file, "%s (%s)",
+ ref->referred->dump_asm_name (),
ipa_ref_use_name [ref->use]);
if (ref->speculative)
fprintf (file, " (speculative)");
int i;
for (i = 0; iterate_referring(i, ref); i++)
{
- fprintf (file, "%s/%i (%s)",
- ref->referring->asm_name (),
- ref->referring->order,
+ fprintf (file, "%s (%s)",
+ ref->referring->dump_asm_name (),
ipa_ref_use_name [ref->use]);
if (ref->speculative)
fprintf (file, " (speculative)");
static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
+/* Dump the visibility of the symbol. */
+
+const char *
+symtab_node::get_visibility_string () const
+{
+ static const char * const visibility_types[]
+ = { "default", "protected", "hidden", "internal" };
+ return visibility_types[DECL_VISIBILITY (decl)];
+}
+
+/* Dump the type_name of the symbol. */
+const char *
+symtab_node::get_symtab_type_string () const
+{
+ return symtab_type_names[type];
+}
+
/* Dump base fields of symtab nodes to F. Not to be used directly. */
void
"default", "protected", "hidden", "internal"
};
- fprintf (f, "%s/%i (%s)", asm_name (), order, name ());
+ fprintf (f, "%s (%s)", dump_asm_name (), name ());
dump_addr (f, " @", (void *)this);
fprintf (f, "\n Type: %s", symtab_type_names[type]);
fprintf (f, "\n");
if (same_comdat_group)
- fprintf (f, " Same comdat group as: %s/%i\n",
- same_comdat_group->asm_name (),
- same_comdat_group->order);
+ fprintf (f, " Same comdat group as: %s\n",
+ same_comdat_group->dump_asm_name ());
if (next_sharing_asm_name)
fprintf (f, " next sharing asm name: %i\n",
next_sharing_asm_name->order);
{
fprintf (f, " Aux:");
dump_addr (f, " @", (void *)aux);
+ fprintf (f, "\n");
}
fprintf (f, " References: ");
vnode->dump (f);
}
-/* Dump symbol table to F. */
-
void
-symtab_node::dump_table (FILE *f)
+symbol_table::dump (FILE *f)
{
symtab_node *node;
fprintf (f, "Symbol table:\n\n");
node->dump (f);
}
+DEBUG_FUNCTION void
+symbol_table::debug (void)
+{
+ dump (stderr);
+}
/* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
Return NULL if there's no such node. */
/* Verify common part of symtab nodes. */
+#if __GNUC__ >= 10
+/* Disable warnings about missing quoting in GCC diagnostics for
+ the verification errors. Their format strings don't follow GCC
+ diagnostic conventions and the calls are ultimately followed by
+ one to internal_error. */
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wformat-diag"
+#endif
+
DEBUG_FUNCTION bool
symtab_node::verify_base (void)
{
error ("function symbol is not function");
error_found = true;
}
+ else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl))
+ != NULL)
+ != dyn_cast <cgraph_node *> (this)->ifunc_resolver)
+ {
+ error ("inconsistent %<ifunc%> attribute");
+ error_found = true;
+ }
}
else if (is_a <varpool_node *> (this))
{
- if (TREE_CODE (decl) != VAR_DECL)
+ if (!VAR_P (decl))
{
error ("variable symbol is not variable");
error_found = true;
if (symtab->assembler_name_hash)
{
hashed_node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl));
- if (hashed_node && hashed_node->previous_sharing_asm_name)
+ if (hashed_node)
{
- error ("assembler name hash list corrupted");
- error_found = true;
- }
- while (hashed_node)
- {
- if (hashed_node == this)
- break;
- hashed_node = hashed_node->next_sharing_asm_name;
- }
- if (!hashed_node
- && !(is_a <varpool_node *> (this)
- && DECL_HARD_REGISTER (decl)))
- {
- error ("node not found in symtab assembler name hash");
- error_found = true;
+ if (hashed_node->previous_sharing_asm_name)
+ {
+ error ("assembler name hash list corrupted");
+ error_found = true;
+ }
+ else if (previous_sharing_asm_name == NULL)
+ {
+ if (hashed_node != this)
+ {
+ error ("assembler name hash list corrupted");
+ error_found = true;
+ }
+ }
+ else if (!(is_a <varpool_node *> (this) && DECL_HARD_REGISTER (decl)))
+ {
+ if (!asmname_hasher::equal (previous_sharing_asm_name,
+ DECL_ASSEMBLER_NAME (decl)))
+ {
+ error ("node not found in symtab assembler name hash");
+ error_found = true;
+ }
+ }
}
}
if (previous_sharing_asm_name
}
if (analyzed && !definition)
{
- error ("node is analyzed byt it is not a definition");
+ error ("node is analyzed but it is not a definition");
error_found = true;
}
if (cpp_implicit_alias && !alias)
}
if (implicit_section && !get_section ())
{
- error ("implicit_section flag is set but section isn't");
+ error ("implicit_section flag is set but section isn%'t");
error_found = true;
}
if (get_section () && get_comdat_group ()
|| strcmp (get_section(),
get_alias_target ()->get_section ())))
{
- error ("Alias and target's section differs");
+ error ("Alias and target%'s section differs");
get_alias_target ()->dump (stderr);
error_found = true;
}
if (alias && definition
&& get_comdat_group () != get_alias_target ()->get_comdat_group ())
{
- error ("Alias and target's comdat groups differs");
+ error ("Alias and target%'s comdat groups differs");
get_alias_target ()->dump (stderr);
error_found = true;
}
ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to->decl)));
if (!symbol_table::assembler_names_equal_p (name1, name2))
{
- error ("Transparent alias and target's assembler names differs");
+ error ("Transparent alias and target%'s assembler names differs");
get_alias_target ()->dump (stderr);
error_found = true;
}
}
}
+#if __GNUC__ >= 10
+# pragma GCC diagnostic pop
+#endif
+
/* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
but other code such as notice_global_symbol generates rtl. */
alias->make_decl_local ();
}
- if (TREE_CODE (decl) == VAR_DECL)
+ if (VAR_P (decl))
{
DECL_COMMON (decl) = 0;
/* ADDRESSABLE flag is not defined for public symbols. */
TREE_ADDRESSABLE (decl) = 1;
TREE_STATIC (decl) = 1;
}
- else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
+ else
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
DECL_COMDAT (decl) = 0;
DECL_WEAK (decl) = 0;
alias->copy_visibility_from (n);
}
- if (TREE_CODE (decl) == VAR_DECL)
+ if (VAR_P (decl))
{
DECL_COMMON (decl) = DECL_COMMON (n->decl);
/* ADDRESSABLE flag is not defined for public symbols. */
}
/* Set section, do not recurse into aliases.
- When one wants to change section of symbol and its aliases,
+ When one wants to change section of a symbol and its aliases,
use set_section. */
void
void
symtab_node::set_section (const char *section)
{
- gcc_assert (!this->alias);
+ gcc_assert (!this->alias || !this->analyzed);
call_for_symbol_and_aliases
(symtab_node::set_section, const_cast<char *>(section), true);
}
return false;
}
-/* If node can not be overwriten by static or dynamic linker to point to
+/* If node cannot be overwriten by static or dynamic linker to point to
different definition, return NODE. Otherwise look for alias with such
property and if none exists, introduce new one. */
(void *)&new_node, true);
if (new_node)
return new_node;
-#ifndef ASM_OUTPUT_DEF
+
/* If aliases aren't supported by the assembler, fail. */
- return NULL;
-#endif
+ if (!TARGET_SUPPORTS_ALIASES)
+ return NULL;
/* Otherwise create a new one. */
new_decl = copy_node (node->decl);
{
if (alias && definition && !ultimate_alias_target ()->definition)
return SYMBOL_EXTERNAL;
- /* Constant pool references use local symbol names that can not
+ /* Constant pool references use local symbol names that cannot
be promoted global. We should never put into a constant pool
- objects that can not be duplicated across partitions. */
+ objects that cannot be duplicated across partitions. */
if (DECL_IN_CONSTANT_POOL (decl))
return SYMBOL_DUPLICATE;
if (DECL_HARD_REGISTER (decl))
if (target->alias && target->weakref)
return false;
- /* We can not recurse to target::nonzero. It is possible that the
+ /* We cannot recurse to target::nonzero. It is possible that the
target is used only via the alias.
We may walk references and look for strong use, but we do not know
if this strong use will survive to final binary, so be
return true;
}
- /* If target is defined and not extern, we know it will be output and thus
- it will bind to non-NULL.
- Play safe for flag_delete_null_pointer_checks where weak definition maye
+ /* If target is defined and either comdat or not extern, we know it will be
+ output and thus it will bind to non-NULL.
+ Play safe for flag_delete_null_pointer_checks where weak definition may
be re-defined by NULL. */
- if (definition && !DECL_EXTERNAL (decl)
+ if (definition && (!DECL_EXTERNAL (decl) || DECL_COMDAT (decl))
&& (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
{
if (!DECL_WEAK (decl))
bool really_binds_local1 = binds_local1;
bool really_binds_local2 = binds_local2;
- /* Addresses of vtables and virtual functions can not be used by user
+ /* Addresses of vtables and virtual functions cannot be used by user
code and are used only within speculation. In this case we may make
symbol equivalent to its alias even if interposition may break this
rule. Doing so will allow us to turn speculative inlining into
if (rs1 != rs2 && avail1 >= AVAIL_AVAILABLE && avail2 >= AVAIL_AVAILABLE)
binds_local1 = binds_local2 = true;
- if ((binds_local1 ? rs1 : this)
- == (binds_local2 ? rs2 : s2))
+ if (binds_local1 && binds_local2 && rs1 == rs2)
{
/* We made use of the fact that alias is not weak. */
- if (binds_local1 && rs1 != this)
+ if (rs1 != this)
refuse_visibility_changes = true;
- if (binds_local2 && rs2 != s2)
+ if (rs2 != s2)
s2->refuse_visibility_changes = true;
return 1;
}
- /* If both symbols may resolve to NULL, we can not really prove them
+ /* If both symbols may resolve to NULL, we cannot really prove them
different. */
if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
return -1;
return -1;
/* If we have a non-interposale definition of at least one of the symbols
- and the other symbol is different, we know other unit can not interpose
+ and the other symbol is different, we know other unit cannot interpose
it to the first symbol; all aliases of the definition needs to be
present in the current unit. */
if (((really_binds_local1 || really_binds_local2)
symtab_node *target = ultimate_alias_target ();
/* For now support only variables. */
- if (TREE_CODE (decl) != VAR_DECL)
+ if (!VAR_P (decl))
return false;
/* With -fno-toplevel-reorder we may have already output the constant. */
if (TREE_ASM_WRITTEN (target->decl))
return false;
- /* If target is already placed in an anchor, we can not touch its
+ /* If target is already placed in an anchor, we cannot touch its
alignment. */
if (DECL_RTL_SET_P (target->decl)
&& MEM_P (DECL_RTL (target->decl))
void
symtab_node::increase_alignment (unsigned int align)
{
- gcc_assert (can_increase_alignment_p () && align < MAX_OFILE_ALIGNMENT);
+ gcc_assert (can_increase_alignment_p () && align <= MAX_OFILE_ALIGNMENT);
ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1,
(void *)(size_t) align,
true);
{
if (!definition)
return false;
+ if (transparent_alias)
+ return definition
+ && get_alias_target()->binds_to_current_def_p (ref);
+ cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
+ if (cnode && cnode->ifunc_resolver)
+ return false;
if (decl_binds_to_current_def_p (decl))
return true;
/* Inline clones always binds locally. */
- cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
if (cnode && cnode->global.inlined_to)
return true;
if (DECL_EXTERNAL (decl))
return false;
- if (!externally_visible)
- debug ();
gcc_assert (externally_visible);
if (ref)
return false;
}
+
+/* Return true if symbol should be output to the symbol table. */
+
+bool
+symtab_node::output_to_lto_symbol_table_p (void)
+{
+ /* Only externally visible symbols matter. */
+ if (!TREE_PUBLIC (decl))
+ return false;
+ if (!real_symbol_p ())
+ return false;
+ /* FIXME: variables probably should not be considered as real symbols at
+ first place. */
+ if (VAR_P (decl) && DECL_HARD_REGISTER (decl))
+ return false;
+ /* FIXME: Builtins corresponding to real functions probably should have
+ symbol table entries. */
+ if (TREE_CODE (decl) == FUNCTION_DECL && fndecl_built_in_p (decl))
+ return false;
+
+ /* We have real symbol that should be in symbol table. However try to trim
+ down the refernces to libraries bit more because linker will otherwise
+ bring unnecesary object files into the final link.
+ FIXME: The following checks can easily be confused i.e. by self recursive
+ function or self-referring variable. */
+
+ /* We keep external functions in symtab for sake of inlining
+ and devirtualization. We do not want to see them in symbol table as
+ references unless they are really used. */
+ cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
+ if (cnode && (!definition || DECL_EXTERNAL (decl))
+ && cnode->callers)
+ return true;
+
+ /* Ignore all references from external vars initializers - they are not really
+ part of the compilation unit until they are used by folding. Some symbols,
+ like references to external construction vtables cannot be referred to at
+ all. We decide this at can_refer_decl_in_current_unit_p. */
+ if (!definition || DECL_EXTERNAL (decl))
+ {
+ int i;
+ struct ipa_ref *ref;
+ for (i = 0; iterate_referring (i, ref); i++)
+ {
+ if (ref->use == IPA_REF_ALIAS)
+ continue;
+ if (is_a <cgraph_node *> (ref->referring))
+ return true;
+ if (!DECL_EXTERNAL (ref->referring->decl))
+ return true;
+ }
+ return false;
+ }
+ return true;
+}
projects / thirdparty / gcc.git / blobdiff