{
struct tm_ipa_cg_data *d;
- if (traverse_aliases && (*node)->symbol.alias)
+ if (traverse_aliases && (*node)->alias)
*node = cgraph_alias_target (*node);
- d = (struct tm_ipa_cg_data *) (*node)->symbol.aux;
+ d = (struct tm_ipa_cg_data *) (*node)->aux;
if (d == NULL)
{
d = (struct tm_ipa_cg_data *)
obstack_alloc (&tm_obstack.obstack, sizeof (*d));
- (*node)->symbol.aux = (void *) d;
+ (*node)->aux = (void *) d;
memset (d, 0, sizeof (*d));
}
ipa_tm_scan_calls_clone (struct cgraph_node *node,
cgraph_node_queue *callees_p)
{
- struct function *fn = DECL_STRUCT_FUNCTION (node->symbol.decl);
+ struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
basic_block bb;
FOR_EACH_BB_FN (bb, fn)
continue;
/* Even if we think we can go irrevocable, believe the user
above all. */
- if (is_tm_safe_or_pure (e->caller->symbol.decl))
+ if (is_tm_safe_or_pure (e->caller->decl))
continue;
caller = e->caller;
bool ret = false;
/* Builtin operators (operator new, and such). */
- if (DECL_STRUCT_FUNCTION (node->symbol.decl) == NULL
- || DECL_STRUCT_FUNCTION (node->symbol.decl)->cfg == NULL)
+ if (DECL_STRUCT_FUNCTION (node->decl) == NULL
+ || DECL_STRUCT_FUNCTION (node->decl)->cfg == NULL)
return false;
- push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
+ push_cfun (DECL_STRUCT_FUNCTION (node->decl));
calculate_dominance_info (CDI_DOMINATORS);
d = get_cg_data (&node, true);
unsigned flags;
d = get_cg_data (&node, true);
- decl = node->symbol.decl;
+ decl = node->decl;
flags = flags_from_decl_or_type (decl);
/* Handle some TM builtins. Ordinarily these aren't actually generated
/* Recurse on the main body for aliases. In general, this will
result in one of the bits above being set so that we will not
have to recurse next time. */
- if (node->symbol.alias)
+ if (node->alias)
return ipa_tm_mayenterirr_function (cgraph_get_node (node->thunk.alias));
/* What remains is unmarked local functions without items that force
struct cgraph_edge *e;
for (e = node->callees; e ; e = e->next_callee)
- if (!is_tm_callable (e->callee->symbol.decl)
+ if (!is_tm_callable (e->callee->decl)
&& e->callee->local.tm_may_enter_irr)
error_at (gimple_location (e->call_stmt),
"unsafe function call %qD within "
- "%<transaction_safe%> function", e->callee->symbol.decl);
+ "%<transaction_safe%> function", e->callee->decl);
}
/* Diagnose call from atomic transactions to unmarked functions
ipa_tm_mark_force_output_node (struct cgraph_node *node)
{
cgraph_mark_force_output_node (node);
- node->symbol.analyzed = true;
+ node->analyzed = true;
}
static inline void
ipa_tm_mark_forced_by_abi_node (struct cgraph_node *node)
{
- node->symbol.forced_by_abi = true;
- node->symbol.analyzed = true;
+ node->forced_by_abi = true;
+ node->analyzed = true;
}
/* Callback data for ipa_tm_create_version_alias. */
tree old_decl, new_decl, tm_name;
struct cgraph_node *new_node;
- if (!node->symbol.cpp_implicit_alias)
+ if (!node->cpp_implicit_alias)
return false;
- old_decl = node->symbol.decl;
+ old_decl = node->decl;
tm_name = tm_mangle (DECL_ASSEMBLER_NAME (old_decl));
new_decl = build_decl (DECL_SOURCE_LOCATION (old_decl),
TREE_CODE (old_decl), tm_name,
new_node = cgraph_same_body_alias (NULL, new_decl, info->new_decl);
new_node->tm_clone = true;
- new_node->symbol.externally_visible = info->old_node->symbol.externally_visible;
+ new_node->externally_visible = info->old_node->externally_visible;
/* ?? Do not traverse aliases here. */
get_cg_data (&node, false)->clone = new_node;
record_tm_clone_pair (old_decl, new_decl);
- if (info->old_node->symbol.force_output
- || ipa_ref_list_first_referring (&info->old_node->symbol.ref_list))
+ if (info->old_node->force_output
+ || ipa_ref_list_first_referring (&info->old_node->ref_list))
ipa_tm_mark_force_output_node (new_node);
- if (info->old_node->symbol.forced_by_abi)
+ if (info->old_node->forced_by_abi)
ipa_tm_mark_forced_by_abi_node (new_node);
return false;
}
tree new_decl, old_decl, tm_name;
struct cgraph_node *new_node;
- old_decl = old_node->symbol.decl;
+ old_decl = old_node->decl;
new_decl = copy_node (old_decl);
/* DECL_ASSEMBLER_NAME needs to be set before we call
new_node = cgraph_copy_node_for_versioning (old_node, new_decl, vNULL, NULL);
new_node->local.local = false;
- new_node->symbol.externally_visible = old_node->symbol.externally_visible;
+ new_node->externally_visible = old_node->externally_visible;
new_node->lowered = true;
new_node->tm_clone = 1;
get_cg_data (&old_node, true)->clone = new_node;
record_tm_clone_pair (old_decl, new_decl);
cgraph_call_function_insertion_hooks (new_node);
- if (old_node->symbol.force_output
- || ipa_ref_list_first_referring (&old_node->symbol.ref_list))
+ if (old_node->force_output
+ || ipa_ref_list_first_referring (&old_node->ref_list))
ipa_tm_mark_force_output_node (new_node);
- if (old_node->symbol.forced_by_abi)
+ if (old_node->forced_by_abi)
ipa_tm_mark_forced_by_abi_node (new_node);
/* Do the same thing, but for any aliases of the original node. */
cgraph_get_create_node
(builtin_decl_explicit (BUILT_IN_TM_IRREVOCABLE)),
g, 0,
- compute_call_stmt_bb_frequency (node->symbol.decl,
+ compute_call_stmt_bb_frequency (node->decl,
gimple_bb (g)));
}
gsi_insert_before (gsi, g, GSI_SAME_STMT);
cgraph_create_edge (node, cgraph_get_create_node (gettm_fn), g, 0,
- compute_call_stmt_bb_frequency (node->symbol.decl,
+ compute_call_stmt_bb_frequency (node->decl,
gimple_bb (g)));
/* Cast return value from tm_gettmclone* into appropriate function
return;
}
- fndecl = new_node->symbol.decl;
+ fndecl = new_node->decl;
}
cgraph_redirect_edge_callee (e, new_node);
d = get_cg_data (&node, true);
- push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
+ push_cfun (DECL_STRUCT_FUNCTION (node->decl));
calculate_dominance_info (CDI_DOMINATORS);
for (region = d->all_tm_regions; region; region = region->next)
if (!node->callees && !node->indirect_calls && !d->irrevocable_blocks_clone)
return;
- push_cfun (DECL_STRUCT_FUNCTION (d->clone->symbol.decl));
+ push_cfun (DECL_STRUCT_FUNCTION (d->clone->decl));
calculate_dominance_info (CDI_DOMINATORS);
need_ssa_rename =
/* For all local functions marked tm_callable, queue them. */
FOR_EACH_DEFINED_FUNCTION (node)
- if (is_tm_callable (node->symbol.decl)
+ if (is_tm_callable (node->decl)
&& cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
{
d = get_cg_data (&node, true);
/* ... marked tm_pure, record that fact for the runtime by
indicating that the pure function is its own tm_callable.
No need to do this if the function's address can't be taken. */
- if (is_tm_pure (node->symbol.decl))
+ if (is_tm_pure (node->decl))
{
if (!node->local.local)
- record_tm_clone_pair (node->symbol.decl, node->symbol.decl);
+ record_tm_clone_pair (node->decl, node->decl);
continue;
}
- push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
+ push_cfun (DECL_STRUCT_FUNCTION (node->decl));
calculate_dominance_info (CDI_DOMINATORS);
tm_region_init (NULL);
/* Some callees cannot be arbitrarily cloned. These will always be
irrevocable. Mark these now, so that we need not scan them. */
- if (is_tm_irrevocable (node->symbol.decl))
+ if (is_tm_irrevocable (node->decl))
ipa_tm_note_irrevocable (node, &irr_worklist);
else if (a <= AVAIL_NOT_AVAILABLE
- && !is_tm_safe_or_pure (node->symbol.decl))
+ && !is_tm_safe_or_pure (node->decl))
ipa_tm_note_irrevocable (node, &irr_worklist);
else if (a >= AVAIL_OVERWRITABLE)
{
- if (!tree_versionable_function_p (node->symbol.decl))
+ if (!tree_versionable_function_p (node->decl))
ipa_tm_note_irrevocable (node, &irr_worklist);
else if (!d->is_irrevocable)
{
/* If this is an alias, make sure its base is queued as well.
we need not scan the callees now, as the base will do. */
- if (node->symbol.alias)
+ if (node->alias)
{
node = cgraph_get_node (node->thunk.alias);
d = get_cg_data (&node, true);
for (e = node->callers; e ; e = e->next_caller)
{
caller = e->caller;
- if (!is_tm_safe_or_pure (caller->symbol.decl)
+ if (!is_tm_safe_or_pure (caller->decl)
&& !caller->local.tm_may_enter_irr)
{
d = get_cg_data (&caller, true);
}
/* Propagate back to referring aliases as well. */
- for (j = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list, j, ref); j++)
+ for (j = 0; ipa_ref_list_referring_iterate (&node->ref_list, j, ref); j++)
{
caller = cgraph (ref->referring);
if (ref->use == IPA_REF_ALIAS
&& cgraph_function_body_availability (node) >= AVAIL_OVERWRITABLE)
{
d = get_cg_data (&node, true);
- if (is_tm_safe (node->symbol.decl))
+ if (is_tm_safe (node->decl))
ipa_tm_diagnose_tm_safe (node);
else if (d->all_tm_regions)
ipa_tm_diagnose_transaction (node, d->all_tm_regions);
bool doit = false;
node = tm_callees[i];
- if (node->symbol.cpp_implicit_alias)
+ if (node->cpp_implicit_alias)
continue;
a = cgraph_function_body_availability (node);
d = get_cg_data (&node, true);
if (a <= AVAIL_NOT_AVAILABLE)
- doit = is_tm_callable (node->symbol.decl);
- else if (a <= AVAIL_AVAILABLE && is_tm_callable (node->symbol.decl))
+ doit = is_tm_callable (node->decl);
+ else if (a <= AVAIL_AVAILABLE && is_tm_callable (node->decl))
doit = true;
else if (!d->is_irrevocable
&& d->tm_callers_normal + d->tm_callers_clone > 0)
for (i = 0; i < tm_callees.length (); ++i)
{
node = tm_callees[i];
- if (node->symbol.analyzed)
+ if (node->analyzed)
{
d = get_cg_data (&node, true);
if (d->clone)
free_original_copy_tables ();
FOR_EACH_FUNCTION (node)
- node->symbol.aux = NULL;
+ node->aux = NULL;
#ifdef ENABLE_CHECKING
verify_cgraph ();
projects / thirdparty / gcc.git / blobdiff