+2014-07-24 Martin Liska <mliska@suse.cz>
+
+ * cgraph.h (varpool_node):
+ (availability get_availability (void)):
+ created from cgraph_variable_initializer_availability
+ (inline varpool_node *ultimate_alias_target (availability *availability = NULL)
+ creted from: cgraph_variable_initializer_availability
+ (inline varpool_node *get_alias_target (void)): created from varpool_alias_target
+ (void finalize_named_section_flags (void)):
+ created from varpool_finalize_named_section_flags
+ (bool assemble_decl (void)): created from varpool_assemble_decl
+ (void analyze (void)): created from varpool_analyze_node
+ (bool call_for_node_and_aliases (bool (*callback) (varpool_node *, void *),
+ void *data, bool include_overwritable)): created fromvarpool_for_node_and_aliases
+ (void remove_initializer (void)): created from varpool_remove_initializer
+ (tree get_constructor (void)): created from varpool_get_constructor
+ (bool externally_visible_p (void)): created from varpool_externally_visible_p
+ (bool ctor_useable_for_folding_p (void)): created from varpool_ctor_useable_for_folding_p
+ (inline bool all_refs_explicit_p ()): created from varpool_all_refs_explicit_p
+ (inline bool can_remove_if_no_refs_p (void)): created from varpool_can_remove_if_no_refs
+ (static inline varpool_node *get (const_tree decl)): created from varpool_get_node
+ (static void finalize_decl (tree decl)): created from varpool_finalize_decl
+ (static bool output_variables (void)): created from varpool_output_variables
+ (static varpool_node * create_extra_name_alias (tree alias, tree decl)):
+ created from varpool_extra_name_alias
+ (static varpool_node * create_alias (tree, tree)): created from varpool_create_variable_alias
+ (static void dump_varpool (FILE *f)): created from dump_varpool
+ (static void DEBUG_FUNCTION debug_varpool (void)): created from debug_varpool
+ (static varpool_node *create_empty (void)): created from varpool_create_empty_node
+ (static varpool_node *get_create (tree decl)): created from varpool_node_for_decl
+ (static varpool_node *get_for_asmname (tree asmname)): created from varpool_node_for_asm
+ (void assemble_aliases (void)): created from assemble_aliases
+
2014-07-24 Martin Liska <mliska@suse.cz>
* cgraph.h (symtab_node):
{
/* For static vars if they are known not to be dynamically
initialized, they will be always accessible. */
- varpool_node *vnode = varpool_get_node (inner);
+ varpool_node *vnode = varpool_node::get (inner);
if (vnode && !vnode->dynamically_initialized)
return;
}
fold_convert (const_ptr_type_node, str_cst));
CONSTRUCTOR_APPEND_ELT (vinner, NULL_TREE,
fold_convert (const_ptr_type_node, module_name_cst));
- varpool_node *vnode = varpool_get_node (decl);
+ varpool_node *vnode = varpool_node::get (decl);
int has_dynamic_init = vnode ? vnode->dynamically_initialized : 0;
CONSTRUCTOR_APPEND_ELT (vinner, NULL_TREE,
build_int_cst (uptr, has_dynamic_init));
TREE_CONSTANT (ctor) = 1;
TREE_STATIC (ctor) = 1;
DECL_INITIAL (var) = ctor;
- varpool_finalize_decl (var);
+ varpool_node::finalize_decl (var);
fn = builtin_decl_implicit (BUILT_IN_ASAN_REGISTER_GLOBALS);
tree gcount_tree = build_int_cst (pointer_sized_int_node, gcount);
/* True when symbol corresponds to a definition in current unit.
set via cgraph_finalize_function or varpool_finalize_decl */
unsigned definition : 1;
- /* True when symbol is an alias.
- Set by assemble_alias. */
+ /* True when symbol is an alias.
+ Set by ssemble_alias. */
unsigned alias : 1;
/* True when alias is a weakref. */
unsigned weakref : 1;
/* Set when variable is used from other LTRANS partition. */
unsigned used_from_other_partition : 1;
- /* Set when function is available in the other LTRANS partition.
+ /* Set when function is available in the other LTRANS partition.
During WPA output it is used to mark nodes that are present in
multiple partitions. */
unsigned in_other_partition : 1;
class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node {
public:
+ /* Dump given varpool node to F. */
+ void dump (FILE *f);
+
+ /* Dump given varpool node to stderr. */
+ void DEBUG_FUNCTION debug (void);
+
+ /* Remove variable from symbol table. */
+ void remove (void);
+
+ /* Remove node initializer when it is no longer needed. */
+ void remove_initializer (void);
+
+ void analyze (void);
+
+ /* Return variable availability. */
+ availability get_availability (void);
+
+ /* When doing LTO, read variable's constructor from disk if
+ it is not already present. */
+ tree get_constructor (void);
+
+ /* Return true if variable has constructor that can be used for folding. */
+ bool ctor_useable_for_folding_p (void);
+
+ /* For given variable pool node, walk the alias chain to return the function
+ the variable is alias of. Do not walk through thunks.
+ When AVAILABILITY is non-NULL, get minimal availability in the chain. */
+ inline varpool_node *ultimate_alias_target
+ (availability *availability = NULL);
+
+ /* Return node that alias is aliasing. */
+ inline varpool_node *get_alias_target (void);
+
+ /* Output one variable, if necessary. Return whether we output it. */
+ bool assemble_decl (void);
+
+ /* For variables in named sections make sure get_variable_section
+ is called before we switch to those sections. Then section
+ conflicts between read-only and read-only requiring relocations
+ sections can be resolved. */
+ void finalize_named_section_flags (void);
+
+ /* Call calback on varpool symbol and aliases associated to varpool symbol.
+ When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
+ skipped. */
+ bool call_for_node_and_aliases (bool (*callback) (varpool_node *, void *),
+ void *data,
+ bool include_overwritable);
+
+ /* Return true when variable should be considered externally visible. */
+ bool externally_visible_p (void);
+
+ /* Return true when all references to variable must be visible
+ in ipa_ref_list.
+ i.e. if the variable is not externally visible or not used in some magic
+ way (asm statement or such).
+ The magic uses are all summarized in force_output flag. */
+ inline bool all_refs_explicit_p ();
+
+ /* Return true when variable can be removed from variable pool
+ if all direct calls are eliminated. */
+ inline bool can_remove_if_no_refs_p (void);
+
+ /* Return varpool node for given symbol and check it is a function. */
+ static inline varpool_node *get (const_tree decl);
+
+ /* Mark DECL as finalized. By finalizing the declaration, frontend instruct
+ the middle end to output the variable to asm file, if needed or externally
+ visible. */
+ static void finalize_decl (tree decl);
+
+ /* Output all variables enqueued to be assembled. */
+ static bool output_variables (void);
+
+ /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
+ Extra name aliases are output whenever DECL is output. */
+ static varpool_node * create_extra_name_alias (tree alias, tree decl);
+
+ /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
+ Extra name aliases are output whenever DECL is output. */
+ static varpool_node * create_alias (tree, tree);
+
+ /* Dump the variable pool to F. */
+ static void dump_varpool (FILE *f);
+
+ /* Dump the variable pool to stderr. */
+ static void DEBUG_FUNCTION debug_varpool (void);
+
+ /* Allocate new callgraph node and insert it into basic data structures. */
+ static varpool_node *create_empty (void);
+
+ /* Return varpool node assigned to DECL. Create new one when needed. */
+ static varpool_node *get_create (tree decl);
+
+ /* Given an assembler name, lookup node. */
+ static varpool_node *get_for_asmname (tree asmname);
+
/* Set when variable is scheduled to be assembled. */
unsigned output : 1;
if we did not do any inter-procedural code movement. */
unsigned used_by_single_function : 1;
- /* Dump given cgraph node to F. */
- void dump (FILE *f);
-
- /* Remove variable from symbol table. */
- void remove (void);
+private:
+ /* Assemble thunks and aliases associated to varpool node. */
+ void assemble_aliases (void);
};
/* Every top level asm statement is put into a asm_node. */
void debug_varpool_node_set (varpool_node_set);
void free_varpool_node_set (varpool_node_set);
void ipa_discover_readonly_nonaddressable_vars (void);
-bool varpool_externally_visible_p (varpool_node *);
/* In predict.c */
bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
/* In varpool.c */
-varpool_node *varpool_create_empty_node (void);
-varpool_node *varpool_node_for_decl (tree);
-varpool_node *varpool_node_for_asm (tree asmname);
-void varpool_mark_needed_node (varpool_node *);
-void debug_varpool (void);
-void dump_varpool (FILE *);
-
-void varpool_finalize_decl (tree);
-enum availability cgraph_variable_initializer_availability (varpool_node *);
-
-void varpool_finalize_named_section_flags (varpool_node *node);
-bool varpool_output_variables (void);
-bool varpool_assemble_decl (varpool_node *node);
-void varpool_analyze_node (varpool_node *);
-varpool_node * varpool_extra_name_alias (tree, tree);
-varpool_node * varpool_create_variable_alias (tree, tree);
void varpool_reset_queue (void);
-bool varpool_ctor_useable_for_folding_p (varpool_node *);
tree ctor_for_folding (tree);
-bool varpool_for_node_and_aliases (varpool_node *,
- bool (*) (varpool_node *, void *),
- void *, bool);
void varpool_add_new_variable (tree);
void symtab_initialize_asm_name_hash (void);
void symtab_prevail_in_asm_name_hash (symtab_node *node);
-void varpool_remove_initializer (varpool_node *);
-tree varpool_get_constructor (struct varpool_node *node);
/* In cgraph.c */
extern void change_decl_assembler_name (tree, tree);
}
/* Return varpool node for given symbol and check it is a function. */
-static inline varpool_node *
-varpool_get_node (const_tree decl)
+inline varpool_node *
+varpool_node::get (const_tree decl)
{
gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
return dyn_cast<varpool_node *> (symtab_node::get (decl));
&& !externally_visible);
}
-/* Return true when function NODE can be removed from callgraph
+/* Return true when variable can be removed from variable pool
if all direct calls are eliminated. */
-static inline bool
-varpool_can_remove_if_no_refs (varpool_node *node)
+inline bool
+varpool_node::can_remove_if_no_refs_p (void)
{
- if (DECL_EXTERNAL (node->decl))
+ if (DECL_EXTERNAL (decl))
return true;
- return (!node->force_output && !node->used_from_other_partition
- && ((DECL_COMDAT (node->decl)
- && !node->forced_by_abi
- && !node->used_from_object_file_p ())
- || !node->externally_visible
- || DECL_HAS_VALUE_EXPR_P (node->decl)));
+ return (!force_output && !used_from_other_partition
+ && ((DECL_COMDAT (decl)
+ && !forced_by_abi
+ && !used_from_object_file_p ())
+ || !externally_visible
+ || DECL_HAS_VALUE_EXPR_P (decl)));
}
-/* Return true when all references to VNODE must be visible in ipa_ref_list.
+/* Return true when all references to variable must be visible in ipa_ref_list.
i.e. if the variable is not externally visible or not used in some magic
way (asm statement or such).
The magic uses are all summarized in force_output flag. */
-static inline bool
-varpool_all_refs_explicit_p (varpool_node *vnode)
+inline bool
+varpool_node::all_refs_explicit_p ()
{
- return (vnode->definition
- && !vnode->externally_visible
- && !vnode->used_from_other_partition
- && !vnode->force_output);
+ return (definition
+ && !externally_visible
+ && !used_from_other_partition
+ && !force_output);
}
/* Constant pool accessor function. */
return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
}
-static inline varpool_node *
-varpool_alias_target (varpool_node *n)
+/* Return node that alias is aliasing. */
+
+inline varpool_node *
+varpool_node::get_alias_target (void)
{
- return dyn_cast <varpool_node *> (n->get_alias_target ());
+ return dyn_cast <varpool_node *> (symtab_node::get_alias_target ());
}
/* Given function symbol, walk the alias chain to return the function node
*availability = AVAIL_NOT_AVAILABLE;
return n;
}
-/* Given NODE, walk the alias chain to return the function NODE is alias of.
- Do not walk through thunks.
+
+/* For given variable pool node, walk the alias chain to return the function
+ the variable is alias of. Do not walk through thunks.
When AVAILABILITY is non-NULL, get minimal availability in the chain. */
-static inline varpool_node *
-varpool_variable_node (varpool_node *node,
- enum availability *availability = NULL)
+inline varpool_node *
+varpool_node::ultimate_alias_target (availability *availability)
{
- varpool_node *n;
-
- if (node)
- n = dyn_cast <varpool_node *> (node->ultimate_alias_target (availability));
- else
- n = NULL;
+ varpool_node *n = dyn_cast <varpool_node *>
+ (symtab_node::ultimate_alias_target (availability));
if (!n && availability)
*availability = AVAIL_NOT_AVAILABLE;
if (TREE_CODE (decl) == VAR_DECL)
{
- varpool_node *vnode = varpool_node_for_decl (decl);
+ varpool_node *vnode = varpool_node::get_create (decl);
ctx->varpool_node->add_reference (vnode, IPA_REF_ADDR);
}
*walk_subtrees = 0;
type = TREE_OPERAND (type, 0);
if (TREE_CODE (type) == VAR_DECL)
{
- varpool_node *vnode = varpool_node_for_decl (type);
+ varpool_node *vnode = varpool_node::get_create (type);
node->add_reference (vnode, IPA_REF_ADDR);
}
}
else if (addr && TREE_CODE (addr) == VAR_DECL
&& (TREE_STATIC (addr) || DECL_EXTERNAL (addr)))
{
- varpool_node *vnode = varpool_node_for_decl (addr);
+ varpool_node *vnode = varpool_node::get_create (addr);
((symtab_node *)data)->add_reference (vnode, IPA_REF_ADDR, stmt);
}
else if (t && TREE_CODE (t) == VAR_DECL
&& (TREE_STATIC (t) || DECL_EXTERNAL (t)))
{
- varpool_node *vnode = varpool_node_for_decl (t);
+ varpool_node *vnode = varpool_node::get_create (t);
((symtab_node *)data)->add_reference (vnode, IPA_REF_LOAD, stmt);
}
if (t && TREE_CODE (t) == VAR_DECL
&& (TREE_STATIC (t) || DECL_EXTERNAL (t)))
{
- varpool_node *vnode = varpool_node_for_decl (t);
+ varpool_node *vnode = varpool_node::get_create (t);
((symtab_node *)data)->add_reference (vnode, IPA_REF_STORE, stmt);
}
if (TREE_CODE (decl) == VAR_DECL
&& (TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
&& !DECL_HAS_VALUE_EXPR_P (decl))
- varpool_finalize_decl (decl);
+ varpool_node::finalize_decl (decl);
record_eh_tables (node, fun);
pointer_set_destroy (visited_nodes);
record_references_in_initializer (tree decl, bool only_vars)
{
struct pointer_set_t *visited_nodes = pointer_set_create ();
- varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node::get_create (decl);
struct record_reference_ctx ctx = {false, NULL};
ctx.varpool_node = node;
if (node->cpp_implicit_alias && !node->analyzed)
node->resolve_alias
(TREE_CODE (node->alias_target) == VAR_DECL
- ? (symtab_node *)varpool_node_for_decl (node->alias_target)
+ ? (symtab_node *)varpool_node::get_create (node->alias_target)
: (symtab_node *)cgraph_node::get_create (node->alias_target));
cpp_implicit_aliases_done = true;
}
tree decl = vnode->decl;
if (DECL_EXTERNAL (decl)
&& DECL_INITIAL (decl))
- varpool_finalize_decl (decl);
+ varpool_node::finalize_decl (decl);
if (DECL_PRESERVE_P (decl))
vnode->force_output = true;
else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
visible. */
void
-varpool_finalize_decl (tree decl)
+varpool_node::finalize_decl (tree decl)
{
- varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node::get_create (decl);
gcc_assert (TREE_STATIC (decl) || DECL_EXTERNAL (decl));
|| referred_to_p (node)))
enqueue_node (node);
if (cgraph_state >= CGRAPH_STATE_IPA_SSA)
- varpool_analyze_node (node);
+ node->analyze ();
/* Some frontends produce various interface variables after compilation
finished. */
if (cgraph_state == CGRAPH_STATE_FINISHED
|| (!flag_toplevel_reorder && cgraph_state == CGRAPH_STATE_EXPANSION))
- varpool_assemble_decl (node);
+ node->assemble_decl ();
}
/* EDGE is an polymorphic call. Mark all possible targets as reachable
{
varpool_node *vnode = dyn_cast <varpool_node *> (node);
if (vnode && vnode->definition && !vnode->analyzed)
- varpool_analyze_node (vnode);
+ vnode->analyze ();
}
if (node->same_comdat_group)
else if (TREE_CODE (p->decl) == VAR_DECL
&& target_node && is_a <varpool_node *> (target_node))
{
- varpool_create_variable_alias (p->decl, target_node->decl);
+ varpool_node::create_alias (p->decl, target_node->decl);
alias_pairs->unordered_remove (i);
}
else
for (i = 0; i < max; ++i)
if (nodes[i].kind == ORDER_VAR)
- varpool_finalize_named_section_flags (nodes[i].u.v);
+ nodes[i].u.v->finalize_named_section_flags ();
for (i = 0; i < max; ++i)
{
break;
case ORDER_VAR:
- varpool_assemble_decl (nodes[i].u.v);
+ nodes[i].u.v->assemble_decl ();
break;
case ORDER_ASM:
output_asm_statements ();
expand_all_functions ();
- varpool_output_variables ();
+ varpool_node::output_variables ();
}
cgraph_process_new_functions ();
TREE_TYPE (var) = array_type;
DECL_SIZE (var) = TYPE_SIZE (array_type);
DECL_SIZE_UNIT (var) = TYPE_SIZE_UNIT (array_type);
- varpool_finalize_decl (var);
+ varpool_node::finalize_decl (var);
}
fn_b_ctrs[i] = fn_n_ctrs[i] = 0;
tree var = build_var (fn, gcov_fn_info_type, -1);
DECL_INITIAL (var) = init;
- varpool_finalize_decl (var);
+ varpool_node::finalize_decl (var);
CONSTRUCTOR_APPEND_ELT (ctor, NULL,
build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var));
ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1);
DECL_NAME (fn_info_ary) = get_identifier (name_buf);
DECL_INITIAL (fn_info_ary) = build_constructor (fn_info_ary_type, ctor);
- varpool_finalize_decl (fn_info_ary);
+ varpool_node::finalize_decl (fn_info_ary);
DECL_INITIAL (gcov_info_var)
= build_info (TREE_TYPE (gcov_info_var), fn_info_ary);
- varpool_finalize_decl (gcov_info_var);
+ varpool_node::finalize_decl (gcov_info_var);
}
/* Perform file-level initialization. Read in data file, generate name
if (TREE_CODE (olddecl) == FUNCTION_DECL)
symbol = cgraph_node::get_create (newdecl);
else
- symbol = varpool_node_for_decl (newdecl);
+ symbol = varpool_node::get_create (newdecl);
symbol->set_comdat_group (symtab_node::get
(olddecl)->get_comdat_group ());
}
if (VAR_P (decl))
{
- varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node::get_create (decl);
DECL_COMDAT (decl) = 1;
/* Mark it needed so we don't forget to emit it. */
node->forced_by_abi = true;
static bool
var_finalized_p (tree var)
{
- return varpool_node_for_decl (var)->definition;
+ return varpool_node::get_create (var)->definition;
}
/* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
}
else if (TREE_CODE (decl) == VAR_DECL)
{
- varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node::get_create (decl);
/* C++ frontend use mark_decl_references to force COMDAT variables
to be output that might appear dead otherwise. */
node->forced_by_abi = true;
TREE_ASM_WRITTEN (vtbl) = 1;
else if (DECL_ONE_ONLY (vtbl))
{
- current = varpool_node_for_decl (vtbl);
+ current = varpool_node::get_create (vtbl);
if (last)
current->add_to_same_comdat_group (last);
last = current;
finish_expr_stmt (init);
if (flag_sanitize & SANITIZE_ADDRESS)
{
- varpool_node *vnode = varpool_get_node (decl);
+ varpool_node *vnode = varpool_node::get (decl);
if (vnode)
vnode->dynamically_initialized = 1;
}
n->create_same_body_alias (alias, decl);
}
else
- varpool_extra_name_alias (alias, decl);
+ varpool_node::create_extra_name_alias (alias, decl);
#endif
}
}
TREE_STATIC (initial) = 1;
DECL_INITIAL (array_arg) = initial;
relayout_decl (array_arg);
- varpool_finalize_decl (array_arg);
+ varpool_node::finalize_decl (array_arg);
arg3 = build1 (ADDR_EXPR, TYPE_POINTER_TO (TREE_TYPE (array_arg)), array_arg);
comdat_linkage (var_decl);
- varpool_finalize_decl (var_decl);
+ varpool_node::finalize_decl (var_decl);
if (!vtable_map_node)
vtable_map_node =
find_or_create_vtbl_map_node (TYPE_MAIN_VARIANT (base_type));
/* If this is a var that might not be actually output,
return NULL, otherwise stabs might reference an undefined
symbol. */
- varpool_node *node = varpool_get_node (expr);
+ varpool_node *node = varpool_node::get (expr);
if (!node || !node->definition)
return NULL;
}
return *tp;
else if (TREE_CODE (*tp) == VAR_DECL)
{
- varpool_node *node = varpool_get_node (*tp);
+ varpool_node *node = varpool_node::get (*tp);
if (!node || !node->definition)
return *tp;
}
{
/* Ask cgraph if the global variable really is to be emitted.
If yes, then we'll keep the DIE of ENTRY->TYPE. */
- varpool_node *node = varpool_get_node (entry->var_decl);
+ varpool_node *node = varpool_node::get (entry->var_decl);
if (node && node->definition)
{
die->die_perennial_p = 1;
if (!from_decl
|| TREE_CODE (from_decl) != VAR_DECL
|| (!DECL_EXTERNAL (from_decl)
- && (vnode = varpool_get_node (from_decl)) != NULL
+ && (vnode = varpool_node::get (from_decl)) != NULL
&& vnode->definition)
|| (flag_ltrans
- && (vnode = varpool_get_node (from_decl)) != NULL
+ && (vnode = varpool_node::get (from_decl)) != NULL
&& vnode->in_other_partition))
return true;
/* We are folding reference from external vtable. The vtable may reffer
vtable = BINFO_VTABLE (TYPE_BINFO (t));
if (TREE_CODE (vtable) == POINTER_PLUS_EXPR)
vtable = TREE_OPERAND (TREE_OPERAND (vtable, 0), 0);
- vnode = varpool_get_node (vtable);
+ vnode = varpool_node::get (vtable);
return vnode && vnode->definition;
}
if (TREE_CODE (vtable) == POINTER_PLUS_EXPR)
vtable = TREE_OPERAND (TREE_OPERAND (vtable, 0), 0);
- vnode = varpool_get_node (vtable);
+ vnode = varpool_node::get (vtable);
if (!vnode || !vnode->definition)
return;
}
return false;
}
-/* Return true when variable VNODE should be considered externally visible. */
+/* Return true when variable should be considered externally visible. */
bool
-varpool_externally_visible_p (varpool_node *vnode)
+varpool_node::externally_visible_p (void)
{
- if (DECL_EXTERNAL (vnode->decl))
+ if (DECL_EXTERNAL (decl))
return true;
- if (!TREE_PUBLIC (vnode->decl))
+ if (!TREE_PUBLIC (decl))
return false;
/* If linker counts on us, we must preserve the function. */
- if (vnode->used_from_object_file_p ())
+ if (used_from_object_file_p ())
return true;
- if (DECL_HARD_REGISTER (vnode->decl))
+ if (DECL_HARD_REGISTER (decl))
return true;
- if (DECL_PRESERVE_P (vnode->decl))
+ if (DECL_PRESERVE_P (decl))
return true;
if (lookup_attribute ("externally_visible",
- DECL_ATTRIBUTES (vnode->decl)))
+ DECL_ATTRIBUTES (decl)))
return true;
if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
&& lookup_attribute ("dllexport",
- DECL_ATTRIBUTES (vnode->decl)))
+ DECL_ATTRIBUTES (decl)))
return true;
/* See if we have linker information about symbol not being used or
Even if the linker clams the symbol is unused, never bring internal
symbols that are declared by user as used or externally visible.
This is needed for i.e. references from asm statements. */
- if (vnode->used_from_object_file_p ())
+ if (used_from_object_file_p ())
return true;
- if (vnode->resolution == LDPR_PREVAILING_DEF_IRONLY)
+ if (resolution == LDPR_PREVAILING_DEF_IRONLY)
return false;
/* As a special case, the COMDAT virtual tables can be unshared.
is faster for dynamic linking. Also this match logic hidding vtables
from LTO symbol tables. */
if ((in_lto_p || flag_whole_program)
- && DECL_COMDAT (vnode->decl)
- && comdat_can_be_unshared_p (vnode))
+ && DECL_COMDAT (decl)
+ && comdat_can_be_unshared_p (this))
return false;
/* When doing link time optimizations, hidden symbols become local. */
if (in_lto_p
- && (DECL_VISIBILITY (vnode->decl) == VISIBILITY_HIDDEN
- || DECL_VISIBILITY (vnode->decl) == VISIBILITY_INTERNAL)
+ && (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN
+ || DECL_VISIBILITY (decl) == VISIBILITY_INTERNAL)
/* Be sure that node is defined in IR file, not in other object
file. In that case we don't set used_from_other_object_file. */
- && vnode->definition)
+ && definition)
;
else if (!flag_whole_program)
return true;
FIXME: We can do so for readonly vars with no address taken and
possibly also for vtables since no direct pointer comparsion is done.
It might be interesting to do so to reduce linking overhead. */
- if (DECL_COMDAT (vnode->decl) || DECL_WEAK (vnode->decl))
+ if (DECL_COMDAT (decl) || DECL_WEAK (decl))
return true;
return false;
}
{
if (!vnode->definition)
continue;
- if (varpool_externally_visible_p (vnode))
+ if (vnode->externally_visible_p ())
vnode->externally_visible = true;
else
{
{
struct pointer_set_t *visited_nodes = pointer_set_create ();
- varpool_get_constructor (vnode);
+ vnode->get_constructor ();
walk_tree (&DECL_INITIAL (vnode->decl),
update_vtable_references, NULL, visited_nodes);
pointer_set_destroy (visited_nodes);
/* Mark variables that are obviously needed. */
FOR_EACH_DEFINED_VARIABLE (vnode)
- if (!varpool_can_remove_if_no_refs (vnode)
+ if (!vnode->can_remove_if_no_refs_p()
&& !vnode->in_other_partition)
{
pointer_set_insert (reachable, vnode);
/* Keep body if it may be useful for constant folding. */
if ((init = ctor_for_folding (vnode->decl)) == error_mark_node)
- varpool_remove_initializer (vnode);
+ vnode->remove_initializer ();
else
DECL_INITIAL (vnode->decl) = init;
vnode->remove_all_references ();
int i;
struct ipa_ref *ref;
- if (!varpool_all_refs_explicit_p (vnode)
+ if (!vnode->all_refs_explicit_p ()
|| TREE_THIS_VOLATILE (vnode->decl))
*explicit_refs = false;
{
if (TREE_ADDRESSABLE (vnode->decl) && dump_file)
fprintf (dump_file, " %s (non-addressable)", vnode->name ());
- varpool_for_node_and_aliases (vnode, clear_addressable_bit, NULL, true);
+ vnode->call_for_node_and_aliases (clear_addressable_bit, NULL, true);
}
if (!address_taken && !written
/* Making variable in explicit section readonly can cause section
{
if (!TREE_READONLY (vnode->decl) && dump_file)
fprintf (dump_file, " %s (read-only)", vnode->name ());
- varpool_for_node_and_aliases (vnode, set_readonly_bit, NULL, true);
+ vnode->call_for_node_and_aliases (set_readonly_bit, NULL, true);
}
if (!vnode->writeonly && !read && !address_taken && written)
{
if (dump_file)
fprintf (dump_file, " %s (write-only)", vnode->name ());
- varpool_for_node_and_aliases (vnode, set_writeonly_bit, NULL, true);
+ vnode->call_for_node_and_aliases (set_writeonly_bit, NULL, true);
}
}
if (dump_file)
/* If node is an alias, first meet with its target. */
if (vnode->alias)
- function = meet (function, varpool_alias_target (vnode), single_user_map);
+ function = meet (function, vnode->get_alias_target (), single_user_map);
/* Check all users and see if they correspond to a single function. */
for (i = 0; vnode->iterate_referring (i, ref) && function != BOTTOM; i++)
hash_map<varpool_node *, cgraph_node *> single_user_map;
FOR_EACH_DEFINED_VARIABLE (var)
- if (!varpool_all_refs_explicit_p (var))
+ if (!var->all_refs_explicit_p ())
var->aux = BOTTOM;
else
{
layout_decl (decl, 0);
pushdecl (decl);
rest_of_decl_compilation (decl, global_bindings_p (), 0);
- varpool_finalize_decl (decl);
+ varpool_node::finalize_decl (decl);
vec_safe_push (resources, decl);
}
if (DECL_ABSTRACT_ORIGIN (vnode->decl))
{
varpool_node *origin_node
- = varpool_get_node (DECL_ABSTRACT_ORIGIN (vnode->decl));
+ = varpool_node::get (DECL_ABSTRACT_ORIGIN (vnode->decl));
lto_set_symtab_encoder_in_partition (encoder, origin_node);
}
}
{
if (!lto_symtab_encoder_encode_initializer_p (encoder,
vnode)
- && varpool_ctor_useable_for_folding_p (vnode))
+ && vnode->ctor_useable_for_folding_p ())
{
lto_set_symtab_encoder_encode_initializer (encoder, vnode);
add_references (encoder, vnode);
/* Declaration of functions can be already merged with a declaration
from other input file. We keep cgraph unmerged until after streaming
of ipa passes is done. Alays forcingly create a fresh node. */
- node = varpool_create_empty_node ();
+ node = varpool_node::create_empty ();
node->decl = var_decl;
node->register_symbol ();
/* Extra section needs about 30 bytes; do not produce it for simple
scalar values. */
if (TREE_CODE (DECL_INITIAL (expr)) == CONSTRUCTOR
- || !(vnode = varpool_get_node (expr))
+ || !(vnode = varpool_node::get (expr))
|| !lto_symtab_encoder_encode_initializer_p (encoder, vnode))
initial = error_mark_node;
}
/* When something is defined, it should have node attached. */
gcc_assert (alias || TREE_CODE (t) != VAR_DECL
- || varpool_get_node (t)->definition);
+ || varpool_node::get (t)->definition);
gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL
|| (cgraph_node::get (t)
&& cgraph_node::get (t)->definition));
Recursively look into the initializers of the constant variable and add
references, too. */
else if (is_a <varpool_node *> (ref->referred)
- && varpool_ctor_useable_for_folding_p
- (dyn_cast <varpool_node *> (ref->referred))
+ && dyn_cast <varpool_node *> (ref->referred)
+ ->ctor_useable_for_folding_p ()
&& !lto_symtab_encoder_in_partition_p (part->encoder, ref->referred))
{
if (!part->initializers_visited)
return cnode;
}
else if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
- return varpool_variable_node (vnode, NULL);
+ return vnode->ultimate_alias_target ();
return node;
}
to be removed. Coupling with objects they refer to only helps to reduce
number of symbols promoted to hidden. */
if (!symbol_partitioned_p (vnode) && flag_toplevel_reorder
- && !varpool_can_remove_if_no_refs (vnode)
+ && !vnode->can_remove_if_no_refs_p ()
&& vnode->get_partitioning_class () == SYMBOL_PARTITION)
add_symbol_to_partition (partition, vnode);
index = lto_symtab_encoder_lookup (partition->encoder,
if (TREE_CODE (t) == VAR_DECL
&& TREE_STATIC (t)
&& !DECL_EXTERNAL (t))
- varpool_finalize_decl (t);
+ varpool_node::finalize_decl (t);
DECL_SAVED_TREE (child_fn) = NULL;
/* We'll create a CFG for child_fn, so no gimple body is needed. */
gimple_set_body (child_fn, NULL);
if (TREE_CODE (t) == VAR_DECL
&& TREE_STATIC (t)
&& !DECL_EXTERNAL (t))
- varpool_finalize_decl (t);
+ varpool_node::finalize_decl (t);
DECL_SAVED_TREE (child_fn) = NULL;
/* We'll create a CFG for child_fn, so no gimple body is needed. */
gimple_set_body (child_fn, NULL);
DECL_COMMON (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
DECL_IGNORED_P (decl) = 1;
- varpool_finalize_decl (decl);
+ varpool_node::finalize_decl (decl);
splay_tree_insert (critical_name_mutexes, (splay_tree_key) name,
(splay_tree_value) decl);
if (in_lto_p && !at_end)
;
else if (finalize && TREE_CODE (decl) != FUNCTION_DECL)
- varpool_finalize_decl (decl);
+ varpool_node::finalize_decl (decl);
}
#ifdef ASM_FINISH_DECLARE_OBJECT
;
else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)
&& TREE_STATIC (decl))
- varpool_node_for_decl (decl);
+ varpool_node::get_create (decl);
}
/* Called after finishing a record, union or enumeral type. */
if (is_a <cgraph_node *> (this))
return dyn_cast <cgraph_node *> (this)->get_availability ();
else
- return cgraph_variable_initializer_availability
- (dyn_cast <varpool_node *> (this));
+ return dyn_cast <varpool_node *> (this)->get_availability ();;
}
{
TREE_READONLY (new_decl) = TREE_READONLY (node->decl);
DECL_INITIAL (new_decl) = error_mark_node;
- new_node = varpool_create_variable_alias (new_decl, node->decl);
+ new_node = varpool_node::create_alias (new_decl, node->decl);
}
new_node->resolve_alias (node);
gcc_assert (decl_binds_to_current_def_p (new_decl)
{
varpool_node *node;
bool needed = true;
- node = varpool_get_node (decl);
+ node = varpool_node::get (decl);
if (!node && flag_ltrans)
needed = false;
/* Perform the same remapping to the comdat group. */
if (DECL_ONE_ONLY (new_decl))
- varpool_get_node (new_decl)->set_comdat_group (tm_mangle (decl_comdat_group_id (old_decl)));
+ varpool_node::get (new_decl)->set_comdat_group
+ (tm_mangle (decl_comdat_group_id (old_decl)));
new_node = cgraph_node::create_same_body_alias (new_decl, info->new_decl);
new_node->tm_clone = true;
/* Perform the same remapping to the comdat group. */
if (DECL_ONE_ONLY (new_decl))
- varpool_get_node (new_decl)->set_comdat_group (tm_mangle (DECL_COMDAT_GROUP (old_decl)));
+ varpool_node::get (new_decl)->set_comdat_group
+ (tm_mangle (DECL_COMDAT_GROUP (old_decl)));
gcc_assert (!old_node->ipa_transforms_to_apply.exists ());
new_node = old_node->create_version_clone (new_decl, vNULL, NULL);
if (TREE_CODE (lhs) == VAR_DECL
&& (TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
- && varpool_get_node (lhs)->writeonly)
+ && varpool_node::get (lhs)->writeonly)
{
unlink_stmt_vdef (stmt);
gsi_remove (&gsi, true);
if (TREE_CODE (lhs) == VAR_DECL
&& (TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
- && varpool_get_node (lhs)->writeonly)
+ && varpool_node::get (lhs)->writeonly)
{
gimple_call_set_lhs (stmt, NULL);
update_stmt (stmt);
varpool_node *node;
if (!DECL_EXTERNAL (expr))
return false;
- node = varpool_variable_node (varpool_get_node (expr), NULL);
+ node = varpool_node::get (expr)->ultimate_alias_target ();
if (node && node->in_other_partition)
return false;
return true;
/* Create varpool node for the new variable and finalize it if it is
not external one. */
if (DECL_EXTERNAL (to))
- varpool_node_for_decl (to);
+ varpool_node::get_create (to);
else
varpool_add_new_variable (to);
return build_fold_addr_expr (to);
/* Create varpool node for the new variable and finalize it if it is
not external one. */
if (DECL_EXTERNAL (to))
- varpool_node_for_decl (to);
+ varpool_node::get_create (to);
else if (!alias_of)
varpool_add_new_variable (to);
else
- varpool_create_variable_alias (to,
- varpool_node_for_asm
- (DECL_ASSEMBLER_NAME (DECL_VALUE_EXPR (alias_of)))->decl);
+ varpool_node::create_alias (to,
+ varpool_node::get_for_asmname
+ (DECL_ASSEMBLER_NAME (DECL_VALUE_EXPR (alias_of)))->decl);
return to;
}
{
varpool_node_set_iterator i;
- i = varpool_node_set_find (tls_vars, varpool_get_node (decl));
+ i = varpool_node_set_find (tls_vars, varpool_node::get (decl));
gcc_assert (i.index != ~0u);
return i.index;
cdecl = new_emutls_decl (var->decl,
var->alias && var->analyzed
- ? varpool_alias_target (var)->decl : NULL);
+ ? var->get_alias_target ()->decl : NULL);
- cvar = varpool_get_node (cdecl);
+ cvar = varpool_node::get (cdecl);
control_vars.quick_push (cvar);
if (!var->alias)
|| DECL_EXTERNAL (var->decl));
varpool_node_set_add (tls_vars, var);
if (var->alias && var->definition)
- varpool_node_set_add (tls_vars, varpool_variable_node (var, NULL));
+ varpool_node_set_add (tls_vars, var->ultimate_alias_target ());
}
/* If we found no TLS variables, then there is no further work to do. */
if (var->alias && !var->analyzed)
any_aliases = true;
else if (!var->alias)
- varpool_for_node_and_aliases (var, create_emultls_var, &ctor_body, true);
+ var->call_for_node_and_aliases (create_emultls_var, &ctor_body, true);
}
/* If there were any aliases, then frob the alias_pairs vector. */
if (targetm.have_tls)
set_decl_tls_model (ic_void_ptr_var, decl_default_tls_model (ic_void_ptr_var));
- varpool_finalize_decl (ic_void_ptr_var);
+ varpool_node::finalize_decl (ic_void_ptr_var);
gcov_type_ptr = build_pointer_type (get_gcov_type ());
/* Workaround for binutils bug 14342. Once it is fixed, remove lto path. */
if (targetm.have_tls)
set_decl_tls_model (ic_gcov_type_ptr_var, decl_default_tls_model (ic_gcov_type_ptr_var));
- varpool_finalize_decl (ic_gcov_type_ptr_var);
+ varpool_node::finalize_decl (ic_gcov_type_ptr_var);
}
/* Create the type and function decls for the interface with gcov. */
if (TREE_CODE (t) == VAR_DECL
&& (TREE_STATIC (t) || DECL_EXTERNAL (t)))
{
- varpool_node *node = varpool_get_node (t);
+ varpool_node *node = varpool_node::get (t);
if (node && node->alias && node->analyzed)
{
- node = varpool_variable_node (node, NULL);
+ node = node->ultimate_alias_target ();
t = node->decl;
}
}
in IPA mode. Else we'd have to parse arbitrary initializers. */
&& !(in_ipa_mode
&& is_global_var (decl)
- && varpool_get_constructor (varpool_get_node (decl))))
+ && varpool_node::get (decl)->get_constructor ()))
{
fieldoff_s *fo = NULL;
bool notokay = false;
for it. */
else
{
- varpool_node *vnode = varpool_get_node (decl);
+ varpool_node *vnode = varpool_node::get (decl);
/* For escaped variables initialize them from nonlocal. */
- if (!varpool_all_refs_explicit_p (vnode))
+ if (!vnode->all_refs_explicit_p ())
make_copy_constraint (vi, nonlocal_id);
/* If this is a global variable with an initializer and we are in
IPA mode generate constraints for it. */
- if (varpool_get_constructor (vnode)
+ if (vnode->get_constructor ()
&& vnode->definition)
{
auto_vec<ce_s> rhsc;
struct constraint_expr lhs, *rhsp;
unsigned i;
- get_constraint_for_rhs (varpool_get_constructor (vnode), &rhsc);
+ get_constraint_for_rhs (vnode->get_constructor (), &rhsc);
lhs.var = vi->id;
lhs.offset = 0;
lhs.type = SCALAR;
process_constraint (new_constraint (lhs, *rhsp));
/* If this is a variable that escapes from the unit
the initializer escapes as well. */
- if (!varpool_all_refs_explicit_p (vnode))
+ if (!vnode->all_refs_explicit_p ())
{
lhs.var = escaped_id;
lhs.offset = 0;
DECL_ARTIFICIAL (decl) = 1;
TREE_CONSTANT (decl) = 1;
TREE_READONLY (decl) = 1;
- varpool_finalize_decl (decl);
+ varpool_node::finalize_decl (decl);
fetch = build4 (ARRAY_REF, value_type, decl, tidx, NULL_TREE,
NULL_TREE);
return;
}
else if (TREE_CODE (node) == VAR_DECL)
- snode = varpool_node_for_decl (node);
+ snode = varpool_node::get_create (node);
else
snode = cgraph_node::get_create (node);
snode->set_section (value);
enum tls_model
decl_tls_model (const_tree node)
{
- struct varpool_node *snode = varpool_get_node (node);
+ struct varpool_node *snode = varpool_node::get (node);
if (!snode)
return TLS_MODEL_NONE;
return snode->tls_model;
if (model == TLS_MODEL_NONE)
{
- vnode = varpool_get_node (node);
+ vnode = varpool_node::get (node);
if (!vnode)
return;
}
else
- vnode = varpool_node_for_decl (node);
+ vnode = varpool_node::get_create (node);
vnode->tls_model = model;
}
return;
}
else if (TREE_CODE (decl) == VAR_DECL)
- snode = varpool_node_for_decl (decl);
+ snode = varpool_node::get_create (decl);
else
snode = cgraph_node::get_create (decl);
snode->set_init_priority (priority);
tree decl = decl_for_type_lookup (type);
/* It is possible that some of the earlier created DECLs were found
- unused, in that case they weren't emitted and varpool_get_node
+ unused, in that case they weren't emitted and varpool_node::get
returns NULL node on them. But now we really need them. Thus,
renew them here. */
- if (decl != NULL_TREE && varpool_get_node (decl))
+ if (decl != NULL_TREE && varpool_node::get (decl))
return build_fold_addr_expr (decl);
tree dtype = ubsan_type_descriptor_type ();
TREE_CONSTANT (ctor) = 1;
TREE_STATIC (ctor) = 1;
DECL_INITIAL (decl) = ctor;
- varpool_finalize_decl (decl);
+ varpool_node::finalize_decl (decl);
/* Save the VAR_DECL into the hash table. */
decl_for_type_insert (type, decl);
TREE_CONSTANT (ctor) = 1;
TREE_STATIC (ctor) = 1;
DECL_INITIAL (var) = ctor;
- varpool_finalize_decl (var);
+ varpool_node::finalize_decl (var);
return var;
}
}
else if (TREE_CODE (decl) == VAR_DECL)
{
- varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node::get_create (decl);
/* C++ frontend use mark_decl_references to force COMDAT variables
to be output that might appear dead otherwise. */
node->force_output = true;
}
decl = SYMBOL_REF_DECL (XEXP (desc->rtl, 0));
- varpool_finalize_decl (decl);
+ varpool_node::finalize_decl (decl);
return decl;
}
\f
if (TREE_CODE (decl) == FUNCTION_DECL)
cgraph_node::get_create (decl)->alias = true;
else
- varpool_node_for_decl (decl)->alias = true;
+ varpool_node::get_create (decl)->alias = true;
/* If the target has already been emitted, we don't have to queue the
alias. This saves a tad of memory. */
TREE_PUBLIC (decl) = 1;
if (TREE_CODE (decl) == VAR_DECL)
- symbol = varpool_node_for_decl (decl);
+ symbol = varpool_node::get_create (decl);
else
symbol = cgraph_node::get_create (decl);
if (TREE_CODE (exp) == VAR_DECL && TREE_PUBLIC (exp)
&& (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
{
- varpool_node *vnode = varpool_get_node (exp);
+ varpool_node *vnode = varpool_node::get (exp);
if (vnode && (resolution_local_p (vnode->resolution) || vnode->in_other_partition))
resolved_locally = true;
if (vnode
if (TREE_CODE (decl) == VAR_DECL
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
{
- varpool_node *vnode = varpool_get_node (decl);
+ varpool_node *vnode = varpool_node::get (decl);
if (vnode
&& vnode->resolution != LDPR_UNKNOWN)
return resolution_to_local_definition_p (vnode->resolution);
/* Allocate new callgraph node and insert it into basic data structures. */
varpool_node *
-varpool_create_empty_node (void)
+varpool_node::create_empty (void)
{
varpool_node *node = ggc_cleared_alloc<varpool_node> ();
node->type = SYMTAB_VARIABLE;
/* Return varpool node assigned to DECL. Create new one when needed. */
varpool_node *
-varpool_node_for_decl (tree decl)
+varpool_node::get_create (tree decl)
{
- varpool_node *node = varpool_get_node (decl);
+ varpool_node *node = varpool_node::get (decl);
gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
if (node)
return node;
- node = varpool_create_empty_node ();
+ node = varpool_node::create_empty ();
node->decl = decl;
node->register_symbol ();
return node;
/* Keep constructor when it may be used for folding. We remove
references to external variables before final compilation. */
else if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node
- && !varpool_ctor_useable_for_folding_p (this))
- varpool_remove_initializer (this);
+ && !ctor_useable_for_folding_p ())
+ remove_initializer ();
ggc_free (this);
}
-/* Renove node initializer when it is no longer needed. */
+/* Remove node initializer when it is no longer needed. */
void
-varpool_remove_initializer (varpool_node *node)
+varpool_node::remove_initializer (void)
{
- if (DECL_INITIAL (node->decl)
- && !DECL_IN_CONSTANT_POOL (node->decl)
+ if (DECL_INITIAL (decl)
+ && !DECL_IN_CONSTANT_POOL (decl)
/* Keep vtables for BINFO folding. */
- && !DECL_VIRTUAL_P (node->decl)
+ && !DECL_VIRTUAL_P (decl)
/* FIXME: http://gcc.gnu.org/PR55395 */
&& debug_info_level == DINFO_LEVEL_NONE
/* When doing declaration merging we have duplicate
the boides, or we will end up remiving
wrong one. */
&& cgraph_state != CGRAPH_LTO_STREAMING)
- DECL_INITIAL (node->decl) = error_mark_node;
+ DECL_INITIAL (decl) = error_mark_node;
}
-/* Dump given cgraph node. */
+/* Dump given varpool node to F. */
void
varpool_node::dump (FILE *f)
{
dump_base (f);
fprintf (f, " Availability: %s\n",
cgraph_function_flags_ready
- ? cgraph_availability_names[cgraph_variable_initializer_availability (this)]
+ ? cgraph_availability_names[get_availability ()]
: "not-ready");
fprintf (f, " Varpool flags:");
if (DECL_INITIAL (decl))
fprintf (f, " used-by-single-function");
if (TREE_READONLY (decl))
fprintf (f, " read-only");
- if (varpool_ctor_useable_for_folding_p (this))
+ if (ctor_useable_for_folding_p ())
fprintf (f, " const-value-known");
if (writeonly)
fprintf (f, " write-only");
fprintf (f, "\n");
}
+
+/* Dump given varpool node to stderr. */
+void varpool_node::debug (void)
+{
+ varpool_node::dump (stderr);
+}
+
/* Dump the variable pool to F. */
void
-dump_varpool (FILE *f)
+varpool_node::dump_varpool (FILE *f)
{
varpool_node *node;
/* Dump the variable pool to stderr. */
DEBUG_FUNCTION void
-debug_varpool (void)
+varpool_node::debug_varpool (void)
{
dump_varpool (stderr);
}
/* Given an assembler name, lookup node. */
varpool_node *
-varpool_node_for_asm (tree asmname)
+varpool_node::get_for_asmname (tree asmname)
{
if (symtab_node *node = symtab_node_for_asm (asmname))
return dyn_cast <varpool_node *> (node);
return NULL;
}
-/* When doing LTO, read NODE's constructor from disk if it is not already present. */
+/* When doing LTO, read variable's constructor from disk if
+ it is not already present. */
tree
-varpool_get_constructor (struct varpool_node *node)
+varpool_node::get_constructor (void)
{
struct lto_file_decl_data *file_data;
const char *data, *name;
size_t len;
- tree decl = node->decl;
- if (DECL_INITIAL (node->decl) != error_mark_node
+ if (DECL_INITIAL (decl) != error_mark_node
|| !in_lto_p)
- return DECL_INITIAL (node->decl);
+ return DECL_INITIAL (decl);
timevar_push (TV_IPA_LTO_CTORS_IN);
- file_data = node->lto_file_data;
+ file_data = lto_file_data;
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
/* We may have renamed the declaration, e.g., a static function. */
file_data->file_name,
name);
- lto_input_variable_constructor (file_data, node, data);
+ lto_input_variable_constructor (file_data, this, data);
lto_stats.num_function_bodies++;
lto_free_section_data (file_data, LTO_section_function_body, name,
data, len);
- lto_free_function_in_decl_state_for_node (node);
+ lto_free_function_in_decl_state_for_node (this);
timevar_pop (TV_IPA_LTO_CTORS_IN);
- return DECL_INITIAL (node->decl);
+ return DECL_INITIAL (decl);
}
-/* Return ture if NODE has constructor that can be used for folding. */
+/* Return true if variable has constructor that can be used for folding. */
bool
-varpool_ctor_useable_for_folding_p (varpool_node *node)
+varpool_node::ctor_useable_for_folding_p (void)
{
- varpool_node *real_node = node;
+ varpool_node *real_node = this;
if (real_node->alias && real_node->definition)
- real_node = varpool_variable_node (node);
+ real_node = ultimate_alias_target ();
- if (TREE_CODE (node->decl) == CONST_DECL
- || DECL_IN_CONSTANT_POOL (node->decl))
+ if (TREE_CODE (decl) == CONST_DECL
+ || DECL_IN_CONSTANT_POOL (decl))
return true;
- if (TREE_THIS_VOLATILE (node->decl))
+ if (TREE_THIS_VOLATILE (decl))
return false;
/* If we do not have a constructor, we can't use it. */
/* Vtables are defined by their types and must match no matter of interposition
rules. */
- if (DECL_VIRTUAL_P (node->decl))
+ if (DECL_VIRTUAL_P (decl))
{
/* The C++ front end creates VAR_DECLs for vtables of typeinfo
classes not defined in the current TU so that it can refer
/* Alias of readonly variable is also readonly, since the variable is stored
in readonly memory. We also accept readonly aliases of non-readonly
locations assuming that user knows what he is asking for. */
- if (!TREE_READONLY (node->decl) && !TREE_READONLY (real_node->decl))
+ if (!TREE_READONLY (decl) && !TREE_READONLY (real_node->decl))
return false;
/* 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 (real_node->decl)
- && (DECL_EXTERNAL (node->decl) || decl_replaceable_p (node->decl)))
+ && (DECL_EXTERNAL (decl) || decl_replaceable_p (decl)))
return false;
/* Variables declared `const' with an initializer are considered
return true;
}
-/* If DECL is constant variable and its initial value is known (so we can
- do constant folding), return its constructor (DECL_INITIAL). This may
- be an expression or NULL when DECL is initialized to 0.
+/* If DECLARATION is constant variable and its initial value is known
+ (so we can do constant folding), return its constructor (DECL_INITIAL).
+ This may be an expression or NULL when DECL is initialized to 0.
Return ERROR_MARK_NODE otherwise.
In LTO this may actually trigger reading the constructor from disk.
gcc_assert (TREE_CODE (decl) == VAR_DECL);
- real_node = node = varpool_get_node (decl);
+ real_node = node = varpool_node::get (decl);
if (node)
{
- real_node = varpool_variable_node (node);
+ real_node = node->ultimate_alias_target ();
real_decl = real_node->decl;
}
else
|| DECL_INITIAL (decl) == error_mark_node);
if (node->weakref)
{
- node = varpool_alias_target (node);
+ node = node->get_alias_target ();
decl = node->decl;
}
}
if ((!DECL_VIRTUAL_P (real_decl)
|| DECL_INITIAL (real_decl) == error_mark_node
|| !DECL_INITIAL (real_decl))
- && (!node || !varpool_ctor_useable_for_folding_p (node)))
+ && (!node || !node->ctor_useable_for_folding_p ()))
return error_mark_node;
/* OK, we can return constructor. See if we need to fetch it from disk
if (DECL_INITIAL (real_decl) != error_mark_node
|| !in_lto_p)
return DECL_INITIAL (real_decl);
- return varpool_get_constructor (real_node);
+ return real_node->get_constructor ();
}
/* Add the variable DECL to the varpool.
varpool_add_new_variable (tree decl)
{
varpool_node *node;
- varpool_finalize_decl (decl);
- node = varpool_node_for_decl (decl);
+ varpool_node::finalize_decl (decl);
+ node = varpool_node::get_create (decl);
varpool_call_variable_insertion_hooks (node);
- if (varpool_externally_visible_p (node))
+ if (node->externally_visible_p ())
node->externally_visible = true;
}
/* Return variable availability. See cgraph.h for description of individual
return values. */
enum availability
-cgraph_variable_initializer_availability (varpool_node *node)
+varpool_node::get_availability (void)
{
- if (!node->definition)
+ if (!definition)
return AVAIL_NOT_AVAILABLE;
- if (!TREE_PUBLIC (node->decl))
+ if (!TREE_PUBLIC (decl))
return AVAIL_AVAILABLE;
- if (DECL_IN_CONSTANT_POOL (node->decl)
- || DECL_VIRTUAL_P (node->decl))
+ if (DECL_IN_CONSTANT_POOL (decl)
+ || DECL_VIRTUAL_P (decl))
return AVAIL_AVAILABLE;
- if (node->alias && node->weakref)
+ if (alias && weakref)
{
enum availability avail;
- cgraph_variable_initializer_availability
- (varpool_variable_node (node, &avail));
+ ultimate_alias_target (&avail)->get_availability ();
return avail;
}
/* If the variable can be overwritten, return OVERWRITABLE. Takes
care of at least one notable extension - the COMDAT variables
used to share template instantiations in C++. */
- if (decl_replaceable_p (node->decl)
- || DECL_EXTERNAL (node->decl))
+ if (decl_replaceable_p (decl)
+ || DECL_EXTERNAL (decl))
return AVAIL_INTERPOSABLE;
return AVAIL_AVAILABLE;
}
void
-varpool_analyze_node (varpool_node *node)
+varpool_node::analyze (void)
{
- tree decl = node->decl;
-
/* When reading back varpool at LTO time, we re-construct the queue in order
to have "needed" list right by inserting all needed nodes into varpool.
We however don't want to re-analyze already analyzed nodes. */
- if (!node->analyzed)
+ if (!analyzed)
{
gcc_assert (!in_lto_p || cgraph_function_flags_ready);
/* Compute the alignment early so function body expanders are
already informed about increased alignment. */
align_variable (decl, 0);
}
- if (node->alias)
- node->resolve_alias (varpool_get_node (node->alias_target));
+ if (alias)
+ resolve_alias (varpool_node::get (alias_target));
else if (DECL_INITIAL (decl))
- record_references_in_initializer (decl, node->analyzed);
- node->analyzed = true;
+ record_references_in_initializer (decl, analyzed);
+ analyzed = true;
}
-/* Assemble thunks and aliases associated to NODE. */
+/* Assemble thunks and aliases associated to varpool node. */
-static void
-assemble_aliases (varpool_node *node)
+void
+varpool_node::assemble_aliases (void)
{
struct ipa_ref *ref;
- FOR_EACH_ALIAS (node, ref)
+ FOR_EACH_ALIAS (this, ref)
{
varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
do_assemble_alias (alias->decl,
- DECL_ASSEMBLER_NAME (node->decl));
- assemble_aliases (alias);
+ DECL_ASSEMBLER_NAME (decl));
+ alias->assemble_aliases ();
}
}
/* Output one variable, if necessary. Return whether we output it. */
bool
-varpool_assemble_decl (varpool_node *node)
+varpool_node::assemble_decl (void)
{
- tree decl = node->decl;
-
/* Aliases are outout when their target is produced or by
output_weakrefs. */
- if (node->alias)
+ if (alias)
return false;
/* Constant pool is output from RTL land when the reference
&& TREE_CODE (decl) == VAR_DECL
&& !DECL_HAS_VALUE_EXPR_P (decl));
- if (!node->in_other_partition
+ if (!in_other_partition
&& !DECL_EXTERNAL (decl))
{
- varpool_get_constructor (node);
+ get_constructor ();
assemble_variable (decl, 0, 1, 0);
gcc_assert (TREE_ASM_WRITTEN (decl));
- gcc_assert (node->definition);
- assemble_aliases (node);
+ gcc_assert (definition);
+ assemble_aliases ();
return true;
}
FOR_EACH_DEFINED_VARIABLE (node)
{
if (node->analyzed
- && (!varpool_can_remove_if_no_refs (node)
+ && (!node->can_remove_if_no_refs_p ()
/* We just expanded all function bodies. See if any of
them needed the variable. */
|| DECL_RTL_SET_P (node->decl)))
if (cgraph_dump_file)
fprintf (cgraph_dump_file, " %s", node->asm_name ());
if (pointer_set_contains (referenced, node))
- varpool_remove_initializer (node);
+ node->remove_initializer ();
else
node->remove ();
}
conflicts between read-only and read-only requiring relocations
sections can be resolved. */
void
-varpool_finalize_named_section_flags (varpool_node *node)
+varpool_node::finalize_named_section_flags (void)
{
- if (!TREE_ASM_WRITTEN (node->decl)
- && !node->alias
- && !node->in_other_partition
- && !DECL_EXTERNAL (node->decl)
- && TREE_CODE (node->decl) == VAR_DECL
- && !DECL_HAS_VALUE_EXPR_P (node->decl)
- && node->get_section ())
- get_variable_section (node->decl, false);
+ if (!TREE_ASM_WRITTEN (decl)
+ && !alias
+ && !in_other_partition
+ && !DECL_EXTERNAL (decl)
+ && TREE_CODE (decl) == VAR_DECL
+ && !DECL_HAS_VALUE_EXPR_P (decl)
+ && get_section ())
+ get_variable_section (decl, false);
}
/* Output all variables enqueued to be assembled. */
bool
-varpool_output_variables (void)
+varpool_node::output_variables (void)
{
bool changed = false;
varpool_node *node;
timevar_push (TV_VAROUT);
FOR_EACH_DEFINED_VARIABLE (node)
- varpool_finalize_named_section_flags (node);
+ node->finalize_named_section_flags ();
FOR_EACH_DEFINED_VARIABLE (node)
- if (varpool_assemble_decl (node))
+ if (node->assemble_decl ())
changed = true;
timevar_pop (TV_VAROUT);
return changed;
DECL_CONTEXT (new_decl) = NULL_TREE;
DECL_ABSTRACT (new_decl) = 0;
lang_hooks.dup_lang_specific_decl (new_decl);
- new_node = varpool_node_for_decl (new_decl);
- varpool_finalize_decl (new_decl);
+ new_node = varpool_node::get_create (new_decl);
+ varpool_node::finalize_decl (new_decl);
return new_node->decl;
}
Extra name aliases are output whenever DECL is output. */
varpool_node *
-varpool_create_variable_alias (tree alias, tree decl)
+varpool_node::create_alias (tree alias, tree decl)
{
varpool_node *alias_node;
gcc_assert (TREE_CODE (decl) == VAR_DECL);
gcc_assert (TREE_CODE (alias) == VAR_DECL);
- alias_node = varpool_node_for_decl (alias);
+ alias_node = varpool_node::get_create (alias);
alias_node->alias = true;
alias_node->definition = true;
alias_node->alias_target = decl;
Extra name aliases are output whenever DECL is output. */
varpool_node *
-varpool_extra_name_alias (tree alias, tree decl)
+varpool_node::create_extra_name_alias (tree alias, tree decl)
{
varpool_node *alias_node;
/* If aliases aren't supported by the assembler, fail. */
return NULL;
#endif
- alias_node = varpool_create_variable_alias (alias, decl);
+ alias_node = varpool_node::create_alias (alias, decl);
alias_node->cpp_implicit_alias = true;
/* Extra name alias mechanizm creates aliases really late
This is unfortunate because they are not going through the
standard channels. Ensure they get output. */
if (cpp_implicit_aliases_done)
- alias_node->resolve_alias (varpool_node_for_decl (decl));
+ alias_node->resolve_alias (varpool_node::get_create (decl));
return alias_node;
}
-/* Call calback on NODE and aliases associated to NODE.
+/* Call calback on varpool symbol and aliases associated to varpool symbol.
When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
skipped. */
bool
-varpool_for_node_and_aliases (varpool_node *node,
- bool (*callback) (varpool_node *, void *),
- void *data,
- bool include_overwritable)
+varpool_node::call_for_node_and_aliases (bool (*callback) (varpool_node *,
+ void *),
+ void *data,
+ bool include_overwritable)
{
struct ipa_ref *ref;
- if (callback (node, data))
+ if (callback (this, data))
return true;
- FOR_EACH_ALIAS (node, ref)
+ FOR_EACH_ALIAS (this, ref)
{
varpool_node *alias = dyn_cast <varpool_node *> (ref->referring);
if (include_overwritable
- || cgraph_variable_initializer_availability (alias) > AVAIL_INTERPOSABLE)
- if (varpool_for_node_and_aliases (alias, callback, data,
- include_overwritable))
+ || alias->get_availability () > AVAIL_INTERPOSABLE)
+ if (alias->call_for_node_and_aliases (callback, data,
+ include_overwritable))
return true;
}
return false;
projects / thirdparty / gcc.git / commitdiff
