+2013-12-06 Oleg Endo <olegendo@gcc.gnu.org>
+
+ * asan.c: Remove struct tags when referring to class varpool_node.
+ * cgraph.h: Likewise.
+ * cgraphbuild.c: Likewise.
+ * cgraphunit.c: Likewise.
+ * dbxout.c: Likewise.
+ * dwarf2out.c: Likewise.
+ * gimple-fold.c: Likewise.
+ * ipa-devirt.c: Likewise.
+ * ipa-ref-inline.h: Likewise.
+ * ipa-ref.h: Likewise.
+ * ipa-reference.c: Likewise.
+ * ipa-utils.c: Likewise.
+ * ipa.c: Likewise.
+ * lto-cgraph.c: Likewise.
+ * lto-streamer-out.c: Likewise.
+ * lto-streamer.h: Likewise.
+ * passes.c: Likewise.
+ * toplev.c: Likewise.
+ * tree-eh.c: Likewise.
+ * tree-emutls.c: Likewise.
+ * tree-pass.h: Likewise.
+ * tree-ssa-structalias.c: Likewise.
+ * tree-vectorizer.c: Likewise.
+ * tree.c: Likewise.
+ * varasm.c: Likewise.
+ * varpool.c: Likewise.
+
2013-12-06 Oleg Endo <olegendo@gcc.gnu.org>
* cgraphunit.c: Remove struct tags when referring to class
{
/* For static vars if they are known not to be dynamically
initialized, they will be always accessible. */
- struct varpool_node *vnode = varpool_get_node (inner);
+ varpool_node *vnode = varpool_get_node (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));
- struct varpool_node *vnode = varpool_get_node (decl);
+ varpool_node *vnode = varpool_get_node (decl);
int has_dynamic_init = vnode ? vnode->dynamically_initialized : 0;
CONSTRUCTOR_APPEND_ELT (vinner, NULL_TREE,
build_int_cst (uptr, has_dynamic_init));
void
asan_finish_file (void)
{
- struct varpool_node *vnode;
+ varpool_node *vnode;
unsigned HOST_WIDE_INT gcount = 0;
if (shadow_ptr_types[0] == NULL_TREE)
vec<cgraph_node_ptr> nodes;
};
-typedef struct varpool_node *varpool_node_ptr;
+class varpool_node;
+typedef varpool_node *varpool_node_ptr;
/* A varpool node set is a collection of varpool nodes. A varpool node
typedef void (*cgraph_edge_hook)(struct cgraph_edge *, void *);
typedef void (*cgraph_node_hook)(struct cgraph_node *, void *);
-typedef void (*varpool_node_hook)(struct varpool_node *, void *);
+typedef void (*varpool_node_hook)(varpool_node *, void *);
typedef void (*cgraph_2edge_hook)(struct cgraph_edge *, struct cgraph_edge *,
void *);
typedef void (*cgraph_2node_hook)(struct cgraph_node *, struct cgraph_node *,
varpool_node_set varpool_node_set_new (void);
varpool_node_set_iterator varpool_node_set_find (varpool_node_set,
- struct varpool_node *);
-void varpool_node_set_add (varpool_node_set, struct varpool_node *);
-void varpool_node_set_remove (varpool_node_set, struct varpool_node *);
+ varpool_node *);
+void varpool_node_set_add (varpool_node_set, varpool_node *);
+void varpool_node_set_remove (varpool_node_set, varpool_node *);
void dump_varpool_node_set (FILE *, varpool_node_set);
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 (struct varpool_node *);
+bool varpool_externally_visible_p (varpool_node *);
/* In predict.c */
bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e);
bool cgraph_optimize_for_size_p (struct cgraph_node *);
/* In varpool.c */
-struct varpool_node *varpool_create_empty_node (void);
-struct varpool_node *varpool_node_for_decl (tree);
-struct varpool_node *varpool_node_for_asm (tree asmname);
-void varpool_mark_needed_node (struct varpool_node *);
+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 dump_varpool_node (FILE *, struct varpool_node *);
+void dump_varpool_node (FILE *, varpool_node *);
void varpool_finalize_decl (tree);
-enum availability cgraph_variable_initializer_availability (struct varpool_node *);
+enum availability cgraph_variable_initializer_availability (varpool_node *);
void cgraph_make_node_local (struct cgraph_node *);
bool cgraph_node_can_be_local_p (struct cgraph_node *);
-void varpool_remove_node (struct varpool_node *node);
-void varpool_finalize_named_section_flags (struct varpool_node *node);
+void varpool_remove_node (varpool_node *node);
+void varpool_finalize_named_section_flags (varpool_node *node);
bool varpool_output_variables (void);
-bool varpool_assemble_decl (struct varpool_node *node);
-void varpool_analyze_node (struct varpool_node *);
-struct varpool_node * varpool_extra_name_alias (tree, tree);
-struct varpool_node * varpool_create_variable_alias (tree, tree);
+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);
tree ctor_for_folding (tree);
-bool varpool_for_node_and_aliases (struct varpool_node *,
- bool (*) (struct varpool_node *, void *),
+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 (struct varpool_node *);
+void varpool_remove_initializer (varpool_node *);
/* In cgraph.c */
extern void change_decl_assembler_name (tree, tree);
}
/* Return varpool node for given symbol and check it is a variable. */
-static inline struct varpool_node *
+static inline varpool_node *
varpool (symtab_node *node)
{
gcc_checking_assert (!node || node->type == SYMTAB_VARIABLE);
- return (struct varpool_node *)node;
+ return (varpool_node *)node;
}
/* Return callgraph node for given symbol and check it is a function. */
}
/* Return varpool node for given symbol and check it is a function. */
-static inline struct varpool_node *
+static inline varpool_node *
varpool_get_node (const_tree decl)
{
gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
/* Return first variable. */
-static inline struct varpool_node *
+static inline varpool_node *
varpool_first_variable (void)
{
symtab_node *node;
}
/* Return next variable after NODE. */
-static inline struct varpool_node *
-varpool_next_variable (struct varpool_node *node)
+static inline varpool_node *
+varpool_next_variable (varpool_node *node)
{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
(node) = varpool_next_variable ((node)))
/* Return first reachable static variable with initializer. */
-static inline struct varpool_node *
+static inline varpool_node *
varpool_first_static_initializer (void)
{
symtab_node *node;
}
/* Return next reachable static variable with initializer after NODE. */
-static inline struct varpool_node *
-varpool_next_static_initializer (struct varpool_node *node)
+static inline varpool_node *
+varpool_next_static_initializer (varpool_node *node)
{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
(node) = varpool_next_static_initializer (node))
/* Return first reachable static variable with initializer. */
-static inline struct varpool_node *
+static inline varpool_node *
varpool_first_defined_variable (void)
{
symtab_node *node;
}
/* Return next reachable static variable with initializer after NODE. */
-static inline struct varpool_node *
-varpool_next_defined_variable (struct varpool_node *node)
+static inline varpool_node *
+varpool_next_defined_variable (varpool_node *node)
{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
}
/* Return the node pointed to by VSI. */
-static inline struct varpool_node *
+static inline varpool_node *
vsi_node (varpool_node_set_iterator vsi)
{
return vsi.set->nodes[vsi.index];
/* Return true if SET contains NODE. */
static inline bool
-varpool_node_in_set_p (struct varpool_node *node, varpool_node_set set)
+varpool_node_in_set_p (varpool_node *node, varpool_node_set set)
{
varpool_node_set_iterator vsi;
vsi = varpool_node_set_find (set, node);
if all direct calls are eliminated. */
static inline bool
-varpool_can_remove_if_no_refs (struct varpool_node *node)
+varpool_can_remove_if_no_refs (varpool_node *node)
{
if (DECL_EXTERNAL (node->decl))
return true;
The magic uses are all summarized in force_output flag. */
static inline bool
-varpool_all_refs_explicit_p (struct varpool_node *vnode)
+varpool_all_refs_explicit_p (varpool_node *vnode)
{
return (vnode->definition
&& !vnode->externally_visible
return dyn_cast <cgraph_node> (symtab_alias_target (n));
}
-static inline struct varpool_node *
-varpool_alias_target (struct varpool_node *n)
+static inline varpool_node *
+varpool_alias_target (varpool_node *n)
{
return dyn_cast <varpool_node> (symtab_alias_target (n));
}
Do not walk through thunks.
When AVAILABILITY is non-NULL, get minimal availability in the chain. */
-static inline struct varpool_node *
-varpool_variable_node (struct varpool_node *node,
+static inline varpool_node *
+varpool_variable_node (varpool_node *node,
enum availability *availability = NULL)
{
- struct varpool_node *n;
+ varpool_node *n;
n = dyn_cast <varpool_node> (symtab_alias_ultimate_target (node,
availability));
struct record_reference_ctx
{
bool only_vars;
- struct varpool_node *varpool_node;
+ class varpool_node *varpool_node;
};
/* Walk tree and record all calls and references to functions/variables.
if (TREE_CODE (decl) == VAR_DECL)
{
- struct varpool_node *vnode = varpool_node_for_decl (decl);
+ varpool_node *vnode = varpool_node_for_decl (decl);
ipa_record_reference (ctx->varpool_node,
vnode,
IPA_REF_ADDR, NULL);
type = TREE_OPERAND (type, 0);
if (TREE_CODE (type) == VAR_DECL)
{
- struct varpool_node *vnode = varpool_node_for_decl (type);
+ varpool_node *vnode = varpool_node_for_decl (type);
ipa_record_reference (node,
vnode,
IPA_REF_ADDR, NULL);
else if (addr && TREE_CODE (addr) == VAR_DECL
&& (TREE_STATIC (addr) || DECL_EXTERNAL (addr)))
{
- struct varpool_node *vnode = varpool_node_for_decl (addr);
+ varpool_node *vnode = varpool_node_for_decl (addr);
ipa_record_reference ((symtab_node *)data,
vnode,
else if (t && TREE_CODE (t) == VAR_DECL
&& (TREE_STATIC (t) || DECL_EXTERNAL (t)))
{
- struct varpool_node *vnode = varpool_node_for_decl (t);
+ varpool_node *vnode = varpool_node_for_decl (t);
ipa_record_reference ((symtab_node *)data,
vnode,
if (t && TREE_CODE (t) == VAR_DECL
&& (TREE_STATIC (t) || DECL_EXTERNAL (t)))
{
- struct varpool_node *vnode = varpool_node_for_decl (t);
+ varpool_node *vnode = varpool_node_for_decl (t);
ipa_record_reference ((symtab_node *)data,
vnode,
record_references_in_initializer (tree decl, bool only_vars)
{
struct pointer_set_t *visited_nodes = pointer_set_create ();
- struct varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node_for_decl (decl);
struct record_reference_ctx ctx = {false, NULL};
ctx.varpool_node = node;
static void
process_function_and_variable_attributes (struct cgraph_node *first,
- struct varpool_node *first_var)
+ varpool_node *first_var)
{
struct cgraph_node *node;
- struct varpool_node *vnode;
+ varpool_node *vnode;
for (node = cgraph_first_function (); node != first;
node = cgraph_next_function (node))
void
varpool_finalize_decl (tree decl)
{
- struct varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node_for_decl (decl);
gcc_assert (TREE_STATIC (decl) || DECL_EXTERNAL (decl));
intermodule optimization. */
static struct cgraph_node *first_analyzed;
struct cgraph_node *first_handled = first_analyzed;
- static struct varpool_node *first_analyzed_var;
- struct varpool_node *first_handled_var = first_analyzed_var;
+ static varpool_node *first_analyzed_var;
+ varpool_node *first_handled_var = first_analyzed_var;
struct pointer_set_t *reachable_call_targets = pointer_set_create ();
symtab_node *node;
union
{
struct cgraph_node *f;
- struct varpool_node *v;
+ varpool_node *v;
struct asm_node *a;
} u;
};
struct cgraph_order_sort *nodes;
int i;
struct cgraph_node *pf;
- struct varpool_node *pv;
+ varpool_node *pv;
struct asm_node *pa;
max = symtab_order;
+2013-12-06 Oleg Endo <olegendo@gcc.gnu.org>
+
+ * decl2.c: Remove struct tags when referring to class varpool_node.
+
2013-12-05 Jason Merrill <jason@redhat.com>
PR c++/59044
if (VAR_P (decl))
{
- struct varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node_for_decl (decl);
DECL_COMDAT (decl) = 1;
/* Mark it needed so we don't forget to emit it. */
node->forced_by_abi = true;
}
else if (TREE_CODE (decl) == VAR_DECL)
{
- struct varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node_for_decl (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 vtbl;
tree primary_vtbl;
int needed = 0;
- struct varpool_node *current = NULL, *last = NULL;
+ varpool_node *current = NULL, *last = NULL;
/* If the vtables for this class have already been emitted there is
nothing more to do. */
finish_expr_stmt (init);
if (flag_sanitize & SANITIZE_ADDRESS)
{
- struct varpool_node *vnode = varpool_get_node (decl);
+ varpool_node *vnode = varpool_get_node (decl);
if (vnode)
vnode->dynamically_initialized = 1;
}
/* If this is a var that might not be actually output,
return NULL, otherwise stabs might reference an undefined
symbol. */
- struct varpool_node *node = varpool_get_node (expr);
+ varpool_node *node = varpool_get_node (expr);
if (!node || !node->definition)
return NULL;
}
return *tp;
else if (TREE_CODE (*tp) == VAR_DECL)
{
- struct varpool_node *node = varpool_get_node (*tp);
+ varpool_node *node = varpool_get_node (*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. */
- struct varpool_node *node = varpool_get_node (entry->var_decl);
+ varpool_node *node = varpool_get_node (entry->var_decl);
if (node && node->definition)
{
die->die_perennial_p = 1;
static bool
can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
{
- struct varpool_node *vnode;
+ varpool_node *vnode;
struct cgraph_node *node;
symtab_node *snode;
if (!flag_ltrans && anonymous)
{
tree vtable = BINFO_VTABLE (inner_binfo);
- struct varpool_node *vnode;
+ varpool_node *vnode;
if (TREE_CODE (vtable) == POINTER_PLUS_EXPR)
vtable = TREE_OPERAND (TREE_OPERAND (vtable, 0), 0);
/* When virtual table is removed, we may need to flush the cache. */
static void
-devirt_variable_node_removal_hook (struct varpool_node *n,
+devirt_variable_node_removal_hook (varpool_node *n,
void *d ATTRIBUTE_UNUSED)
{
if (cached_polymorphic_call_targets
/* Return varpool node REF is referring. */
-static inline struct varpool_node *
+static inline varpool_node *
ipa_ref_varpool_node (struct ipa_ref *ref)
{
return varpool (ref->referred);
/* Return varpool node REF is in. */
-static inline struct varpool_node *
+static inline varpool_node *
ipa_ref_referring_varpool_node (struct ipa_ref *ref)
{
return varpool (ref->referring);
<http://www.gnu.org/licenses/>. */
struct cgraph_node;
-struct varpool_node;
+class varpool_node;
class symtab_node;
propagate (void)
{
struct cgraph_node *node;
- struct varpool_node *vnode;
+ varpool_node *vnode;
struct cgraph_node **order =
XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
int order_pos;
/* Add varpool_node NODE to varpool_node_set SET. */
void
-varpool_node_set_add (varpool_node_set set, struct varpool_node *node)
+varpool_node_set_add (varpool_node_set set, varpool_node *node)
{
void **slot;
/* Remove varpool_node NODE from varpool_node_set SET. */
void
-varpool_node_set_remove (varpool_node_set set, struct varpool_node *node)
+varpool_node_set_remove (varpool_node_set set, varpool_node *node)
{
void **slot, **last_slot;
int index;
- struct varpool_node *last_node;
+ varpool_node *last_node;
slot = pointer_map_contains (set->map, node);
if (slot == NULL || !*slot)
is returned if NODE is not in SET. */
varpool_node_set_iterator
-varpool_node_set_find (varpool_node_set set, struct varpool_node *node)
+varpool_node_set_find (varpool_node_set set, varpool_node *node)
{
void **slot;
varpool_node_set_iterator vsi;
for (iter = vsi_start (set); !vsi_end_p (iter); vsi_next (&iter))
{
- struct varpool_node *node = vsi_node (iter);
+ varpool_node *node = vsi_node (iter);
fprintf (f, " %s", node->name ());
}
fprintf (f, "\n");
{
symtab_node *first = (symtab_node *) (void *) 1;
struct cgraph_node *node, *next;
- struct varpool_node *vnode, *vnext;
+ varpool_node *vnode, *vnext;
bool changed = false;
struct pointer_set_t *reachable = pointer_set_create ();
struct pointer_set_t *body_needed_for_clonning = pointer_set_create ();
void
ipa_discover_readonly_nonaddressable_vars (void)
{
- struct varpool_node *vnode;
+ varpool_node *vnode;
if (dump_file)
fprintf (dump_file, "Clearing variable flags:");
FOR_EACH_VARIABLE (vnode)
i, ref); i++)
if (ref->use == IPA_REF_ADDR)
{
- struct varpool_node *node;
+ varpool_node *node;
if (is_a <cgraph_node> (ref->referring))
return true;
node = ipa_ref_referring_varpool_node (ref);
/* Return true when variable VNODE should be considered externally visible. */
bool
-varpool_externally_visible_p (struct varpool_node *vnode)
+varpool_externally_visible_p (varpool_node *vnode)
{
if (DECL_EXTERNAL (vnode->decl))
return true;
function_and_variable_visibility (bool whole_program)
{
struct cgraph_node *node;
- struct varpool_node *vnode;
+ varpool_node *vnode;
/* All aliases should be procssed at this point. */
gcc_checking_assert (!alias_pairs || !alias_pairs->length ());
bool
lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t encoder,
- struct varpool_node *node)
+ varpool_node *node)
{
int index = lto_symtab_encoder_lookup (encoder, node);
if (index == LCC_NOT_FOUND)
static void
lto_set_symtab_encoder_encode_initializer (lto_symtab_encoder_t encoder,
- struct varpool_node *node)
+ varpool_node *node)
{
int index = lto_symtab_encoder_lookup (encoder, node);
encoder->nodes[index].initializer = true;
If NODE is not in SET, then NODE is a boundary. */
static void
-lto_output_varpool_node (struct lto_simple_output_block *ob, struct varpool_node *node,
+lto_output_varpool_node (struct lto_simple_output_block *ob, varpool_node *node,
lto_symtab_encoder_t encoder)
{
bool boundary_p = !lto_symtab_encoder_in_partition_p (encoder, node);
for (lsei = lsei_start_variable_in_partition (in_encoder);
!lsei_end_p (lsei); lsei_next_variable_in_partition (&lsei))
{
- struct varpool_node *vnode = lsei_varpool_node (lsei);
+ varpool_node *vnode = lsei_varpool_node (lsei);
lto_set_symtab_encoder_in_partition (encoder, vnode);
lto_set_symtab_encoder_encode_initializer (encoder, vnode);
/* For proper debug info, we need to ship the origins, too. */
if (DECL_ABSTRACT_ORIGIN (vnode->decl))
{
- struct varpool_node *origin_node
+ varpool_node *origin_node
= varpool_get_node (DECL_ABSTRACT_ORIGIN (node->decl));
lto_set_symtab_encoder_in_partition (encoder, origin_node);
}
/* Read a node from input_block IB. TAG is the node's tag just read.
Return the node read or overwriten. */
-static struct varpool_node *
+static varpool_node *
input_varpool_node (struct lto_file_decl_data *file_data,
struct lto_input_block *ib)
{
int decl_index;
tree var_decl;
- struct varpool_node *node;
+ varpool_node *node;
struct bitpack_d bp;
int ref = LCC_NOT_FOUND;
int order;
&& initial)
{
lto_symtab_encoder_t encoder;
- struct varpool_node *vnode;
+ varpool_node *vnode;
encoder = ob->decl_state->symtab_node_encoder;
vnode = varpool_get_node (expr);
symtab_node *);
bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t,
- struct varpool_node *);
+ varpool_node *);
void output_symtab (void);
void input_symtab (void);
bool referenced_from_other_partition_p (struct ipa_ref_list *,
}
/* Return the node pointed to by LSI. */
-static inline struct varpool_node *
+static inline varpool_node *
lsei_varpool_node (lto_symtab_encoder_iterator lsei)
{
return varpool (lsei.encoder->nodes[lsei.index].node);
+2013-12-06 Oleg Endo <olegendo@gcc.gnu.org>
+
+ * lto.c: Remove struct tags when referring to class varpool_node.
+ * lto-partition.c: Likewise.
+ * lto-symtab.c: Likewise.
+
2013-11-29 Jakub Jelinek <jakub@redhat.com>
Richard Biener <rguenther@suse.de>
static int
varpool_node_cmp (const void *pa, const void *pb)
{
- const struct varpool_node *a = *(const struct varpool_node * const *) pa;
- const struct varpool_node *b = *(const struct varpool_node * const *) pb;
+ const varpool_node *a = *(const varpool_node * const *) pa;
+ const varpool_node *b = *(const varpool_node * const *) pb;
return b->order - a->order;
}
int n_nodes = 0;
int n_varpool_nodes = 0, varpool_pos = 0, best_varpool_pos = 0;
struct cgraph_node **order = XNEWVEC (struct cgraph_node *, cgraph_max_uid);
- struct varpool_node **varpool_order = NULL;
+ varpool_node **varpool_order = NULL;
int i;
struct cgraph_node *node;
int total_size = 0, best_total_size = 0;
int partition_size;
ltrans_partition partition;
int last_visited_node = 0;
- struct varpool_node *vnode;
+ varpool_node *vnode;
int cost = 0, internal = 0;
int best_n_nodes = 0, best_i = 0, best_cost =
INT_MAX, best_internal = 0;
FOR_EACH_VARIABLE (vnode)
if (get_symbol_class (vnode) == SYMBOL_PARTITION)
n_varpool_nodes++;
- varpool_order = XNEWVEC (struct varpool_node *, n_varpool_nodes);
+ varpool_order = XNEWVEC (varpool_node *, n_varpool_nodes);
n_varpool_nodes = 0;
FOR_EACH_VARIABLE (vnode)
if (get_symbol_class (vnode) == SYMBOL_PARTITION)
varpool_order[n_varpool_nodes++] = vnode;
- qsort (varpool_order, n_varpool_nodes, sizeof (struct varpool_node *),
+ qsort (varpool_order, n_varpool_nodes, sizeof (varpool_node *),
varpool_node_cmp);
}
all edges and removing the old node. */
static void
-lto_varpool_replace_node (struct varpool_node *vnode,
- struct varpool_node *prevailing_node)
+lto_varpool_replace_node (varpool_node *vnode,
+ varpool_node *prevailing_node)
{
gcc_assert (!vnode->definition || prevailing_node->definition);
gcc_assert (!vnode->analyzed || prevailing_node->analyzed);
do_whole_program_analysis ();
else
{
- struct varpool_node *vnode;
+ varpool_node *vnode;
timevar_start (TV_PHASE_OPT_GEN);
{
lto_symtab_encoder_t encoder;
int i, order_pos;
- struct varpool_node *vnode;
+ varpool_node *vnode;
struct cgraph_node *node;
struct cgraph_node **order;
if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
{
- struct varpool_node *node;
+ varpool_node *node;
bool needed = true;
node = varpool_get_node (decl);
LTO partition. */
if (DECL_WEAK (expr) && !DECL_COMDAT (expr))
{
- struct varpool_node *node;
+ varpool_node *node;
if (!DECL_EXTERNAL (expr))
return false;
node = varpool_variable_node (varpool_get_node (expr), NULL);
static tree
emutls_decl (tree decl)
{
- struct varpool_node *var;
+ varpool_node *var;
unsigned int i;
i = emutls_index (decl);
addr = access_vars[index];
if (addr == NULL)
{
- struct varpool_node *cvar;
+ varpool_node *cvar;
tree cdecl;
gimple x;
Callback for varpool_for_variable_and_aliases. */
static bool
-create_emultls_var (struct varpool_node *var, void *data)
+create_emultls_var (varpool_node *var, void *data)
{
tree cdecl;
- struct varpool_node *cvar;
+ varpool_node *cvar;
cdecl = new_emutls_decl (var->decl,
var->alias && var->analyzed
static unsigned int
ipa_lower_emutls (void)
{
- struct varpool_node *var;
+ varpool_node *var;
struct cgraph_node *func;
bool any_aliases = false;
tree ctor_body = NULL;
}
};
-struct varpool_node;
+class varpool_node;
struct cgraph_node;
struct lto_symtab_encoder_d;
function body via this hook. */
unsigned int function_transform_todo_flags_start;
unsigned int (*function_transform) (struct cgraph_node *);
- void (*variable_transform) (struct varpool_node *);
+ void (*variable_transform) (varpool_node *);
protected:
ipa_opt_pass_d (const pass_data& data, gcc::context *ctxt,
void (*stmt_fixup) (struct cgraph_node *, gimple *),
unsigned int function_transform_todo_flags_start,
unsigned int (*function_transform) (struct cgraph_node *),
- void (*variable_transform) (struct varpool_node *))
+ void (*variable_transform) (varpool_node *))
: opt_pass (data, ctxt),
generate_summary (generate_summary),
write_summary (write_summary),
if (TREE_CODE (t) == VAR_DECL
&& (TREE_STATIC (t) || DECL_EXTERNAL (t)))
{
- struct varpool_node *node = varpool_get_node (t);
+ varpool_node *node = varpool_get_node (t);
if (node && node->alias && node->analyzed)
{
node = varpool_variable_node (node, NULL);
for it. */
else
{
- struct varpool_node *vnode = varpool_get_node (decl);
+ varpool_node *vnode = varpool_get_node (decl);
/* For escaped variables initialize them from nonlocal. */
if (!varpool_all_refs_explicit_p (vnode))
ipa_pta_execute (void)
{
struct cgraph_node *node;
- struct varpool_node *var;
+ varpool_node *var;
int from;
in_ipa_mode = 1;
static unsigned int
increase_alignment (void)
{
- struct varpool_node *vnode;
+ varpool_node *vnode;
vect_location = UNKNOWN_LOCATION;
NAMESPACE_DECLs, etc). */
static void
-find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld)
+find_decls_types_in_var (varpool_node *v, struct free_lang_data_d *fld)
{
find_decls_types (v->decl, fld);
}
free_lang_data_in_cgraph (void)
{
struct cgraph_node *n;
- struct varpool_node *v;
+ varpool_node *v;
struct free_lang_data_d fld;
tree t;
unsigned i;
}
else if (TREE_CODE (decl) == VAR_DECL)
{
- struct varpool_node *node = varpool_node_for_decl (decl);
+ varpool_node *node = varpool_node_for_decl (decl);
/* C++ frontend use mark_decl_references to force COMDAT variables
to be output that might appear dead otherwise. */
node->force_output = true;
if (TREE_CODE (exp) == VAR_DECL && TREE_PUBLIC (exp)
&& (TREE_STATIC (exp) || DECL_EXTERNAL (exp)))
{
- struct varpool_node *vnode = varpool_get_node (exp);
+ varpool_node *vnode = varpool_get_node (exp);
if (vnode && resolution_local_p (vnode->resolution))
resolved_locally = true;
if (vnode
if (TREE_CODE (decl) == VAR_DECL
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
{
- struct varpool_node *vnode = varpool_get_node (decl);
+ varpool_node *vnode = varpool_get_node (decl);
if (vnode
&& vnode->resolution != LDPR_UNKNOWN)
return resolution_to_local_definition_p (vnode->resolution);
/* Call all node removal hooks. */
static void
-varpool_call_node_removal_hooks (struct varpool_node *node)
+varpool_call_node_removal_hooks (varpool_node *node)
{
struct varpool_node_hook_list *entry = first_varpool_node_removal_hook;
while (entry)
/* Call all node insertion hooks. */
void
-varpool_call_variable_insertion_hooks (struct varpool_node *node)
+varpool_call_variable_insertion_hooks (varpool_node *node)
{
struct varpool_node_hook_list *entry = first_varpool_variable_insertion_hook;
while (entry)
/* Allocate new callgraph node and insert it into basic data structures. */
-struct varpool_node *
+varpool_node *
varpool_create_empty_node (void)
{
- struct varpool_node *node = ggc_alloc_cleared_varpool_node ();
+ varpool_node *node = ggc_alloc_cleared_varpool_node ();
node->type = SYMTAB_VARIABLE;
return node;
}
/* Return varpool node assigned to DECL. Create new one when needed. */
-struct varpool_node *
+varpool_node *
varpool_node_for_decl (tree decl)
{
- struct varpool_node *node = varpool_get_node (decl);
+ varpool_node *node = varpool_get_node (decl);
gcc_checking_assert (TREE_CODE (decl) == VAR_DECL);
if (node)
return node;
/* Remove node from the varpool. */
void
-varpool_remove_node (struct varpool_node *node)
+varpool_remove_node (varpool_node *node)
{
tree init;
varpool_call_node_removal_hooks (node);
/* Renove node initializer when it is no longer needed. */
void
-varpool_remove_initializer (struct varpool_node *node)
+varpool_remove_initializer (varpool_node *node)
{
if (DECL_INITIAL (node->decl)
&& !DECL_IN_CONSTANT_POOL (node->decl)
/* Dump given cgraph node. */
void
-dump_varpool_node (FILE *f, struct varpool_node *node)
+dump_varpool_node (FILE *f, varpool_node *node)
{
dump_symtab_base (f, node);
fprintf (f, " Availability: %s\n",
void
dump_varpool (FILE *f)
{
- struct varpool_node *node;
+ varpool_node *node;
fprintf (f, "variable pool:\n\n");
FOR_EACH_VARIABLE (node)
}
/* Given an assembler name, lookup node. */
-struct varpool_node *
+varpool_node *
varpool_node_for_asm (tree asmname)
{
if (symtab_node *node = symtab_node_for_asm (asmname))
tree
ctor_for_folding (tree decl)
{
- struct varpool_node *node, *real_node;
+ varpool_node *node, *real_node;
tree real_decl;
if (TREE_CODE (decl) != VAR_DECL
void
varpool_add_new_variable (tree decl)
{
- struct varpool_node *node;
+ varpool_node *node;
varpool_finalize_decl (decl);
node = varpool_node_for_decl (decl);
varpool_call_variable_insertion_hooks (node);
/* Return variable availability. See cgraph.h for description of individual
return values. */
enum availability
-cgraph_variable_initializer_availability (struct varpool_node *node)
+cgraph_variable_initializer_availability (varpool_node *node)
{
gcc_assert (cgraph_function_flags_ready);
if (!node->definition)
}
void
-varpool_analyze_node (struct varpool_node *node)
+varpool_analyze_node (varpool_node *node)
{
tree decl = node->decl;
/* Assemble thunks and aliases associated to NODE. */
static void
-assemble_aliases (struct varpool_node *node)
+assemble_aliases (varpool_node *node)
{
int i;
struct ipa_ref *ref;
for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
if (ref->use == IPA_REF_ALIAS)
{
- struct varpool_node *alias = ipa_ref_referring_varpool_node (ref);
+ varpool_node *alias = ipa_ref_referring_varpool_node (ref);
do_assemble_alias (alias->decl,
DECL_ASSEMBLER_NAME (node->decl));
assemble_aliases (alias);
/* Output one variable, if necessary. Return whether we output it. */
bool
-varpool_assemble_decl (struct varpool_node *node)
+varpool_assemble_decl (varpool_node *node)
{
tree decl = node->decl;
The queue is linked via AUX pointers and terminated by pointer to 1. */
static void
-enqueue_node (struct varpool_node *node, struct varpool_node **first)
+enqueue_node (varpool_node *node, varpool_node **first)
{
if (node->aux)
return;
static void
varpool_remove_unreferenced_decls (void)
{
- struct varpool_node *next, *node;
- struct varpool_node *first = (struct varpool_node *)(void *)1;
+ varpool_node *next, *node;
+ varpool_node *first = (varpool_node *)(void *)1;
int i;
struct ipa_ref *ref;
fprintf (cgraph_dump_file, " %s", node->asm_name ());
}
}
- while (first != (struct varpool_node *)(void *)1)
+ while (first != (varpool_node *)(void *)1)
{
node = first;
- first = (struct varpool_node *)first->aux;
+ first = (varpool_node *)first->aux;
if (node->same_comdat_group)
{
conflicts between read-only and read-only requiring relocations
sections can be resolved. */
void
-varpool_finalize_named_section_flags (struct varpool_node *node)
+varpool_finalize_named_section_flags (varpool_node *node)
{
if (!TREE_ASM_WRITTEN (node->decl)
&& !node->alias
varpool_output_variables (void)
{
bool changed = false;
- struct varpool_node *node;
+ varpool_node *node;
if (seen_error ())
return false;
add_new_static_var (tree type)
{
tree new_decl;
- struct varpool_node *new_node;
+ varpool_node *new_node;
new_decl = create_tmp_var_raw (type, NULL);
DECL_NAME (new_decl) = create_tmp_var_name (NULL);
/* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
Extra name aliases are output whenever DECL is output. */
-struct varpool_node *
+varpool_node *
varpool_create_variable_alias (tree alias, tree decl)
{
- struct varpool_node *alias_node;
+ varpool_node *alias_node;
gcc_assert (TREE_CODE (decl) == VAR_DECL);
gcc_assert (TREE_CODE (alias) == VAR_DECL);
/* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful.
Extra name aliases are output whenever DECL is output. */
-struct varpool_node *
+varpool_node *
varpool_extra_name_alias (tree alias, tree decl)
{
- struct varpool_node *alias_node;
+ varpool_node *alias_node;
#ifndef ASM_OUTPUT_DEF
/* If aliases aren't supported by the assembler, fail. */
skipped. */
bool
-varpool_for_node_and_aliases (struct varpool_node *node,
- bool (*callback) (struct varpool_node *, void *),
+varpool_for_node_and_aliases (varpool_node *node,
+ bool (*callback) (varpool_node *, void *),
void *data,
bool include_overwritable)
{
for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
if (ref->use == IPA_REF_ALIAS)
{
- struct varpool_node *alias = ipa_ref_referring_varpool_node (ref);
+ varpool_node *alias = ipa_ref_referring_varpool_node (ref);
if (include_overwritable
|| cgraph_variable_initializer_availability (alias) > AVAIL_OVERWRITABLE)
if (varpool_for_node_and_aliases (alias, callback, data,
projects / thirdparty / gcc.git / commitdiff
