/* Symbol table.
- Copyright (C) 2012-2015 Free Software Foundation, Inc.
+ Copyright (C) 2012-2019 Free Software Foundation, Inc.
Contributed by Jan Hubicka
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
+#include "target.h"
#include "rtl.h"
-#include "hash-set.h"
-#include "machmode.h"
-#include "vec.h"
-#include "double-int.h"
-#include "input.h"
-#include "alias.h"
-#include "symtab.h"
-#include "wide-int.h"
-#include "inchash.h"
#include "tree.h"
-#include "fold-const.h"
-#include "print-tree.h"
-#include "varasm.h"
-#include "hashtab.h"
-#include "hard-reg-set.h"
-#include "input.h"
-#include "function.h"
-#include "emit-rtl.h"
-#include "predict.h"
-#include "basic-block.h"
-#include "tree-ssa-alias.h"
-#include "internal-fn.h"
-#include "gimple-expr.h"
-#include "is-a.h"
#include "gimple.h"
-#include "tree-inline.h"
-#include "langhooks.h"
-#include "hash-map.h"
-#include "plugin-api.h"
-#include "ipa-ref.h"
-#include "cgraph.h"
-#include "diagnostic.h"
#include "timevar.h"
+#include "cgraph.h"
#include "lto-streamer.h"
+#include "print-tree.h"
+#include "varasm.h"
+#include "langhooks.h"
#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[]=
{
"prevailing_def_ironly_exp"
};
+/* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
+ until we find an identifier that is not itself a transparent alias. */
+
+static inline tree
+ultimate_transparent_alias_target (tree alias)
+{
+ tree target = alias;
+
+ while (IDENTIFIER_TRANSPARENT_ALIAS (target))
+ {
+ gcc_checking_assert (TREE_CHAIN (target));
+ target = TREE_CHAIN (target);
+ }
+ gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
+ && ! TREE_CHAIN (target));
+
+ return target;
+}
+
+
/* Hash asmnames ignoring the user specified marks. */
hashval_t
return htab_hash_string (IDENTIFIER_POINTER (asmname));
}
+/* Return true if assembler names NAME1 and NAME2 leads to the same symbol
+ name. */
+
+bool
+symbol_table::assembler_names_equal_p (const char *name1, const char *name2)
+{
+ if (name1 != name2)
+ {
+ if (name1[0] == '*')
+ {
+ size_t ulp_len = strlen (user_label_prefix);
+
+ name1 ++;
+
+ if (ulp_len == 0)
+ ;
+ else if (strncmp (name1, user_label_prefix, ulp_len) == 0)
+ name1 += ulp_len;
+ else
+ return false;
+ }
+ if (name2[0] == '*')
+ {
+ size_t ulp_len = strlen (user_label_prefix);
+
+ name2 ++;
+
+ if (ulp_len == 0)
+ ;
+ else if (strncmp (name2, user_label_prefix, ulp_len) == 0)
+ name2 += ulp_len;
+ else
+ return false;
+ }
+ return !strcmp (name1, name2);
+ }
+ return true;
+}
/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
const char *decl_str;
const char *asmname_str;
- bool test = false;
if (decl_asmname == asmname)
return true;
decl_str = IDENTIFIER_POINTER (decl_asmname);
asmname_str = IDENTIFIER_POINTER (asmname);
-
-
- /* If the target assembler name was set by the user, things are trickier.
- We have a leading '*' to begin with. After that, it's arguable what
- is the correct thing to do with -fleading-underscore. Arguably, we've
- historically been doing the wrong thing in assemble_alias by always
- printing the leading underscore. Since we're not changing that, make
- sure user_label_prefix follows the '*' before matching. */
- if (decl_str[0] == '*')
- {
- size_t ulp_len = strlen (user_label_prefix);
-
- decl_str ++;
-
- if (ulp_len == 0)
- test = true;
- else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
- decl_str += ulp_len, test=true;
- else
- decl_str --;
- }
- if (asmname_str[0] == '*')
- {
- size_t ulp_len = strlen (user_label_prefix);
-
- asmname_str ++;
-
- if (ulp_len == 0)
- test = true;
- else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
- asmname_str += ulp_len, test=true;
- else
- asmname_str --;
- }
-
- if (!test)
- return false;
- return strcmp (decl_str, asmname_str) == 0;
+ return assembler_names_equal_p (decl_str, asmname_str);
}
insert_to_assembler_name_hash (node, false);
}
-/* Initalize asm name hash unless. */
+/* Initialize asm name hash unless. */
void
symbol_table::symtab_initialize_asm_name_hash (void)
/* 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))
: NULL);
if (node)
unlink_from_assembler_name_hash (node, true);
+
+ 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)
IDENTIFIER_TRANSPARENT_ALIAS (name) = 1;
TREE_CHAIN (name) = alias;
}
+ /* If we change assembler name, also all transparent aliases must
+ be updated. There are three kinds - those having same assembler name,
+ those being renamed in varasm.c and weakref being renamed by the
+ assembler. */
if (node)
- insert_to_assembler_name_hash (node, true);
+ {
+ insert_to_assembler_name_hash (node, true);
+ ipa_ref *ref;
+ for (unsigned i = 0; node->iterate_direct_aliases (i, ref); i++)
+ {
+ struct symtab_node *alias = ref->referring;
+ if (alias->transparent_alias && !alias->weakref
+ && symbol_table::assembler_names_equal_p
+ (old_name, IDENTIFIER_POINTER (
+ DECL_ASSEMBLER_NAME (alias->decl))))
+ change_decl_assembler_name (alias->decl, name);
+ else if (alias->transparent_alias
+ && IDENTIFIER_TRANSPARENT_ALIAS (alias->decl))
+ {
+ gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl))
+ && IDENTIFIER_TRANSPARENT_ALIAS
+ (DECL_ASSEMBLER_NAME (alias->decl)));
+
+ TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl)) =
+ ultimate_transparent_alias_target
+ (DECL_ASSEMBLER_NAME (node->decl));
+ }
+#ifdef ASM_OUTPUT_WEAKREF
+ else gcc_assert (!alias->transparent_alias || alias->weakref);
+#else
+ else gcc_assert (!alias->transparent_alias);
+#endif
+ }
+ gcc_assert (!node->transparent_alias || !node->definition
+ || node->weakref
+ || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
+ || symbol_table::assembler_names_equal_p
+ (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
+ IDENTIFIER_POINTER
+ (DECL_ASSEMBLER_NAME
+ (node->get_alias_target ()->decl))));
+ }
}
}
symtab_node::asm_name () const
{
if (!DECL_ASSEMBLER_NAME_SET_P (decl))
- return lang_hooks.decl_printable_name (decl, 2);
+ return name ();
return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
}
const char *
symtab_node::name () const
{
+ if (!DECL_NAME (decl))
+ {
+ if (DECL_ASSEMBLER_NAME_SET_P (decl))
+ return asm_name ();
+ else
+ return "<unnamed>";
+ }
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
+ REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
of the use. */
ipa_ref *
/* Return ipa reference from this symtab_node to
- REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type
+ REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
of the use and STMT the statement (if it exists). */
ipa_ref *
symtab_node::create_reference (symtab_node *referred_node,
- enum ipa_ref_use use_type, gimple stmt)
+ enum ipa_ref_use use_type, gimple *stmt)
{
ipa_ref *ref = NULL, *ref2 = NULL;
ipa_ref_list *list, *list2;
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);
/* Clone reference REF to this symtab_node and set its stmt to STMT. */
ipa_ref *
-symtab_node::clone_reference (ipa_ref *ref, gimple stmt)
+symtab_node::clone_reference (ipa_ref *ref, gimple *stmt)
{
bool speculative = ref->speculative;
unsigned int stmt_uid = ref->lto_stmt_uid;
ipa_ref *
symtab_node::find_reference (symtab_node *referred_node,
- gimple stmt, unsigned int lto_stmt_uid)
+ gimple *stmt, unsigned int lto_stmt_uid)
{
ipa_ref *r = NULL;
int i;
/* Remove all references that are associated with statement STMT. */
void
-symtab_node::remove_stmt_references (gimple stmt)
+symtab_node::remove_stmt_references (gimple *stmt)
{
ipa_ref *r = NULL;
int i = 0;
}
/* Remove all stmt references in non-speculative references.
- Those are not maintained during inlining & clonning.
+ Those are not maintained during inlining & cloning.
The exception are speculative references that are updated along
with callgraph edges associated with them. */
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, " analyzed");
if (alias)
fprintf (f, " alias");
+ if (transparent_alias)
+ fprintf (f, " transparent_alias");
if (weakref)
fprintf (f, " weakref");
if (cpp_implicit_alias)
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_graphviz (FILE *f)
+{
+ if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
+ cnode->dump_graphviz (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);
}
+void
+symbol_table::dump_graphviz (FILE *f)
+{
+ symtab_node *node;
+ fprintf (f, "digraph symtab {\n");
+ FOR_EACH_SYMBOL (node)
+ node->dump_graphviz (f);
+ fprintf (f, "}\n");
+}
+
+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)
- {
- 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)))
+ if (hashed_node)
{
- 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)
error ("node is alias but not definition");
error_found = true;
}
- if (weakref && !alias)
+ if (weakref && !transparent_alias)
+ {
+ error ("node is weakref but not an transparent_alias");
+ error_found = true;
+ }
+ if (transparent_alias && !alias)
{
- error ("node is weakref but not an alias");
+ error ("node is transparent_alias but not an alias");
error_found = true;
}
if (same_comdat_group)
}
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;
+ }
+ if (transparent_alias && definition && !weakref)
+ {
+ symtab_node *to = get_alias_target ();
+ const char *name1
+ = IDENTIFIER_POINTER (
+ ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl)));
+ const char *name2
+ = IDENTIFIER_POINTER (
+ 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");
+ get_alias_target ()->dump (stderr);
+ error_found = true;
+ }
+ }
+ if (transparent_alias && definition
+ && get_alias_target()->transparent_alias && get_alias_target()->analyzed)
+ {
+ error ("Chained transparent aliases");
get_alias_target ()->dump (stderr);
error_found = true;
}
*entry = node;
else if (!DECL_EXTERNAL (node->decl))
{
- for (s = (*entry)->same_comdat_group; s != NULL && s != node;
+ for (s = (*entry)->same_comdat_group;
+ s != NULL && s != node && s != *entry;
s = s->same_comdat_group)
;
if (!s || s == *entry)
}
}
+#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. */
{
rtx rtl, symbol;
+ if (weakref)
+ {
+ weakref = false;
+ IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) = 0;
+ TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) = NULL_TREE;
+ symtab->change_decl_assembler_name
+ (decl, DECL_ASSEMBLER_NAME (get_alias_target ()->decl));
+ DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
+ DECL_ATTRIBUTES (decl));
+ }
/* Avoid clearing comdat_groups on comdat-local decls. */
- if (TREE_PUBLIC (decl) == 0)
+ else if (TREE_PUBLIC (decl) == 0)
return;
- if (TREE_CODE (decl) == VAR_DECL)
+ /* Localizing a symbol also make all its transparent aliases local. */
+ ipa_ref *ref;
+ for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
+ {
+ struct symtab_node *alias = ref->referring;
+ if (alias->transparent_alias)
+ alias->make_decl_local ();
+ }
+
+ 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;
SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
}
+/* Copy visibility from N.
+ This is useful when THIS becomes a transparent alias of N. */
+
+void
+symtab_node::copy_visibility_from (symtab_node *n)
+{
+ gcc_checking_assert (n->weakref == weakref);
+
+ ipa_ref *ref;
+ for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
+ {
+ struct symtab_node *alias = ref->referring;
+ if (alias->transparent_alias)
+ alias->copy_visibility_from (n);
+ }
+
+ if (VAR_P (decl))
+ {
+ DECL_COMMON (decl) = DECL_COMMON (n->decl);
+ /* ADDRESSABLE flag is not defined for public symbols. */
+ if (TREE_PUBLIC (decl) && !TREE_PUBLIC (n->decl))
+ TREE_ADDRESSABLE (decl) = 1;
+ TREE_STATIC (decl) = TREE_STATIC (n->decl);
+ }
+ else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
+
+ DECL_COMDAT (decl) = DECL_COMDAT (n->decl);
+ DECL_WEAK (decl) = DECL_WEAK (n->decl);
+ DECL_EXTERNAL (decl) = DECL_EXTERNAL (n->decl);
+ DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (n->decl);
+ DECL_VISIBILITY (decl) = DECL_VISIBILITY (n->decl);
+ TREE_PUBLIC (decl) = TREE_PUBLIC (n->decl);
+ DECL_DLLIMPORT_P (decl) = DECL_DLLIMPORT_P (n->decl);
+ resolution = n->resolution;
+ set_comdat_group (n->get_comdat_group ());
+ call_for_symbol_and_aliases (symtab_node::set_section,
+ const_cast<char *>(n->get_section ()), true);
+ externally_visible = n->externally_visible;
+ if (!DECL_RTL_SET_P (decl))
+ return;
+
+ /* Update rtl flags. */
+ make_decl_rtl (decl);
+
+ rtx rtl = DECL_RTL (decl);
+ if (!MEM_P (rtl))
+ return;
+
+ rtx symbol = XEXP (rtl, 0);
+ if (GET_CODE (symbol) != SYMBOL_REF)
+ return;
+
+ SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
+}
+
/* Walk the alias chain to return the symbol NODE is alias of.
If NODE is not an alias, return NODE.
Assumes NODE is known to be alias. */
symtab_node *
-symtab_node::ultimate_alias_target_1 (enum availability *availability)
+symtab_node::ultimate_alias_target_1 (enum availability *availability,
+ symtab_node *ref)
{
- bool weakref_p = false;
+ bool transparent_p = false;
/* To determine visibility of the target, we follow ELF semantic of aliases.
Here alias is an alternative assembler name of a given definition. Its
availability prevails the availability of its target (i.e. static alias of
weak definition is available.
- Weakref is a different animal (and not part of ELF per se). It is just
- alternative name of a given symbol used within one complation unit
- and is translated prior hitting the object file. It inherits the
- visibility of its target (i.e. weakref of non-overwritable definition
- is non-overwritable, while weakref of weak definition is weak).
+ Transparent alias is just alternative name of a given symbol used within
+ one compilation unit and is translated prior hitting the object file. It
+ inherits the visibility of its target.
+ Weakref is a different animal (and noweak definition is weak).
If we ever get into supporting targets with different semantics, a target
hook will be needed here. */
if (availability)
{
- weakref_p = weakref;
- if (!weakref_p)
- *availability = get_availability ();
+ transparent_p = transparent_alias;
+ if (!transparent_p)
+ *availability = get_availability (ref);
else
- *availability = AVAIL_LOCAL;
+ *availability = AVAIL_NOT_AVAILABLE;
}
symtab_node *node = this;
node = node->get_alias_target ();
else
{
- if (!availability)
+ if (!availability || (!transparent_p && node->analyzed))
;
- else if (node->analyzed)
- {
- if (weakref_p)
- {
- enum availability a = node->get_availability ();
- if (a < *availability)
- *availability = a;
- }
- }
+ else if (node->analyzed && !node->transparent_alias)
+ *availability = node->get_availability (ref);
else
*availability = AVAIL_NOT_AVAILABLE;
return node;
}
- if (node && availability && weakref_p)
+ if (node && availability && transparent_p
+ && node->transparent_alias)
{
- enum availability a = node->get_availability ();
- if (a < *availability)
- *availability = a;
- weakref_p = node->weakref;
+ *availability = node->get_availability (ref);
+ transparent_p = false;
}
}
if (availability)
DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
DECL_VISIBILITY (decl) = DECL_VISIBILITY (target->decl);
}
- DECL_VIRTUAL_P (decl) = DECL_VIRTUAL_P (target->decl);
if (TREE_PUBLIC (decl))
{
tree group;
}
/* 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);
}
h->init = priority;
}
-/* Set fialization priority to PRIORITY. */
+/* Set finalization priority to PRIORITY. */
void
cgraph_node::set_fini_priority (priority_type priority)
it returns false. */
bool
-symtab_node::resolve_alias (symtab_node *target)
+symtab_node::resolve_alias (symtab_node *target, bool transparent)
{
symtab_node *n;
definition = true;
alias = true;
analyzed = true;
+ transparent |= transparent_alias;
+ transparent_alias = transparent;
+ if (transparent)
+ while (target->transparent_alias && target->analyzed)
+ target = target->get_alias_target ();
create_reference (target, IPA_REF_ALIAS, NULL);
/* Add alias into the comdat group of its target unless it is already there. */
when renaming symbols. */
alias_target = NULL;
- if (cpp_implicit_alias && symtab->state >= CONSTRUCTION)
+ if (!transparent && cpp_implicit_alias && symtab->state >= CONSTRUCTION)
fixup_same_cpp_alias_visibility (target);
/* If alias has address taken, so does the target. */
if (address_taken)
target->ultimate_alias_target ()->address_taken = true;
- /* All non-weakref aliases of THIS are now in fact aliases of TARGET. */
+ /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
+ If alias is transparent, also all transparent aliases of THIS are now
+ aliases of TARGET.
+ Also merge same comdat group lists. */
ipa_ref *ref;
for (unsigned i = 0; iterate_direct_aliases (i, ref);)
{
struct symtab_node *alias_alias = ref->referring;
- if (!alias_alias->weakref)
+ if (alias_alias->get_comdat_group ())
+ {
+ alias_alias->remove_from_same_comdat_group ();
+ alias_alias->set_comdat_group (NULL);
+ if (target->get_comdat_group ())
+ alias_alias->add_to_same_comdat_group (target);
+ }
+ if (!alias_alias->transparent_alias || transparent)
{
alias_alias->remove_all_references ();
alias_alias->create_reference (target, IPA_REF_ALIAS, NULL);
bool
symtab_node::noninterposable_alias (symtab_node *node, void *data)
{
- if (decl_binds_to_current_def_p (node->decl))
+ if (!node->transparent_alias && decl_binds_to_current_def_p (node->decl))
{
symtab_node *fn = node->ultimate_alias_target ();
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);
symtab_node::get_partitioning_class (void)
{
/* Inline clones are always duplicated.
- This include external delcarations. */
+ This include external declarations. */
cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
if (DECL_ABSTRACT_P (decl))
return SYMBOL_EXTERNAL;
- if (cnode && cnode->global.inlined_to)
+ if (cnode && cnode->inlined_to)
return SYMBOL_DUPLICATE;
- /* Weakref aliases are always duplicated. */
- if (weakref)
- return SYMBOL_DUPLICATE;
+ /* Transparent aliases are always duplicated. */
+ if (transparent_alias)
+ return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL;
/* External declarations are external. */
if (DECL_EXTERNAL (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->resolution != LDPR_UNKNOWN
&& target->resolution != LDPR_UNDEF
+ && !target->can_be_discarded_p ()
&& flag_delete_null_pointer_checks)
return true;
return false;
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))
/* As the last resort, check the resolution info. */
if (resolution != LDPR_UNKNOWN
&& resolution != LDPR_UNDEF
+ && !can_be_discarded_p ()
&& flag_delete_null_pointer_checks)
return true;
return false;
/* Return 0 if symbol is known to have different address than S2,
Return 1 if symbol is known to have same address as S2,
- return 2 otherwise. */
+ return -1 otherwise.
+
+ If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
+ and S2 is going to be accessed. This eliminates the situations when
+ either THIS or S2 is NULL and is useful for comparing bases when deciding
+ about memory aliasing. */
int
-symtab_node::equal_address_to (symtab_node *s2)
+symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
{
enum availability avail1, avail2;
if (this == s2)
return 1;
+ /* Unwind transparent aliases first; those are always equal to their
+ target. */
+ if (this->transparent_alias && this->analyzed)
+ return this->get_alias_target ()->equal_address_to (s2);
+ while (s2->transparent_alias && s2->analyzed)
+ s2 = s2->get_alias_target();
+
+ if (this == s2)
+ return 1;
+
/* For non-interposable aliases, lookup and compare their actual definitions.
Also check if the symbol needs to bind to given definition. */
symtab_node *rs1 = ultimate_alias_target (&avail1);
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
- non-speculative more agressively. */
+ non-speculative more aggressively. */
if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
binds_local1 = true;
if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
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 different. */
- if (!nonzero_address () && !s2->nonzero_address ())
- return 2;
+ /* If both symbols may resolve to NULL, we cannot really prove them
+ different. */
+ if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
+ return -1;
/* Except for NULL, functions and variables never overlap. */
if (TREE_CODE (decl) != TREE_CODE (s2->decl))
/* If one of the symbols is unresolved alias, punt. */
if (rs1->alias || rs2->alias)
- return 2;
+ 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)
}
/* TODO: Alias oracle basically assume that addresses of global variables
- are different unless they are declared as alias of one to another.
- We probably should be consistent and use this fact here, too, and update
- alias oracle to use this predicate. */
+ are different unless they are declared as alias of one to another while
+ the code folding comparisons doesn't.
+ We probably should be consistent and use this fact here, too, but for
+ the moment return false only when we are called from the alias oracle. */
- return 2;
+ return memory_accessed && rs1 != rs2 ? 0 : -1;
}
/* Worker for call_for_symbol_and_aliases. */
return false;
}
-/* Return ture if address of N is possibly compared. */
+/* Return true if address of N is possibly compared. */
static bool
address_matters_1 (symtab_node *n, void *)
return call_for_symbol_and_aliases (address_matters_1, NULL, true);
}
-/* Return ture if symbol's alignment may be increased. */
+/* Return true if symbol's alignment may be increased. */
bool
symtab_node::can_increase_alignment_p (void)
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))
if (DECL_ALIGN (n->decl) < align
&& n->can_increase_alignment_p ())
{
- DECL_ALIGN (n->decl) = align;
+ SET_DECL_ALIGN (n->decl, align);
DECL_USER_ALIGN (n->decl) = 1;
}
return false;
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);
call_for_symbol_and_aliases (get_alignment_1, &align, true);
return align;
}
+
+/* Return symbol used to separate symbol name from suffix. */
+
+char
+symbol_table::symbol_suffix_separator ()
+{
+#ifndef NO_DOT_IN_LABEL
+ return '.';
+#elif !defined NO_DOLLAR_IN_LABEL
+ return '$';
+#else
+ return '_';
+#endif
+}
+
+/* Return true when references to this symbol from REF must bind to current
+ definition in final executable. */
+
+bool
+symtab_node::binds_to_current_def_p (symtab_node *ref)
+{
+ 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. */
+ if (cnode && cnode->inlined_to)
+ return true;
+
+ if (DECL_EXTERNAL (decl))
+ return false;
+
+ gcc_assert (externally_visible);
+
+ if (ref)
+ {
+ cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
+ if (cref)
+ ref = cref->inlined_to;
+ }
+
+ /* If this is a reference from symbol itself and there are no aliases, we
+ may be sure that the symbol was not interposed by something else because
+ the symbol itself would be unreachable otherwise. This is important
+ to optimize recursive functions well.
+
+ This assumption may be broken by inlining: if symbol is interposable
+ but the body is available (i.e. declared inline), inliner may make
+ the body reachable even with interposition. */
+ if (this == ref && !has_aliases_p ()
+ && (!cnode
+ || symtab->state >= IPA_SSA_AFTER_INLINING
+ || get_availability () >= AVAIL_INTERPOSABLE))
+ return true;
+
+
+ /* References within one comdat group are always bound in a group. */
+ if (ref
+ && symtab->state >= IPA_SSA_AFTER_INLINING
+ && get_comdat_group ()
+ && get_comdat_group () == ref->get_comdat_group ())
+ return true;
+
+ 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;
+ if (TREE_CODE (decl) == FUNCTION_DECL && !definition
+ && fndecl_built_in_p (decl))
+ {
+ /* Builtins like those for most math functions have actual implementations
+ in libraries so make sure to output references into the symbol table to
+ make those libraries referenced. Note this is incomplete handling for
+ now and only covers math functions. */
+ if (builtin_with_linkage_p (decl))
+ return true;
+ else
+ return false;
+ }
+
+ /* We have real symbol that should be in symbol table. However try to trim
+ down the references to libraries bit more because linker will otherwise
+ bring unnecessary 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 / gcc.git / blobdiff