+2019-10-30 Martin Liska <mliska@suse.cz>
+
+ * cgraph.c (cgraph_node::local_info): Transform to ...
+ (cgraph_node::local_info_node): ... this.
+ (cgraph_node::dump): Remove cgraph_local_info and
+ put its fields directly into cgraph_node.
+ (cgraph_node::get_availability): Likewise.
+ (cgraph_node::make_local): Likewise.
+ (cgraph_node::verify_node): Likewise.
+ * cgraph.h (struct GTY): Likewise.
+ * cgraphclones.c (set_new_clone_decl_and_node_flags): Likewise.
+ (duplicate_thunk_for_node): Likewise.
+ (cgraph_node::create_clone): Likewise.
+ (cgraph_node::create_virtual_clone): Likewise.
+ (cgraph_node::create_version_clone): Likewise.
+ * cgraphunit.c (cgraph_node::reset): Likewise.
+ (cgraph_node::finalize_function): Likewise.
+ (cgraph_node::add_new_function): Likewise.
+ (analyze_functions): Likewise.
+ * combine.c (setup_incoming_promotions): Likewise.
+ * config/i386/i386.c (ix86_function_regparm): Likewise.
+ (ix86_function_sseregparm): Likewise.
+ (init_cumulative_args): Likewise.
+ * ipa-cp.c (determine_versionability): Likewise.
+ (count_callers): Likewise.
+ (set_single_call_flag): Likewise.
+ (initialize_node_lattices): Likewise.
+ (estimate_local_effects): Likewise.
+ (create_specialized_node): Likewise.
+ (identify_dead_nodes): Likewise.
+ * ipa-fnsummary.c (compute_fn_summary): Likewise.
+ (ipa_fn_summary_generate): Likewise.
+ * ipa-hsa.c (check_warn_node_versionable): Likewise.
+ (process_hsa_functions): Likewise.
+ * ipa-icf.c (set_local): Likewise.
+ * ipa-inline-analysis.c (initialize_inline_failed): Likewise.
+ * ipa-inline.c (speculation_useful_p): Likewise.
+ * ipa-profile.c (ipa_propagate_frequency): Likewise.
+ (ipa_profile): Likewise.
+ * ipa-split.c (split_function): Likewise.
+ (execute_split_functions): Likewise.
+ * ipa-sra.c (ipa_sra_preliminary_function_checks): Likewise.
+ (ipa_sra_ipa_function_checks): Likewise.
+ * ipa-visibility.c (function_and_variable_visibility): Likewise.
+ * ipa.c (symbol_table::remove_unreachable_nodes): Likewise.
+ * lto-cgraph.c (lto_output_node): Likewise.
+ (input_overwrite_node): Likewise.
+ * multiple_target.c (expand_target_clones): Likewise.
+ * omp-simd-clone.c (simd_clone_create): Likewise.
+ * trans-mem.c (expand_call_tm): Likewise.
+ (ipa_tm_mayenterirr_function): Likewise.
+ (ipa_tm_diagnose_tm_safe): Likewise.
+ (ipa_tm_diagnose_transaction): Likewise.
+ (ipa_tm_create_version): Likewise.
+ (ipa_tm_transform_calls_redirect): Likewise.
+ (ipa_tm_execute): Likewise.
+ * tree-inline.c (expand_call_inline): Likewise.
+
2019-10-29 Martin Liska <mliska@suse.cz>
* symbol-summary.h (function_summary): Pass memory location
node->address_taken = 1;
}
-/* Return local info for the compiled function. */
+/* Return local info node for the compiled function. */
-cgraph_local_info *
-cgraph_node::local_info (tree decl)
+cgraph_node *
+cgraph_node::local_info_node (tree decl)
{
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
cgraph_node *node = get (decl);
if (!node)
return NULL;
- return &node->ultimate_alias_target ()->local;
+ return node->ultimate_alias_target ();
}
/* Return RTL info for the compiled function. */
fprintf (f, " body");
if (process)
fprintf (f, " process");
- if (local.local)
+ if (local)
fprintf (f, " local");
- if (local.redefined_extern_inline)
+ if (redefined_extern_inline)
fprintf (f, " redefined_extern_inline");
if (only_called_at_startup)
fprintf (f, " only_called_at_startup");
enum availability avail;
if (!analyzed)
avail = AVAIL_NOT_AVAILABLE;
- else if (local.local)
+ else if (local)
avail = AVAIL_LOCAL;
else if (inlined_to)
avail = AVAIL_AVAILABLE;
node->set_comdat_group (NULL);
node->externally_visible = false;
node->forced_by_abi = false;
- node->local.local = true;
+ node->local = true;
node->set_section (NULL);
node->unique_name = ((node->resolution == LDPR_PREVAILING_DEF_IRONLY
|| node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP)
error ("inline clone in same comdat group list");
error_found = true;
}
- if (!definition && !in_other_partition && local.local)
+ if (!definition && !in_other_partition && local)
{
error ("local symbols must be defined");
error_found = true;
bool thunk_p;
};
-/* Information about the function collected locally.
- Available after function is analyzed. */
-
-struct GTY(()) cgraph_local_info {
- /* Set when function is visible in current compilation unit only and
- its address is never taken. */
- unsigned local : 1;
-
- /* False when there is something makes versioning impossible. */
- unsigned versionable : 1;
-
- /* False when function calling convention and signature cannot be changed.
- This is the case when __builtin_apply_args is used. */
- unsigned can_change_signature : 1;
-
- /* True when the function has been originally extern inline, but it is
- redefined now. */
- unsigned redefined_extern_inline : 1;
-
- /* True if the function may enter serial irrevocable mode. */
- unsigned tm_may_enter_irr : 1;
-};
-
/* Represent which DECL tree (or reference to such tree)
will be replaced by another tree while versioning. */
struct GTY(()) ipa_replace_map
static cgraph_node * get_create (tree);
/* Return local info for the compiled function. */
- static cgraph_local_info *local_info (tree decl);
+ static cgraph_node *local_info_node (tree decl);
/* Return RTL info for the compiled function. */
static struct cgraph_rtl_info *rtl_info (const_tree);
per-function in order to allow IPA passes to introduce new functions. */
vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
- cgraph_local_info local;
-
/* For inline clones this points to the function they will be
inlined into. */
cgraph_node *inlined_to;
unsigned split_part : 1;
/* True if the function appears as possible target of indirect call. */
unsigned indirect_call_target : 1;
+ /* Set when function is visible in current compilation unit only and
+ its address is never taken. */
+ unsigned local : 1;
+ /* False when there is something makes versioning impossible. */
+ unsigned versionable : 1;
+ /* False when function calling convention and signature cannot be changed.
+ This is the case when __builtin_apply_args is used. */
+ unsigned can_change_signature : 1;
+ /* True when the function has been originally extern inline, but it is
+ redefined now. */
+ unsigned redefined_extern_inline : 1;
+ /* True if the function may enter serial irrevocable mode. */
+ unsigned tm_may_enter_irr : 1;
private:
/* Unique id of the node. */
DECL_SET_IS_OPERATOR_DELETE (new_node->decl, 0);
new_node->externally_visible = 0;
- new_node->local.local = 1;
+ new_node->local = 1;
new_node->lowered = true;
}
new_thunk = cgraph_node::create (new_decl);
set_new_clone_decl_and_node_flags (new_thunk);
new_thunk->definition = true;
- new_thunk->local.can_change_signature = node->local.can_change_signature;
+ new_thunk->can_change_signature = node->can_change_signature;
new_thunk->thunk = thunk->thunk;
new_thunk->unique_name = in_lto_p;
new_thunk->former_clone_of = thunk->decl;
}
new_node->analyzed = analyzed;
new_node->definition = definition;
- new_node->local = local;
+ new_node->versionable = versionable;
+ new_node->can_change_signature = can_change_signature;
+ new_node->redefined_extern_inline = redefined_extern_inline;
+ new_node->tm_may_enter_irr = tm_may_enter_irr;
new_node->externally_visible = false;
new_node->no_reorder = no_reorder;
- new_node->local.local = true;
+ new_node->local = true;
new_node->inlined_to = new_inlined_to;
new_node->rtl = rtl;
new_node->frequency = frequency;
ipa_replace_map *map;
char *name;
- gcc_checking_assert (local.versionable);
+ gcc_checking_assert (versionable);
/* TODO: It would be nice if we could recognize that param_adjustments do not
actually perform any changes, but at the moment let's require it simply
does not exist. */
- gcc_assert (local.can_change_signature || !param_adjustments);
+ gcc_assert (can_change_signature || !param_adjustments);
/* Make a new FUNCTION_DECL tree node */
if (!param_adjustments)
new_version->local = local;
new_version->externally_visible = false;
new_version->no_reorder = no_reorder;
- new_version->local.local = new_version->definition;
+ new_version->local = new_version->definition;
new_version->inlined_to = inlined_to;
new_version->rtl = rtl;
new_version->count = count;
return NULL;
/* TODO: Restore an assert that we do not change signature if
- local.can_change_signature is false. We cannot just check that
+ can_change_signature is false. We cannot just check that
param_adjustments is NULL because unfortunately ipa-split removes return
values from such functions. */
new_version_node->make_decl_local ();
DECL_VIRTUAL_P (new_version_node->decl) = 0;
new_version_node->externally_visible = 0;
- new_version_node->local.local = 1;
+ new_version_node->local = 1;
new_version_node->lowered = true;
if (!implicit_section)
new_version_node->set_section (get_section ());
gcc_assert (!process);
/* Reset our data structures so we can analyze the function again. */
- memset (&local, 0, sizeof (local));
inlined_to = NULL;
memset (&rtl, 0, sizeof (rtl));
analyzed = false;
gcc_assert (!DECL_CONTEXT (decl)
|| TREE_CODE (DECL_CONTEXT (decl)) != FUNCTION_DECL);
node->reset ();
- node->local.redefined_extern_inline = true;
+ node->redefined_extern_inline = true;
}
/* Set definition first before calling notice_global_symbol so that
/* Bring the function into finalized state and enqueue for later
analyzing and compilation. */
node = cgraph_node::get_create (fndecl);
- node->local.local = false;
+ node->local = false;
node->definition = true;
node->force_output = true;
if (TREE_PUBLIC (fndecl))
&& !cnode->dispatcher_function)
{
cnode->reset ();
- cnode->local.redefined_extern_inline = true;
+ cnode->redefined_extern_inline = true;
continue;
}
function lie within the current compilation unit. (This does
take into account the exporting of a function via taking its
address, and so forth.) */
- strictly_local = cgraph_node::local_info (current_function_decl)->local;
+ strictly_local
+ = cgraph_node::local_info_node (current_function_decl)->local;
/* The mode and signedness of the argument before any promotions happen
(equal to the mode of the pseudo holding it at that stage). */
if (target && opt_for_fn (target->decl, optimize)
&& !(profile_flag && !flag_fentry))
{
- cgraph_local_info *i = &target->local;
- if (i && i->local && i->can_change_signature)
+ if (target->local && target->can_change_signature)
{
int local_regparm, globals = 0, regno;
&& opt_for_fn (target->decl, optimize)
&& !(profile_flag && !flag_fentry))
{
- cgraph_local_info *i = &target->local;
- if (i && i->local && i->can_change_signature)
+ if (target->local && target->can_change_signature)
{
/* Refuse to produce wrong code when local function with SSE enabled
is called from SSE disabled function.
tree fndecl,
int caller)
{
- struct cgraph_local_info *i = NULL;
+ struct cgraph_node *local_info_node = NULL;
struct cgraph_node *target = NULL;
memset (cum, 0, sizeof (*cum));
if (target)
{
target = target->function_symbol ();
- i = cgraph_node::local_info (target->decl);
+ local_info_node = cgraph_node::local_info_node (target->decl);
cum->call_abi = ix86_function_abi (target->decl);
}
else
va_start so for local functions maybe_vaarg can be made aggressive
helping K&R code.
FIXME: once typesytem is fixed, we won't need this code anymore. */
- if (i && i->local && i->can_change_signature)
+ if (local_info_node && local_info_node->local
+ && local_info_node->can_change_signature)
fntype = TREE_TYPE (target->decl);
cum->stdarg = stdarg_p (fntype);
cum->maybe_vaarg = (fntype
present. */
if (node->alias || node->thunk.thunk_p)
reason = "alias or thunk";
- else if (!node->local.versionable)
+ else if (!node->versionable)
reason = "not a tree_versionable_function";
else if (node->get_availability () <= AVAIL_INTERPOSABLE)
reason = "insufficient body availability";
for (cgraph_edge *cs = node->callers; cs; cs = cs->next_caller)
/* Local thunks can be handled transparently, but if the thunk cannot
be optimized out, count it as a real use. */
- if (!cs->caller->thunk.thunk_p || !cs->caller->local.local)
+ if (!cs->caller->thunk.thunk_p || !cs->caller->local)
++*caller_count;
return false;
}
{
cgraph_edge *cs = node->callers;
/* Local thunks can be handled transparently, skip them. */
- while (cs && cs->caller->thunk.thunk_p && cs->caller->local.local)
+ while (cs && cs->caller->thunk.thunk_p && cs->caller->local)
cs = cs->next_caller;
if (cs)
{
if (!ipa_get_param_count (info))
disable = true;
- else if (node->local.local)
+ else if (node->local)
{
int caller_count = 0;
node->call_for_symbol_thunks_and_aliases (count_callers, &caller_count,
int devirt_bonus = devirtualization_time_bonus (node, known_csts,
known_contexts, known_aggs_ptrs);
if (always_const || devirt_bonus
- || (removable_params_cost && node->local.can_change_signature))
+ || (removable_params_cost && node->can_change_signature))
{
struct caller_statistics stats;
ipa_hints hints;
fprintf (dump_file, " - context independent values, size: %i, "
"time_benefit: %f\n", size, (base_time - time).to_double ());
- if (size <= 0 || node->local.local)
+ if (size <= 0 || node->local)
{
info->do_clone_for_all_contexts = true;
ipa_param_adjustments *old_adjustments = node->clone.param_adjustments;
ipa_param_adjustments *new_adjustments;
gcc_assert (!info->ipcp_orig_node);
- gcc_assert (node->local.can_change_signature
+ gcc_assert (node->can_change_signature
|| !old_adjustments);
if (old_adjustments)
for (i = 0; i < old_adj_count; i++)
{
ipa_adjusted_param *old_adj = &(*old_adjustments->m_adj_params)[i];
- if (!node->local.can_change_signature
+ if (!node->can_change_signature
|| old_adj->op != IPA_PARAM_OP_COPY
|| (!known_csts[old_adj->base_index]
&& ipa_is_param_used (info, old_adj->base_index)))
ipa_param_adjustments (new_params, count,
skip_return));
}
- else if (node->local.can_change_signature
+ else if (node->can_change_signature
&& want_remove_some_param_p (node, known_csts))
{
ipa_adjusted_param adj;
{
struct cgraph_node *v;
for (v = node; v; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
- if (v->local.local
+ if (v->local
&& !v->call_for_symbol_thunks_and_aliases
(has_undead_caller_from_outside_scc_p, NULL, true))
IPA_NODE_REF (v)->node_dead = 1;
ipa_call_summary *es = ipa_call_summaries->get_create (node->callees);
predicate t = true;
- node->local.can_change_signature = false;
+ node->can_change_signature = false;
es->call_stmt_size = eni_size_weights.call_cost;
es->call_stmt_time = eni_time_weights.call_cost;
info->account_size_time (ipa_fn_summary::size_scale
with simd attribute. */
|| lookup_attribute ("omp declare simd",
DECL_ATTRIBUTES (node->decl)))
- node->local.can_change_signature = false;
+ node->can_change_signature = false;
else
{
/* Otherwise, inlinable functions always can change signature. */
if (info->inlinable)
- node->local.can_change_signature = true;
+ node->can_change_signature = true;
else
{
/* Functions calling builtin_apply cannot change signature. */
|| fndecl_built_in_p (cdecl, BUILT_IN_VA_START))
break;
}
- node->local.can_change_signature = !e;
+ node->can_change_signature = !e;
}
}
analyze_function_body (node, early);
FOR_EACH_DEFINED_FUNCTION (node)
if (DECL_STRUCT_FUNCTION (node->decl))
- node->local.versionable = tree_versionable_function_p (node->decl);
+ node->versionable = tree_versionable_function_p (node->decl);
ipa_fn_summary_alloc ();
static bool
check_warn_node_versionable (cgraph_node *node)
{
- if (!node->local.versionable)
+ if (!node->versionable)
{
warning_at (EXPR_LOCATION (node->decl), OPT_Whsa,
"could not emit HSAIL for function %s: function cannot be "
TREE_PUBLIC (clone->decl) = TREE_PUBLIC (node->decl);
clone->externally_visible = node->externally_visible;
- if (!node->local.local)
+ if (!node->local)
clone->force_output = true;
hsa_summaries->link_functions (clone, node, HSA_FUNCTION, false);
static bool
set_local (cgraph_node *node, void *data)
{
- node->local.local = data != NULL;
+ node->local = data != NULL;
return false;
}
e->inline_failed = CIF_INDIRECT_UNKNOWN_CALL;
else if (!callee->definition)
e->inline_failed = CIF_BODY_NOT_AVAILABLE;
- else if (callee->local.redefined_extern_inline)
+ else if (callee->redefined_extern_inline)
e->inline_failed = CIF_REDEFINED_EXTERN_INLINE;
else
e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED;
to an ipa-cp clone (that are seen by having local flag set),
it is probably pointless to inline it unless hardware is missing
indirect call predictor. */
- if (!anticipate_inlining && !target->local.local)
+ if (!anticipate_inlining && !target->local)
return false;
/* For overwritable targets there is not much to do. */
if (!can_inline_edge_p (e, false)
/* We cannot propagate anything useful about externally visible functions
nor about virtuals. */
- if (!node->local.local
+ if (!node->local
|| node->alias
|| (opt_for_fn (node->decl, flag_devirtualize)
&& DECL_VIRTUAL_P (node->decl)))
order_pos = ipa_reverse_postorder (order);
for (i = order_pos - 1; i >= 0; i--)
{
- if (order[i]->local.local
+ if (order[i]->local
&& opt_for_fn (order[i]->decl, flag_ipa_profile)
&& ipa_propagate_frequency (order[i]))
{
for (e = order[i]->callees; e; e = e->next_callee)
- if (e->callee->local.local && !e->callee->aux)
+ if (e->callee->local && !e->callee->aux)
{
something_changed = true;
e->callee->aux = (void *)1;
&& ipa_propagate_frequency (order[i]))
{
for (e = order[i]->callees; e; e = e->next_callee)
- if (e->callee->local.local && !e->callee->aux)
+ if (e->callee->local && !e->callee->aux)
{
something_changed = true;
e->callee->aux = (void *)1;
dump_split_point (dump_file, split_point);
}
- if (cur_node->local.can_change_signature)
+ if (cur_node->can_change_signature)
args_to_skip = BITMAP_ALLOC (NULL);
else
args_to_skip = NULL;
then inlining would still benefit. */
if ((!node->callers
/* Local functions called once will be completely inlined most of time. */
- || (!node->callers->next_caller && node->local.local))
+ || (!node->callers->next_caller && node->local))
&& !node->address_taken
&& !node->has_aliases_p ()
&& (!flag_lto || !node->externally_visible))
static bool
ipa_sra_preliminary_function_checks (cgraph_node *node)
{
- if (!node->local.can_change_signature)
+ if (!node->can_change_signature)
{
if (dump_file)
fprintf (dump_file, "Function cannot change signature.\n");
"made local.\n", node->dump_name ());
return false;
}
- if (!node->local.can_change_signature)
+ if (!node->can_change_signature)
{
if (dump_file)
fprintf (dump_file, "Function can not change signature.\n");
}
FOR_EACH_DEFINED_FUNCTION (node)
{
- if (!node->local.local)
- node->local.local |= node->local_p ();
+ if (!node->local)
+ node->local |= node->local_p ();
/* If we know that function cannot be overwritten by a
different semantics and moreover its section cannot be
{
fprintf (dump_file, "\nMarking local functions:");
FOR_EACH_DEFINED_FUNCTION (node)
- if (node->local.local)
+ if (node->local)
fprintf (dump_file, " %s", node->name ());
fprintf (dump_file, "\n\n");
fprintf (dump_file, "\nMarking externally visible functions:");
= remove_attribute ("always_inline",
DECL_ATTRIBUTES (node->decl));
if (!node->in_other_partition)
- node->local.local = false;
+ node->local = false;
node->remove_callees ();
node->remove_all_references ();
changed = true;
|| !node->call_for_symbol_and_aliases
(is_indirect_call_target_p, NULL, true)))
{
- node->local.local = true;
+ node->local = true;
if (file)
fprintf (file, " (local)");
}
streamer_write_hwi_stream (ob->main_stream, node->tp_first_run);
bp = bitpack_create (ob->main_stream);
- bp_pack_value (&bp, node->local.local, 1);
+ bp_pack_value (&bp, node->local, 1);
bp_pack_value (&bp, node->externally_visible, 1);
bp_pack_value (&bp, node->no_reorder, 1);
bp_pack_value (&bp, node->definition, 1);
- bp_pack_value (&bp, node->local.versionable, 1);
- bp_pack_value (&bp, node->local.can_change_signature, 1);
- bp_pack_value (&bp, node->local.redefined_extern_inline, 1);
+ bp_pack_value (&bp, node->versionable, 1);
+ bp_pack_value (&bp, node->can_change_signature, 1);
+ bp_pack_value (&bp, node->redefined_extern_inline, 1);
bp_pack_value (&bp, node->force_output, 1);
bp_pack_value (&bp, node->forced_by_abi, 1);
bp_pack_value (&bp, node->unique_name, 1);
node->aux = (void *) tag;
node->lto_file_data = file_data;
- node->local.local = bp_unpack_value (bp, 1);
+ node->local = bp_unpack_value (bp, 1);
node->externally_visible = bp_unpack_value (bp, 1);
node->no_reorder = bp_unpack_value (bp, 1);
node->definition = bp_unpack_value (bp, 1);
- node->local.versionable = bp_unpack_value (bp, 1);
- node->local.can_change_signature = bp_unpack_value (bp, 1);
- node->local.redefined_extern_inline = bp_unpack_value (bp, 1);
+ node->versionable = bp_unpack_value (bp, 1);
+ node->can_change_signature = bp_unpack_value (bp, 1);
+ node->redefined_extern_inline = bp_unpack_value (bp, 1);
node->force_output = bp_unpack_value (bp, 1);
node->forced_by_abi = bp_unpack_value (bp, 1);
node->unique_name = bp_unpack_value (bp, 1);
attributes);
if (new_node == NULL)
return false;
- new_node->local.local = false;
+ new_node->local = false;
XDELETEVEC (suffix);
decl2_v = new_node->function_version ();
tree attributes = make_attribute ("target", "default",
DECL_ATTRIBUTES (node->decl));
DECL_ATTRIBUTES (node->decl) = attributes;
- node->local.local = false;
+ node->local = false;
return true;
}
/* The method cgraph_version_clone_with_body () will force the new
symbol local. Undo this, and inherit external visibility from
the old node. */
- new_node->local.local = old_node->local.local;
+ new_node->local = old_node->local;
new_node->externally_visible = old_node->externally_visible;
return new_node;
gimple_call_set_fndecl (stmt, repl);
update_stmt (stmt);
node = cgraph_node::create (repl);
- node->local.tm_may_enter_irr = false;
+ node->tm_may_enter_irr = false;
return expand_call_tm (region, gsi);
}
gcc_unreachable ();
}
- if (node->local.tm_may_enter_irr)
+ if (node->tm_may_enter_irr)
transaction_subcode_ior (region, GTMA_MAY_ENTER_IRREVOCABLE);
if (is_tm_abort (fn_decl))
/* We may have previously marked this function as tm_may_enter_irr;
see pass_diagnose_tm_blocks. */
- if (node->local.tm_may_enter_irr)
+ if (node->tm_may_enter_irr)
return true;
/* Recurse on the main body for aliases. In general, this will
for (e = node->callees; e ; e = e->next_callee)
if (!is_tm_callable (e->callee->decl)
- && e->callee->local.tm_may_enter_irr)
+ && e->callee->tm_may_enter_irr)
error_at (gimple_location (e->call_stmt),
"unsafe function call %qD within "
"%<transaction_safe%> function", e->callee->decl);
if (is_tm_callable (fndecl))
continue;
- if (cgraph_node::local_info (fndecl)->tm_may_enter_irr)
+ if (cgraph_node::local_info_node (fndecl)->tm_may_enter_irr)
error_at (gimple_location (stmt),
"unsafe function call %qD within "
"atomic transaction", fndecl);
gcc_assert (!old_node->ipa_transforms_to_apply.exists ());
new_node = old_node->create_version_clone (new_decl, vNULL, NULL);
- new_node->local.local = false;
+ new_node->local = false;
new_node->externally_visible = old_node->externally_visible;
new_node->lowered = true;
new_node->tm_clone = 1;
CALLER. Also note that find_tm_replacement_function also
contains mappings into the TM runtime, e.g. memcpy. These
we know won't go irrevocable. */
- new_node->local.tm_may_enter_irr = 1;
+ new_node->tm_may_enter_irr = 1;
}
else
{
No need to do this if the function's address can't be taken. */
if (is_tm_pure (node->decl))
{
- if (!node->local.local)
+ if (!node->local)
record_tm_clone_pair (node->decl, node->decl);
continue;
}
node = irr_worklist[i];
d = get_cg_data (&node, true);
d->in_worklist = false;
- node->local.tm_may_enter_irr = true;
+ node->tm_may_enter_irr = true;
/* Propagate back to normal callers. */
for (e = node->callers; e ; e = e->next_caller)
{
caller = e->caller;
if (!is_tm_safe_or_pure (caller->decl)
- && !caller->local.tm_may_enter_irr)
+ && !caller->tm_may_enter_irr)
{
d = get_cg_data (&caller, true);
maybe_push_queue (caller, &irr_worklist, &d->in_worklist);
FOR_EACH_ALIAS (node, ref)
{
caller = dyn_cast<cgraph_node *> (ref->referring);
- if (!caller->local.tm_may_enter_irr)
+ if (!caller->tm_may_enter_irr)
{
/* ?? Do not traverse aliases here. */
d = get_cg_data (&caller, false);
be to be able to keep both bodies and use extern inline body
for inlining, but we can't do that because frontends overwrite
the body. */
- && !cg_edge->callee->local.redefined_extern_inline
+ && !cg_edge->callee->redefined_extern_inline
/* During early inline pass, report only when optimization is
not turned on. */
&& (symtab->global_info_ready
projects / gcc.git / commitdiff