---
gcc/cgraph.c | 56 ++++++++++++-------------
gcc/cgraph.h | 41 ++++++++-----------
gcc/cgraphbuild.c | 2 +-
gcc/cgraphclones.c | 7 ++--
gcc/cgraphunit.c | 16 ++++----
gcc/gimple-fold.c | 4 +-
gcc/ipa-comdats.c | 8 ++--
gcc/ipa-devirt.c | 2 +-
gcc/ipa-fnsummary.c | 18 ++++----
gcc/ipa-inline-analysis.c | 8 ++--
gcc/ipa-inline-transform.c | 16 ++++----
gcc/ipa-inline.c | 84 +++++++++++++++++++-------------------
gcc/ipa-profile.c | 4 +-
gcc/ipa-prop.c | 26 ++++++------
gcc/ipa-pure-const.c | 6 +--
gcc/ipa-reference.c | 4 +-
gcc/ipa-utils.c | 2 +-
gcc/ipa-visibility.c | 2 +-
gcc/ipa.c | 18 ++++----
gcc/lto-cgraph.c | 26 ++++++------
gcc/lto/lto-partition.c | 6 +--
gcc/lto/lto-symtab.c | 4 +-
gcc/omp-simd-clone.c | 2 +-
gcc/passes.c | 2 +-
gcc/symtab.c | 6 +--
gcc/tree-ssa-structalias.c | 4 +-
26 files changed, 184 insertions(+), 190 deletions(-)
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index d47d4128b1c..2dc91a3a99b 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -539,7 +539,7 @@ cgraph_node::get_create (tree decl)
{
cgraph_node *first_clone = cgraph_node::get (decl);
- if (first_clone && !first_clone->global.inlined_to)
+ if (first_clone && !first_clone->inlined_to)
return first_clone;
cgraph_node *node = cgraph_node::create (decl);
@@ -659,7 +659,7 @@ cgraph_node::get_for_asmname (tree asmname)
node = node->next_sharing_asm_name)
{
cgraph_node *cn = dyn_cast <cgraph_node *> (node);
- if (cn && !cn->global.inlined_to)
+ if (cn && !cn->inlined_to)
return cn;
}
return NULL;
@@ -1786,7 +1786,7 @@ cgraph_node::remove (void)
{
cgraph_node *n = cgraph_node::get (decl);
if (!n
- || (!n->clones && !n->clone_of && !n->global.inlined_to
+ || (!n->clones && !n->clone_of && !n->inlined_to
&& ((symtab->global_info_ready || in_lto_p)
&& (TREE_ASM_WRITTEN (n->decl)
|| DECL_EXTERNAL (n->decl)
@@ -1817,7 +1817,7 @@ cgraph_node::mark_address_taken (void)
{
/* Indirect inlining can figure out that all uses of the address are
inlined. */
- if (global.inlined_to)
+ if (inlined_to)
{
gcc_assert (cfun->after_inlining);
gcc_assert (callers->indirect_inlining_edge);
@@ -1944,10 +1944,10 @@ cgraph_node::dump (FILE *f)
dump_base (f);
- if (global.inlined_to)
+ if (inlined_to)
fprintf (f, " Function %s is inline copy in %s\n",
dump_name (),
- global.inlined_to->dump_name ());
+ inlined_to->dump_name ());
if (clone_of)
fprintf (f, " Clone of %s\n", clone_of->dump_asm_name ());
if (symtab->function_flags_ready)
@@ -2096,7 +2096,7 @@ cgraph_node::dump (FILE *f)
if (dyn_cast <cgraph_node *> (ref->referring)->count.initialized_p ())
sum += dyn_cast <cgraph_node *> (ref->referring)->count.ipa ();
- if (global.inlined_to
+ if (inlined_to
|| (symtab->state < EXPANSION
&& ultimate_alias_target () == this && only_called_directly_p ()))
ok = !count.ipa ().differs_from_p (sum);
@@ -2212,14 +2212,14 @@ cgraph_node::get_availability (symtab_node *ref)
{
cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
if (cref)
- ref = cref->global.inlined_to;
+ ref = cref->inlined_to;
}
enum availability avail;
if (!analyzed)
avail = AVAIL_NOT_AVAILABLE;
else if (local.local)
avail = AVAIL_LOCAL;
- else if (global.inlined_to)
+ else if (inlined_to)
avail = AVAIL_AVAILABLE;
else if (transparent_alias)
ultimate_alias_target (&avail, ref);
@@ -2828,7 +2828,7 @@ bool
cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
(bool will_inline)
{
- gcc_assert (!global.inlined_to);
+ gcc_assert (!inlined_to);
if (DECL_EXTERNAL (decl))
return true;
@@ -3015,7 +3015,7 @@ cgraph_edge::verify_corresponds_to_fndecl (tree decl)
{
cgraph_node *node;
- if (!decl || callee->global.inlined_to)
+ if (!decl || callee->inlined_to)
return false;
if (symtab->state == LTO_STREAMING)
return false;
@@ -3085,7 +3085,7 @@ cgraph_node::verify_node (void)
error ("cgraph count invalid");
error_found = true;
}
- if (global.inlined_to && same_comdat_group)
+ if (inlined_to && same_comdat_group)
{
error ("inline clone in same comdat group list");
error_found = true;
@@ -3095,17 +3095,17 @@ cgraph_node::verify_node (void)
error ("local symbols must be defined");
error_found = true;
}
- if (global.inlined_to && externally_visible)
+ if (inlined_to && externally_visible)
{
error ("externally visible inline clone");
error_found = true;
}
- if (global.inlined_to && address_taken)
+ if (inlined_to && address_taken)
{
error ("inline clone with address taken");
error_found = true;
}
- if (global.inlined_to && force_output)
+ if (inlined_to && force_output)
{
error ("inline clone is forced to output");
error_found = true;
@@ -3142,9 +3142,9 @@ cgraph_node::verify_node (void)
}
if (!e->inline_failed)
{
- if (global.inlined_to
- != (e->caller->global.inlined_to
- ? e->caller->global.inlined_to : e->caller))
+ if (inlined_to
+ != (e->caller->inlined_to
+ ? e->caller->inlined_to : e->caller))
{
error ("inlined_to pointer is wrong");
error_found = true;
@@ -3156,7 +3156,7 @@ cgraph_node::verify_node (void)
}
}
else
- if (global.inlined_to)
+ if (inlined_to)
{
error ("inlined_to pointer set for noninline callers");
error_found = true;
@@ -3167,7 +3167,7 @@ cgraph_node::verify_node (void)
if (e->verify_count ())
error_found = true;
if (gimple_has_body_p (e->caller->decl)
- && !e->caller->global.inlined_to
+ && !e->caller->inlined_to
&& !e->speculative
/* Optimized out calls are redirected to __builtin_unreachable. */
&& (e->count.nonzero_p ()
@@ -3192,7 +3192,7 @@ cgraph_node::verify_node (void)
if (e->verify_count ())
error_found = true;
if (gimple_has_body_p (e->caller->decl)
- && !e->caller->global.inlined_to
+ && !e->caller->inlined_to
&& !e->speculative
&& e->count.ipa_p ()
&& count
@@ -3209,12 +3209,12 @@ cgraph_node::verify_node (void)
error_found = true;
}
}
- if (!callers && global.inlined_to)
+ if (!callers && inlined_to)
{
error ("inlined_to pointer is set but no predecessors found");
error_found = true;
}
- if (global.inlined_to == this)
+ if (inlined_to == this)
{
error ("inlined_to pointer refers to itself");
error_found = true;
@@ -3303,7 +3303,7 @@ cgraph_node::verify_node (void)
error ("More than one edge out of thunk node");
error_found = true;
}
- if (gimple_has_body_p (decl) && !global.inlined_to)
+ if (gimple_has_body_p (decl) && !inlined_to)
{
error ("Thunk is not supposed to have body");
error_found = true;
@@ -3311,7 +3311,7 @@ cgraph_node::verify_node (void)
}
else if (analyzed && gimple_has_body_p (decl)
&& !TREE_ASM_WRITTEN (decl)
- && (!DECL_EXTERNAL (decl) || global.inlined_to)
+ && (!DECL_EXTERNAL (decl) || inlined_to)
&& !flag_wpa)
{
if (this_cfun->cfg)
@@ -3586,7 +3586,7 @@ cgraph_node::get_body (void)
early.
TODO: Materializing clones here will likely lead to smaller LTRANS
footprint. */
- gcc_assert (!global.inlined_to && !clone_of);
+ gcc_assert (!inlined_to && !clone_of);
if (ipa_transforms_to_apply.exists ())
{
opt_pass *saved_current_pass = current_pass;
@@ -3776,8 +3776,8 @@ cgraph_node::has_thunk_p (cgraph_node *node, void *)
sreal
cgraph_edge::sreal_frequency ()
{
- return count.to_sreal_scale (caller->global.inlined_to
- ? caller->global.inlined_to->count
+ return count.to_sreal_scale (caller->inlined_to
+ ? caller->inlined_to->count
: caller->count);
}
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index a7f357f0b5c..826d391db32 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -730,15 +730,6 @@ struct GTY(()) cgraph_local_info {
unsigned tm_may_enter_irr : 1;
};
-/* Information about the function that needs to be computed globally
- once compilation is finished. Available only with -funit-at-a-time. */
-
-struct GTY(()) cgraph_global_info {
- /* For inline clones this points to the function they will be
- inlined into. */
- cgraph_node *inlined_to;
-};
-
/* Represent which DECL tree (or reference to such tree)
will be replaced by another tree while versioning. */
struct GTY(()) ipa_replace_map
@@ -979,7 +970,7 @@ struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node
If the new node is being inlined into another one, NEW_INLINED_TO should be
the outline function the new one is (even indirectly) inlined to.
- All hooks will see this in node's global.inlined_to, when invoked.
+ All hooks will see this in node's inlined_to, when invoked.
Can be NULL if the node is not inlined. SUFFIX is string that is appended
to the original name. */
cgraph_node *create_clone (tree decl, profile_count count,
@@ -1446,7 +1437,11 @@ struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node
vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply;
cgraph_local_info local;
- cgraph_global_info global;
+
+ /* For inline clones this points to the function they will be
+ inlined into. */
+ cgraph_node *inlined_to;
+
struct cgraph_rtl_info *rtl;
cgraph_clone_info clone;
cgraph_thunk_info thunk;
@@ -2519,7 +2514,7 @@ symtab_node::real_symbol_p (void)
if (!is_a <cgraph_node *> (this))
return true;
cnode = dyn_cast <cgraph_node *> (this);
- if (cnode->global.inlined_to)
+ if (cnode->inlined_to)
return false;
return true;
}
@@ -2542,13 +2537,13 @@ symtab_node::in_same_comdat_group_p (symtab_node *target)
if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
{
- if (cn->global.inlined_to)
- source = cn->global.inlined_to;
+ if (cn->inlined_to)
+ source = cn->inlined_to;
}
if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
{
- if (cn->global.inlined_to)
- target = cn->global.inlined_to;
+ if (cn->inlined_to)
+ target = cn->inlined_to;
}
return source->get_comdat_group () == target->get_comdat_group ();
@@ -2995,7 +2990,7 @@ struct GTY((for_user)) constant_descriptor_tree {
inline bool
cgraph_node::only_called_directly_or_aliased_p (void)
{
- gcc_assert (!global.inlined_to);
+ gcc_assert (!inlined_to);
return (!force_output && !address_taken
&& !ifunc_resolver
&& !used_from_other_partition
@@ -3012,7 +3007,7 @@ cgraph_node::only_called_directly_or_aliased_p (void)
inline bool
cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
{
- gcc_checking_assert (!global.inlined_to);
+ gcc_checking_assert (!inlined_to);
/* Extern inlines can always go, we will use the external definition. */
if (DECL_EXTERNAL (decl))
return true;
@@ -3183,8 +3178,8 @@ inline bool
cgraph_edge::recursive_p (void)
{
cgraph_node *c = callee->ultimate_alias_target ();
- if (caller->global.inlined_to)
- return caller->global.inlined_to->decl == c->decl;
+ if (caller->inlined_to)
+ return caller->inlined_to->decl == c->decl;
else
return caller->decl == c->decl;
}
@@ -3221,8 +3216,8 @@ cgraph_edge::binds_to_current_def_p ()
inline int
cgraph_edge::frequency ()
{
- return count.to_cgraph_frequency (caller->global.inlined_to
- ? caller->global.inlined_to->count
+ return count.to_cgraph_frequency (caller->inlined_to
+ ? caller->inlined_to->count
: caller->count);
}
@@ -3244,7 +3239,7 @@ inline void
cgraph_node::mark_force_output (void)
{
force_output = 1;
- gcc_checking_assert (!global.inlined_to);
+ gcc_checking_assert (!inlined_to);
}
/* Return true if function should be optimized for size. */
diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c
index 2e7d0b5fe95..3baf67b4828 100644
--- a/gcc/cgraphbuild.c
+++ b/gcc/cgraphbuild.c
@@ -428,7 +428,7 @@ cgraph_edge::rebuild_edges (void)
node->record_stmt_references (gsi_stmt (gsi));
}
record_eh_tables (node, cfun);
- gcc_assert (!node->global.inlined_to);
+ gcc_assert (!node->inlined_to);
return 0;
}
diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c
index 087b5a26280..fcf9cd5c992 100644
--- a/gcc/cgraphclones.c
+++ b/gcc/cgraphclones.c
@@ -309,7 +309,7 @@ dump_callgraph_transformation (const cgraph_node *original,
If the new node is being inlined into another one, NEW_INLINED_TO should be
the outline function the new one is (even indirectly) inlined to. All hooks
- will see this in node's global.inlined_to, when invoked. Can be NULL if the
+ will see this in node's inlined_to, when invoked. Can be NULL if the
node is not inlined.
If PARAM_ADJUSTMENTS is non-NULL, the parameter manipulation information
@@ -357,8 +357,7 @@ cgraph_node::create_clone (tree new_decl, profile_count prof_count,
new_node->externally_visible = false;
new_node->no_reorder = no_reorder;
new_node->local.local = true;
- new_node->global = global;
- new_node->global.inlined_to = new_inlined_to;
+ new_node->inlined_to = new_inlined_to;
new_node->rtl = rtl;
new_node->frequency = frequency;
new_node->tp_first_run = tp_first_run;
@@ -862,7 +861,7 @@ cgraph_node::create_version_clone (tree new_decl,
new_version->externally_visible = false;
new_version->no_reorder = no_reorder;
new_version->local.local = new_version->definition;
- new_version->global = global;
+ new_version->inlined_to = inlined_to;
new_version->rtl = rtl;
new_version->count = count;
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 6ec24432351..ef96393a009 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -392,7 +392,7 @@ cgraph_node::reset (void)
/* Reset our data structures so we can analyze the function again. */
memset (&local, 0, sizeof (local));
- memset (&global, 0, sizeof (global));
+ inlined_to = NULL;
memset (&rtl, 0, sizeof (rtl));
analyzed = false;
definition = false;
@@ -1507,7 +1507,7 @@ mark_functions_to_output (void)
if (node->analyzed
&& !node->thunk.thunk_p
&& !node->alias
- && !node->global.inlined_to
+ && !node->inlined_to
&& !TREE_ASM_WRITTEN (decl)
&& !DECL_EXTERNAL (decl))
{
@@ -1532,7 +1532,7 @@ mark_functions_to_output (void)
{
/* We should've reclaimed all functions that are not needed. */
if (flag_checking
- && !node->global.inlined_to
+ && !node->inlined_to
&& gimple_has_body_p (decl)
/* FIXME: in ltrans unit when offline copy is outside partition but inline copies
are inside partition, we can end up not removing the body since we no longer
@@ -1545,7 +1545,7 @@ mark_functions_to_output (void)
node->debug ();
internal_error ("failed to reclaim unneeded function");
}
- gcc_assert (node->global.inlined_to
+ gcc_assert (node->inlined_to
|| !gimple_has_body_p (decl)
|| node->in_other_partition
|| node->clones
@@ -1560,7 +1560,7 @@ mark_functions_to_output (void)
if (node->same_comdat_group && !node->process)
{
tree decl = node->decl;
- if (!node->global.inlined_to
+ if (!node->inlined_to
&& gimple_has_body_p (decl)
/* FIXME: in an ltrans unit when the offline copy is outside a
partition but inline copies are inside a partition, we can
@@ -2117,7 +2117,7 @@ cgraph_node::assemble_thunks_and_aliases (void)
for (e = callers; e;)
if (e->caller->thunk.thunk_p
- && !e->caller->global.inlined_to)
+ && !e->caller->inlined_to)
{
cgraph_node *thunk = e->caller;
@@ -2154,7 +2154,7 @@ cgraph_node::expand (void)
location_t saved_loc;
/* We ought to not compile any inline clones. */
- gcc_assert (!global.inlined_to);
+ gcc_assert (!inlined_to);
/* __RTL functions are compiled as soon as they are parsed, so don't
do it again. */
@@ -2707,7 +2707,7 @@ symbol_table::compile (void)
bool error_found = false;
FOR_EACH_DEFINED_FUNCTION (node)
- if (node->global.inlined_to
+ if (node->inlined_to
|| gimple_has_body_p (node->decl))
{
error_found = true;
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index a085ab2beaf..1b7e7edfa8c 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -135,7 +135,7 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
if (!snode || !snode->definition)
return false;
node = dyn_cast <cgraph_node *> (snode);
- return !node || !node->global.inlined_to;
+ return !node || !node->inlined_to;
}
/* We will later output the initializer, so we can refer to it.
@@ -184,7 +184,7 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
|| (!snode->forced_by_abi && !snode->force_output))))
return false;
node = dyn_cast <cgraph_node *> (snode);
- return !node || !node->global.inlined_to;
+ return !node || !node->inlined_to;
}
/* Create a temporary for TYPE for a statement STMT. If the current function
diff --git a/gcc/ipa-comdats.c b/gcc/ipa-comdats.c
index 69cc3f3b907..b496497ff66 100644
--- a/gcc/ipa-comdats.c
+++ b/gcc/ipa-comdats.c
@@ -98,8 +98,8 @@ propagate_comdat_group (struct symtab_node *symbol,
if (cgraph_node * cn = dyn_cast <cgraph_node *> (symbol2))
{
- if (cn->global.inlined_to)
- symbol2 = cn->global.inlined_to;
+ if (cn->inlined_to)
+ symbol2 = cn->inlined_to;
}
/* The actual merge operation. */
@@ -133,8 +133,8 @@ propagate_comdat_group (struct symtab_node *symbol,
/* If we see inline clone, its comdat group actually
corresponds to the comdat group of the function it
is inlined to. */
- if (cn->global.inlined_to)
- symbol2 = cn->global.inlined_to;
+ if (cn->inlined_to)
+ symbol2 = cn->inlined_to;
}
/* The actual merge operation. */
diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
index 6c651a38705..a14e7953788 100644
--- a/gcc/ipa-devirt.c
+++ b/gcc/ipa-devirt.c
@@ -2414,7 +2414,7 @@ maybe_record_node (vec <cgraph_node *> &nodes,
|| target_node->definition)
&& target_node->real_symbol_p ())
{
- gcc_assert (!target_node->global.inlined_to);
+ gcc_assert (!target_node->inlined_to);
gcc_assert (target_node->real_symbol_p ());
/* When sanitizing, do not assume that __cxa_pure_virtual is not called
by valid program. */
diff --git a/gcc/ipa-fnsummary.c b/gcc/ipa-fnsummary.c
index 0d38e42546d..9ad0f1fd435 100644
--- a/gcc/ipa-fnsummary.c
+++ b/gcc/ipa-fnsummary.c
@@ -470,8 +470,8 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
class ipa_call_summary *es = ipa_call_summaries->get (e);
int i, count = ipa_get_cs_argument_count (args);
- if (e->caller->global.inlined_to)
- caller_parms_info = IPA_NODE_REF (e->caller->global.inlined_to);
+ if (e->caller->inlined_to)
+ caller_parms_info = IPA_NODE_REF (e->caller->inlined_to);
else
caller_parms_info = IPA_NODE_REF (e->caller);
callee_pi = IPA_NODE_REF (e->callee);
@@ -746,7 +746,7 @@ ipa_fn_summary_t::duplicate (cgraph_node *src,
set_hint_predicate (&info->loop_stride, p);
}
}
- if (!dst->global.inlined_to)
+ if (!dst->inlined_to)
ipa_update_overall_fn_summary (dst);
}
@@ -927,7 +927,7 @@ ipa_dump_fn_summaries (FILE *f)
struct cgraph_node *node;
FOR_EACH_DEFINED_FUNCTION (node)
- if (!node->global.inlined_to)
+ if (!node->inlined_to)
ipa_dump_fn_summary (f, node);
}
@@ -2690,7 +2690,7 @@ compute_fn_summary (struct cgraph_node *node, bool early)
HOST_WIDE_INT self_stack_size;
struct cgraph_edge *e;
- gcc_assert (!node->global.inlined_to);
+ gcc_assert (!node->inlined_to);
if (!ipa_fn_summaries)
ipa_fn_summary_alloc ();
@@ -3115,13 +3115,13 @@ HOST_WIDE_INT
ipa_get_stack_frame_offset (struct cgraph_node *node)
{
HOST_WIDE_INT offset = 0;
- if (!node->global.inlined_to)
+ if (!node->inlined_to)
return 0;
node = node->callers->caller;
while (true)
{
offset += ipa_size_summaries->get (node)->estimated_self_stack_size;
- if (!node->global.inlined_to)
+ if (!node->inlined_to)
return offset;
node = node->callers->caller;
}
@@ -3292,8 +3292,8 @@ void
ipa_merge_fn_summary_after_inlining (struct cgraph_edge *edge)
{
ipa_fn_summary *callee_info = ipa_fn_summaries->get (edge->callee);
- struct cgraph_node *to = (edge->caller->global.inlined_to
- ? edge->caller->global.inlined_to : edge->caller);
+ struct cgraph_node *to = (edge->caller->inlined_to
+ ? edge->caller->inlined_to : edge->caller);
class ipa_fn_summary *info = ipa_fn_summaries->get (to);
clause_t clause = 0; /* not_inline is known to be false. */
size_time_entry *e;
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index 8b572a45386..8dee132600a 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -93,8 +93,8 @@ int
simple_edge_hints (struct cgraph_edge *edge)
{
int hints = 0;
- struct cgraph_node *to = (edge->caller->global.inlined_to
- ? edge->caller->global.inlined_to : edge->caller);
+ struct cgraph_node *to = (edge->caller->inlined_to
+ ? edge->caller->inlined_to : edge->caller);
struct cgraph_node *callee = edge->callee->ultimate_alias_target ();
int to_scc_no = ipa_fn_summaries->get (to)->scc_no;
int callee_scc_no = ipa_fn_summaries->get (callee)->scc_no;
@@ -147,8 +147,8 @@ do_estimate_edge_time (struct cgraph_edge *edge)
may hurt optimization of the caller's hot path. */
if (edge->count.ipa ().initialized_p () && edge->maybe_hot_p ()
&& (edge->count.ipa ().apply_scale (2, 1)
- > (edge->caller->global.inlined_to
- ? edge->caller->global.inlined_to->count.ipa ()
+ > (edge->caller->inlined_to
+ ? edge->caller->inlined_to->count.ipa ()
: edge->caller->count.ipa ())))
hints |= INLINE_HINT_known_hot;
diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c
index ccaa0ebf582..1cc78034f19 100644
--- a/gcc/ipa-inline-transform.c
+++ b/gcc/ipa-inline-transform.c
@@ -166,8 +166,8 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
struct cgraph_node *inlining_into;
struct cgraph_edge *next;
- if (e->caller->global.inlined_to)
- inlining_into = e->caller->global.inlined_to;
+ if (e->caller->inlined_to)
+ inlining_into = e->caller->inlined_to;
else
inlining_into = e->caller;
@@ -193,7 +193,7 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
For now we keep the ohter functions in the group in program until
cgraph_remove_unreachable_functions gets rid of them. */
- gcc_assert (!e->callee->global.inlined_to);
+ gcc_assert (!e->callee->inlined_to);
e->callee->remove_from_same_comdat_group ();
if (e->callee->definition
&& inline_account_function_p (e->callee))
@@ -226,7 +226,7 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
else
e->callee->remove_from_same_comdat_group ();
- e->callee->global.inlined_to = inlining_into;
+ e->callee->inlined_to = inlining_into;
/* Recursively clone all bodies. */
for (e = e->callee->callees; e; e = next)
@@ -344,11 +344,11 @@ inline_call (struct cgraph_edge *e, bool update_original,
/* Don't inline inlined edges. */
gcc_assert (e->inline_failed);
/* Don't even think of inlining inline clone. */
- gcc_assert (!callee->global.inlined_to);
+ gcc_assert (!callee->inlined_to);
to = e->caller;
- if (to->global.inlined_to)
- to = to->global.inlined_to;
+ if (to->inlined_to)
+ to = to->inlined_to;
if (to->thunk.thunk_p)
{
struct cgraph_node *target = to->callees->callee;
@@ -478,7 +478,7 @@ inline_call (struct cgraph_edge *e, bool update_original,
clone_inlined_nodes (e, true, update_original, overall_size);
- gcc_assert (curr->callee->global.inlined_to == to);
+ gcc_assert (curr->callee->inlined_to == to);
old_size = ipa_size_summaries->get (to)->size;
ipa_merge_fn_summary_after_inlining (e);
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index a7ef7faa3a0..210387050bc 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -167,7 +167,7 @@ caller_growth_limits (struct cgraph_edge *e)
limit = size_info->self_size;
if (stack_size_limit < size_info->estimated_self_stack_size)
stack_size_limit = size_info->estimated_self_stack_size;
- if (to->global.inlined_to)
+ if (to->inlined_to)
to = to->callers->caller;
else
break;
@@ -321,8 +321,8 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
bool inlinable = true;
enum availability avail;
- cgraph_node *caller = e->caller->global.inlined_to
- ? e->caller->global.inlined_to : e->caller;
+ cgraph_node *caller = (e->caller->inlined_to
+ ? e->caller->inlined_to : e->caller);
cgraph_node *callee = e->callee->ultimate_alias_target (&avail, caller);
if (!callee->definition)
@@ -458,8 +458,8 @@ can_inline_edge_by_limits_p (struct cgraph_edge *e, bool report,
bool inlinable = true;
enum availability avail;
- cgraph_node *caller = e->caller->global.inlined_to
- ? e->caller->global.inlined_to : e->caller;
+ cgraph_node *caller = (e->caller->inlined_to
+ ? e->caller->inlined_to : e->caller);
cgraph_node *callee = e->callee->ultimate_alias_target (&avail, caller);
tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (caller->decl);
tree callee_tree
@@ -737,8 +737,8 @@ inline sreal
compute_uninlined_call_time (struct cgraph_edge *edge,
sreal uninlined_call_time)
{
- cgraph_node *caller = (edge->caller->global.inlined_to
- ? edge->caller->global.inlined_to
+ cgraph_node *caller = (edge->caller->inlined_to
+ ? edge->caller->inlined_to
: edge->caller);
sreal freq = edge->sreal_frequency ();
@@ -758,8 +758,8 @@ inline sreal
compute_inlined_call_time (struct cgraph_edge *edge,
sreal time)
{
- cgraph_node *caller = (edge->caller->global.inlined_to
- ? edge->caller->global.inlined_to
+ cgraph_node *caller = (edge->caller->inlined_to
+ ? edge->caller->inlined_to
: edge->caller);
sreal caller_time = ipa_fn_summaries->get (caller)->time;
@@ -789,9 +789,9 @@ big_speedup_p (struct cgraph_edge *e)
sreal spec_time = estimate_edge_time (e, &unspec_time);
sreal time = compute_uninlined_call_time (e, unspec_time);
sreal inlined_time = compute_inlined_call_time (e, spec_time);
- cgraph_node *caller = e->caller->global.inlined_to
- ? e->caller->global.inlined_to
- : e->caller;
+ cgraph_node *caller = (e->caller->inlined_to
+ ? e->caller->inlined_to
+ : e->caller);
int limit = opt_for_fn (caller->decl, optimize) >= 3
? PARAM_VALUE (PARAM_INLINE_MIN_SPEEDUP)
: PARAM_VALUE (PARAM_INLINE_MIN_SPEEDUP_O2);
@@ -959,7 +959,7 @@ want_inline_self_recursive_call_p (struct cgraph_edge *edge,
reason = "--param max-inline-recursive-depth exceeded.";
want_inline = false;
}
- else if (outer_node->global.inlined_to
+ else if (outer_node->inlined_to
&& (caller_freq = outer_node->callers->sreal_frequency ()) == 0)
{
reason = "caller frequency is 0";
@@ -1069,7 +1069,7 @@ want_inline_function_to_all_callers_p (struct cgraph_node *node, bool cold)
if (node->alias)
return false;
/* Already inlined? */
- if (node->global.inlined_to)
+ if (node->inlined_to)
return false;
/* Does it have callers? */
if (!node->call_for_symbol_and_aliases (has_caller_p, NULL, true))
@@ -1101,8 +1101,8 @@ edge_badness (struct cgraph_edge *edge, bool dump)
struct cgraph_node *callee = edge->callee->ultimate_alias_target ();
class ipa_fn_summary *callee_info = ipa_fn_summaries->get (callee);
ipa_hints hints;
- cgraph_node *caller = (edge->caller->global.inlined_to
- ? edge->caller->global.inlined_to
+ cgraph_node *caller = (edge->caller->inlined_to
+ ? edge->caller->inlined_to
: edge->caller);
growth = estimate_edge_growth (edge);
@@ -1196,7 +1196,7 @@ edge_badness (struct cgraph_edge *edge, bool dump)
if (growth > overall_growth
/* ... and having only one caller which is not inlined ... */
&& callee_info->single_caller
- && !edge->caller->global.inlined_to
+ && !edge->caller->inlined_to
/* ... and edges executed only conditionally ... */
&& edge->sreal_frequency () < 1
/* ... consider case where callee is not inline but caller is ... */
@@ -1365,8 +1365,8 @@ reset_edge_caches (struct cgraph_node *node)
struct cgraph_node *where = node;
struct ipa_ref *ref;
- if (where->global.inlined_to)
- where = where->global.inlined_to;
+ if (where->inlined_to)
+ where = where->inlined_to;
if (edge_growth_cache != NULL)
for (edge = where->callers; edge; edge = edge->next_caller)
@@ -1416,7 +1416,7 @@ update_caller_keys (edge_heap_t *heap, struct cgraph_node *node,
struct ipa_ref *ref;
if ((!node->alias && !ipa_fn_summaries->get (node)->inlinable)
- || node->global.inlined_to)
+ || node->inlined_to)
return;
if (!bitmap_set_bit (updated_nodes, node->get_uid ()))
return;
@@ -1544,8 +1544,8 @@ recursive_inlining (struct cgraph_edge *edge,
int n = 0;
node = edge->caller;
- if (node->global.inlined_to)
- node = node->global.inlined_to;
+ if (node->inlined_to)
+ node = node->inlined_to;
if (DECL_DECLARED_INLINE_P (node->decl))
limit = PARAM_VALUE (PARAM_MAX_INLINE_INSNS_RECURSIVE);
@@ -1593,7 +1593,7 @@ recursive_inlining (struct cgraph_edge *edge,
depth = 1;
for (cnode = curr->caller;
- cnode->global.inlined_to; cnode = cnode->callers->caller)
+ cnode->inlined_to; cnode = cnode->callers->caller)
if (node->decl
== curr->callee->ultimate_alias_target ()->decl)
depth++;
@@ -1658,7 +1658,7 @@ recursive_inlining (struct cgraph_edge *edge,
node = next)
{
next = symtab->next_function (node);
- if (node->global.inlined_to == master_clone)
+ if (node->inlined_to == master_clone)
node->remove ();
}
master_clone->remove ();
@@ -1776,8 +1776,8 @@ resolve_noninline_speculation (edge_heap_t *edge_heap, struct cgraph_edge *edge)
if (edge->speculative && !speculation_useful_p (edge, false))
{
struct cgraph_node *node = edge->caller;
- struct cgraph_node *where = node->global.inlined_to
- ? node->global.inlined_to : node;
+ struct cgraph_node *where = node->inlined_to
+ ? node->inlined_to : node;
auto_bitmap updated_nodes;
if (edge->count.ipa ().initialized_p ())
@@ -1859,7 +1859,7 @@ inline_small_functions (void)
free (order);
FOR_EACH_DEFINED_FUNCTION (node)
- if (!node->global.inlined_to)
+ if (!node->inlined_to)
{
if (!node->alias && node->analyzed
&& (node->has_gimple_body_p () || node->thunk.thunk_p)
@@ -1888,7 +1888,7 @@ inline_small_functions (void)
if (opt_for_fn (n2->decl, optimize))
{
ipa_fn_summary *info2 = ipa_fn_summaries->get
- (n2->global.inlined_to ? n2->global.inlined_to : n2);
+ (n2->inlined_to ? n2->inlined_to : n2);
if (info2->scc_no)
break;
info2->scc_no = id;
@@ -1952,8 +1952,8 @@ inline_small_functions (void)
}
if (update)
{
- struct cgraph_node *where = node->global.inlined_to
- ? node->global.inlined_to : node;
+ struct cgraph_node *where = node->inlined_to
+ ? node->inlined_to : node;
ipa_update_overall_fn_summary (where);
reset_edge_caches (where);
update_caller_keys (&edge_heap, where,
@@ -2097,8 +2097,8 @@ inline_small_functions (void)
if (edge->recursive_p ())
{
where = edge->caller;
- if (where->global.inlined_to)
- where = where->global.inlined_to;
+ if (where->inlined_to)
+ where = where->inlined_to;
if (!recursive_inlining (edge,
opt_for_fn (edge->caller->decl,
flag_indirect_inlining)
@@ -2128,7 +2128,7 @@ inline_small_functions (void)
selective. */
where = edge->caller;
- while (where->global.inlined_to)
+ while (where->inlined_to)
{
if (where->decl == callee->decl)
outer_node = where, depth++;
@@ -2147,7 +2147,7 @@ inline_small_functions (void)
else if (depth && dump_file)
fprintf (dump_file, " Peeling recursion with depth %i\n", depth);
- gcc_checking_assert (!callee->global.inlined_to);
+ gcc_checking_assert (!callee->inlined_to);
inline_call (edge, true, &new_indirect_edges, &overall_size, true);
add_new_edges_to_heap (&edge_heap, new_indirect_edges);
@@ -2156,8 +2156,8 @@ inline_small_functions (void)
update_callee_keys (&edge_heap, where, updated_nodes);
}
where = edge->caller;
- if (where->global.inlined_to)
- where = where->global.inlined_to;
+ if (where->inlined_to)
+ where = where->inlined_to;
/* Our profitability metric can depend on local properties
such as number of inlinable calls and size of the function body.
@@ -2290,8 +2290,8 @@ flatten_function (struct cgraph_node *node, bool early, bool update)
node->aux = NULL;
if (update)
- ipa_update_overall_fn_summary (node->global.inlined_to
- ? node->global.inlined_to : node);
+ ipa_update_overall_fn_summary (node->inlined_to
+ ? node->inlined_to : node);
}
/* Inline NODE to all callers. Worker for cgraph_for_node_and_aliases.
@@ -2305,7 +2305,7 @@ inline_to_all_callers_1 (struct cgraph_node *node, void *data,
int *num_calls = (int *)data;
bool callee_removed = false;
- while (node->callers && !node->global.inlined_to)
+ while (node->callers && !node->inlined_to)
{
struct cgraph_node *caller = node->callers->caller;
@@ -2378,7 +2378,7 @@ dump_overall_stats (void)
struct cgraph_node *node;
FOR_EACH_DEFINED_FUNCTION (node)
- if (!node->global.inlined_to
+ if (!node->inlined_to
&& !node->alias)
{
ipa_fn_summary *s = ipa_fn_summaries->get (node);
@@ -2670,8 +2670,8 @@ ipa_inline (void)
}
if (update)
{
- struct cgraph_node *where = node->global.inlined_to
- ? node->global.inlined_to : node;
+ struct cgraph_node *where = node->inlined_to
+ ? node->inlined_to : node;
reset_edge_caches (where);
ipa_update_overall_fn_summary (where);
}
diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c
index 970dba39c80..50a54ebf19b 100644
--- a/gcc/ipa-profile.c
+++ b/gcc/ipa-profile.c
@@ -326,8 +326,8 @@ ipa_propagate_frequency_1 (struct cgraph_node *node, void *data)
if (profile_info
&& !(edge->callee->count.ipa () == profile_count::zero ())
&& (edge->caller->frequency != NODE_FREQUENCY_UNLIKELY_EXECUTED
- || (edge->caller->global.inlined_to
- && edge->caller->global.inlined_to->frequency
+ || (edge->caller->inlined_to
+ && edge->caller->inlined_to->frequency
!= NODE_FREQUENCY_UNLIKELY_EXECUTED)))
d->maybe_unlikely_executed = false;
if (edge->count.ipa ().initialized_p ()
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index 0dd73561419..0b620c4d1da 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -2892,7 +2892,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
/* Because may-edges are not explicitely represented and vtable may be external,
we may create the first reference to the object in the unit. */
- if (!callee || callee->global.inlined_to)
+ if (!callee || callee->inlined_to)
{
/* We are better to ensure we can refer to it.
@@ -2945,7 +2945,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
/* We cannot make edges to inline clones. It is bug that someone removed
the cgraph node too early. */
- gcc_assert (!callee->global.inlined_to);
+ gcc_assert (!callee->inlined_to);
if (dump_file && !unreachable)
{
@@ -3412,8 +3412,8 @@ update_indirect_edges_after_inlining (struct cgraph_edge *cs,
ipa_check_create_edge_args ();
top = IPA_EDGE_REF (cs);
- new_root_info = IPA_NODE_REF (cs->caller->global.inlined_to
- ? cs->caller->global.inlined_to
+ new_root_info = IPA_NODE_REF (cs->caller->inlined_to
+ ? cs->caller->inlined_to
: cs->caller);
inlined_node_info = IPA_NODE_REF (cs->callee->function_symbol ());
@@ -3579,8 +3579,8 @@ propagate_controlled_uses (struct cgraph_edge *cs)
class ipa_edge_args *args = IPA_EDGE_REF (cs);
if (!args)
return;
- struct cgraph_node *new_root = cs->caller->global.inlined_to
- ? cs->caller->global.inlined_to : cs->caller;
+ struct cgraph_node *new_root = cs->caller->inlined_to
+ ? cs->caller->inlined_to : cs->caller;
class ipa_node_params *new_root_info = IPA_NODE_REF (new_root);
class ipa_node_params *old_root_info = IPA_NODE_REF (cs->callee);
int count, i;
@@ -3645,7 +3645,7 @@ propagate_controlled_uses (struct cgraph_edge *cs)
gcc_checking_assert (ok);
clone = cs->caller;
- while (clone->global.inlined_to
+ while (clone->inlined_to
&& clone != rdesc->cs->caller
&& IPA_NODE_REF (clone)->ipcp_orig_node)
{
@@ -3867,16 +3867,16 @@ ipa_edge_args_sum_t::duplicate (cgraph_edge *src, cgraph_edge *dst,
We need to find the duplicate that refers to our tree of
inline clones. */
- gcc_assert (dst->caller->global.inlined_to);
+ gcc_assert (dst->caller->inlined_to);
for (dst_rdesc = src_rdesc->next_duplicate;
dst_rdesc;
dst_rdesc = dst_rdesc->next_duplicate)
{
struct cgraph_node *top;
- top = dst_rdesc->cs->caller->global.inlined_to
- ? dst_rdesc->cs->caller->global.inlined_to
+ top = dst_rdesc->cs->caller->inlined_to
+ ? dst_rdesc->cs->caller->inlined_to
: dst_rdesc->cs->caller;
- if (dst->caller->global.inlined_to == top)
+ if (dst->caller->inlined_to == top)
break;
}
gcc_assert (dst_rdesc);
@@ -3886,8 +3886,8 @@ ipa_edge_args_sum_t::duplicate (cgraph_edge *src, cgraph_edge *dst,
else if (dst_jf->type == IPA_JF_PASS_THROUGH
&& src->caller == dst->caller)
{
- struct cgraph_node *inline_root = dst->caller->global.inlined_to
- ? dst->caller->global.inlined_to : dst->caller;
+ struct cgraph_node *inline_root = dst->caller->inlined_to
+ ? dst->caller->inlined_to : dst->caller;
class ipa_node_params *root_info = IPA_NODE_REF (inline_root);
int idx = ipa_get_jf_pass_through_formal_id (dst_jf);
diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
index 4b2a79f18a9..a142e0cc8f6 100644
--- a/gcc/ipa-pure-const.c
+++ b/gcc/ipa-pure-const.c
@@ -1678,7 +1678,7 @@ propagate_pure_const (void)
/* Inline clones share declaration with their offline copies;
do not modify their declarations since the offline copy may
be different. */
- if (!w->global.inlined_to)
+ if (!w->inlined_to)
switch (this_state)
{
case IPA_CONST:
@@ -1839,7 +1839,7 @@ propagate_nothrow (void)
/* Inline clones share declaration with their offline copies;
do not modify their declarations since the offline copy may
be different. */
- if (!w->global.inlined_to)
+ if (!w->inlined_to)
{
w->set_nothrow_flag (true);
if (dump_file)
@@ -1966,7 +1966,7 @@ propagate_malloc (void)
funct_state l = funct_state_summaries->get (node);
if (!node->alias
&& l->malloc_state == STATE_MALLOC
- && !node->global.inlined_to)
+ && !node->inlined_to)
{
if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Function %s found to be malloc\n",
diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c
index 06c122551b8..feee92de545 100644
--- a/gcc/ipa-reference.c
+++ b/gcc/ipa-reference.c
@@ -901,7 +901,7 @@ propagate (void)
ipa_reference_global_vars_info_t node_g;
/* No need to produce summaries for inline clones. */
- if (node->global.inlined_to)
+ if (node->inlined_to)
continue;
node_info = get_reference_vars_info (node);
@@ -977,7 +977,7 @@ write_node_summary_p (struct cgraph_node *node,
ipa_reference_optimization_summary_t info;
/* See if we have (non-empty) info. */
- if (!node->definition || node->global.inlined_to)
+ if (!node->definition || node->inlined_to)
return false;
info = get_reference_optimization_summary (node);
if (!info)
diff --git a/gcc/ipa-utils.c b/gcc/ipa-utils.c
index 25c2e2cf789..8849429e9e4 100644
--- a/gcc/ipa-utils.c
+++ b/gcc/ipa-utils.c
@@ -296,7 +296,7 @@ ipa_reverse_postorder (struct cgraph_node **order)
if (!node->aux
&& (pass
|| (!node->address_taken
- && !node->global.inlined_to
+ && !node->inlined_to
&& !node->alias && !node->thunk.thunk_p
&& !node->only_called_directly_p ())))
{
diff --git a/gcc/ipa-visibility.c b/gcc/ipa-visibility.c
index 84585b52e46..274d3081ada 100644
--- a/gcc/ipa-visibility.c
+++ b/gcc/ipa-visibility.c
@@ -707,7 +707,7 @@ function_and_variable_visibility (bool whole_program)
|| DECL_EXTERNAL (node->decl));
if (cgraph_externally_visible_p (node, whole_program))
{
- gcc_assert (!node->global.inlined_to);
+ gcc_assert (!node->inlined_to);
node->externally_visible = true;
}
else
diff --git a/gcc/ipa.c b/gcc/ipa.c
index 6b84e1f9bda..5d47e3d2146 100644
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -71,9 +71,9 @@ update_inlined_to_pointer (struct cgraph_node *node, struct cgraph_node *inlined
{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
- if (e->callee->global.inlined_to)
+ if (e->callee->inlined_to)
{
- e->callee->global.inlined_to = inlined_to;
+ e->callee->inlined_to = inlined_to;
update_inlined_to_pointer (e->callee, inlined_to);
}
}
@@ -335,11 +335,11 @@ symbol_table::remove_unreachable_nodes (FILE *file)
node->used_as_abstract_origin = false;
node->indirect_call_target = false;
if (node->definition
- && !node->global.inlined_to
+ && !node->inlined_to
&& !node->in_other_partition
&& !node->can_remove_if_no_direct_calls_and_refs_p ())
{
- gcc_assert (!node->global.inlined_to);
+ gcc_assert (!node->inlined_to);
reachable.add (node);
enqueue_node (node, &first, &reachable);
}
@@ -451,7 +451,7 @@ symbol_table::remove_unreachable_nodes (FILE *file)
/* When inline clone exists, mark body to be preserved so when removing
offline copy of the function we don't kill it. */
- if (cnode->global.inlined_to)
+ if (cnode->inlined_to)
body_needed_for_clonning.add (cnode->decl);
/* For non-inline clones, force their origins to the boundary and ensure
@@ -560,11 +560,11 @@ symbol_table::remove_unreachable_nodes (FILE *file)
to turn it into normal cone. */
FOR_EACH_FUNCTION (node)
{
- if (node->global.inlined_to
+ if (node->inlined_to
&& !node->callers)
{
gcc_assert (node->clones);
- node->global.inlined_to = NULL;
+ node->inlined_to = NULL;
update_inlined_to_pointer (node, node);
}
node->aux = NULL;
@@ -1212,8 +1212,8 @@ propagate_single_user (varpool_node *vnode, cgraph_node *function,
struct cgraph_node *cnode = dyn_cast <cgraph_node *> (ref->referring);
if (cnode)
{
- if (cnode->global.inlined_to)
- cnode = cnode->global.inlined_to;
+ if (cnode->inlined_to)
+ cnode = cnode->inlined_to;
if (!function)
function = cnode;
else if (function != cnode)
diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index 147975ba869..b03835a9b8c 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -329,7 +329,7 @@ reachable_from_other_partition_p (struct cgraph_node *node, lto_symtab_encoder_t
struct cgraph_edge *e;
if (!node->definition)
return false;
- if (node->global.inlined_to)
+ if (node->inlined_to)
return false;
for (e = node->callers; e; e = e->next_caller)
{
@@ -399,7 +399,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
boundary_p = !lto_symtab_encoder_in_partition_p (encoder, node);
if (node->analyzed && (!boundary_p || node->alias
- || (node->thunk.thunk_p && !node->global.inlined_to)))
+ || (node->thunk.thunk_p && !node->inlined_to)))
tag = LTO_symtab_analyzed_node;
else
tag = LTO_symtab_unavail_node;
@@ -422,7 +422,7 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
&& node->get_partitioning_class () == SYMBOL_PARTITION)
{
/* Inline clones cannot be part of boundary.
- gcc_assert (!node->global.inlined_to);
+ gcc_assert (!node->inlined_to);
FIXME: At the moment they can be, when partition contains an inline
clone that is clone of inline clone from outside partition. We can
@@ -468,9 +468,9 @@ lto_output_node (struct lto_simple_output_block *ob, struct cgraph_node *node,
if (tag == LTO_symtab_analyzed_node)
{
- if (node->global.inlined_to)
+ if (node->inlined_to)
{
- ref = lto_symtab_encoder_lookup (encoder, node->global.inlined_to);
+ ref = lto_symtab_encoder_lookup (encoder, node->inlined_to);
gcc_assert (ref != LCC_NOT_FOUND);
}
else
@@ -884,7 +884,7 @@ compute_ltrans_boundary (lto_symtab_encoder_t in_encoder)
if (!lto_symtab_encoder_in_partition_p (encoder, callee))
{
/* We should have moved all the inlines. */
- gcc_assert (!callee->global.inlined_to);
+ gcc_assert (!callee->inlined_to);
add_node_to (encoder, callee, false);
}
}
@@ -911,7 +911,7 @@ compute_ltrans_boundary (lto_symtab_encoder_t in_encoder)
&& !lto_symtab_encoder_in_partition_p
(encoder, callee))
{
- gcc_assert (!callee->global.inlined_to);
+ gcc_assert (!callee->inlined_to);
add_node_to (encoder, callee, false);
}
}
@@ -928,7 +928,7 @@ compute_ltrans_boundary (lto_symtab_encoder_t in_encoder)
if (node->alias && node->analyzed)
create_references (encoder, node);
if (cnode
- && cnode->thunk.thunk_p && !cnode->global.inlined_to)
+ && cnode->thunk.thunk_p && !cnode->inlined_to)
add_node_to (encoder, cnode->callees->callee, false);
while (node->transparent_alias && node->analyzed)
{
@@ -984,7 +984,7 @@ output_symtab (void)
{
node = dyn_cast <cgraph_node *> (lto_symtab_encoder_deref (encoder, i));
if (node
- && ((node->thunk.thunk_p && !node->global.inlined_to)
+ && ((node->thunk.thunk_p && !node->inlined_to)
|| lto_symtab_encoder_in_partition_p (encoder, node)))
{
output_outgoing_cgraph_edges (node->callees, ob, encoder);
@@ -1283,7 +1283,7 @@ input_node (struct lto_file_decl_data *file_data,
input_overwrite_node (file_data, node, tag, &bp);
/* Store a reference for now, and fix up later to be a pointer. */
- node->global.inlined_to = (cgraph_node *) (intptr_t) ref;
+ node->inlined_to = (cgraph_node *) (intptr_t) ref;
if (group)
{
@@ -1542,7 +1542,7 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
int ref;
if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
{
- ref = (int) (intptr_t) cnode->global.inlined_to;
+ ref = (int) (intptr_t) cnode->inlined_to;
/* We share declaration of builtins, so we may read same node twice. */
if (!node->aux)
@@ -1551,10 +1551,10 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
/* Fixup inlined_to from reference to pointer. */
if (ref != LCC_NOT_FOUND)
- dyn_cast<cgraph_node *> (node)->global.inlined_to
+ dyn_cast<cgraph_node *> (node)->inlined_to
= dyn_cast<cgraph_node *> (nodes[ref]);
else
- cnode->global.inlined_to = NULL;
+ cnode->inlined_to = NULL;
}
ref = (int) (intptr_t) node->same_comdat_group;
diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c
index 1492833bc06..32090359814 100644
--- a/gcc/lto/lto-partition.c
+++ b/gcc/lto/lto-partition.c
@@ -182,7 +182,7 @@ add_symbol_to_partition_1 (ltrans_partition part, symtab_node *node)
/* Add all thunks associated with the function. */
for (e = cnode->callers; e; e = e->next_caller)
- if (e->caller->thunk.thunk_p && !e->caller->global.inlined_to)
+ if (e->caller->thunk.thunk_p && !e->caller->inlined_to)
add_symbol_to_partition_1 (part, e->caller);
}
@@ -233,8 +233,8 @@ contained_in_symbol (symtab_node *node)
if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
{
cnode = cnode->function_symbol ();
- if (cnode->global.inlined_to)
- cnode = cnode->global.inlined_to;
+ if (cnode->inlined_to)
+ cnode = cnode->inlined_to;
return cnode;
}
else if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c
index 37fa572b883..2fd5b1e8f49 100644
--- a/gcc/lto/lto-symtab.c
+++ b/gcc/lto/lto-symtab.c
@@ -63,7 +63,7 @@ lto_cgraph_replace_node (struct cgraph_node *node,
prevailing_node->forced_by_abi = true;
if (node->address_taken)
{
- gcc_assert (!prevailing_node->global.inlined_to);
+ gcc_assert (!prevailing_node->inlined_to);
prevailing_node->mark_address_taken ();
}
if (node->definition && prevailing_node->definition
@@ -910,7 +910,7 @@ lto_symtab_merge_symbols_1 (symtab_node *prevailing)
cgraph_node *ce = dyn_cast <cgraph_node *> (e);
if ((!TREE_PUBLIC (e->decl) && !DECL_EXTERNAL (e->decl))
- || (ce != NULL && ce->global.inlined_to))
+ || (ce != NULL && ce->inlined_to))
continue;
symtab_node *to = symtab_node::get (lto_symtab_prevailing_decl (e->decl));
diff --git a/gcc/omp-simd-clone.c b/gcc/omp-simd-clone.c
index d71a963443b..f4bfcc8b8b8 100644
--- a/gcc/omp-simd-clone.c
+++ b/gcc/omp-simd-clone.c
@@ -1645,7 +1645,7 @@ expand_simd_clones (struct cgraph_node *node)
tree attr = lookup_attribute ("omp declare simd",
DECL_ATTRIBUTES (node->decl));
if (attr == NULL_TREE
- || node->global.inlined_to
+ || node->inlined_to
|| lookup_attribute ("noclone", DECL_ATTRIBUTES (node->decl)))
return;
diff --git a/gcc/passes.c b/gcc/passes.c
index 863605da292..d86af115ecb 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -3033,7 +3033,7 @@ function_called_by_processed_nodes_p (void)
continue;
if (TREE_ASM_WRITTEN (e->caller->decl))
continue;
- if (!e->caller->process && !e->caller->global.inlined_to)
+ if (!e->caller->process && !e->caller->inlined_to)
break;
}
if (dump_file && e)
diff --git a/gcc/symtab.c b/gcc/symtab.c
index ee9723c3453..a75f516831e 100644
--- a/gcc/symtab.c
+++ b/gcc/symtab.c
@@ -1921,7 +1921,7 @@ symtab_node::get_partitioning_class (void)
if (DECL_ABSTRACT_P (decl))
return SYMBOL_EXTERNAL;
- if (cnode && cnode->global.inlined_to)
+ if (cnode && cnode->inlined_to)
return SYMBOL_DUPLICATE;
/* Transparent aliases are always duplicated. */
@@ -2321,7 +2321,7 @@ symtab_node::binds_to_current_def_p (symtab_node *ref)
return true;
/* Inline clones always binds locally. */
- if (cnode && cnode->global.inlined_to)
+ if (cnode && cnode->inlined_to)
return true;
if (DECL_EXTERNAL (decl))
@@ -2333,7 +2333,7 @@ symtab_node::binds_to_current_def_p (symtab_node *ref)
{
cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
if (cref)
- ref = cref->global.inlined_to;
+ ref = cref->inlined_to;
}
/* If this is a reference from symbol itself and there are no aliases, we
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index 75c6faedc1f..6e7d4dbc5b3 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -7959,7 +7959,7 @@ associate_varinfo_to_alias (struct cgraph_node *node, void *data)
{
if ((node->alias
|| (node->thunk.thunk_p
- && ! node->global.inlined_to))
+ && ! node->inlined_to))
&& node->analyzed
&& !node->ifunc_resolver)
insert_vi_for_tree (node->decl, (varinfo_t)data);
@@ -8129,7 +8129,7 @@ ipa_pta_execute (void)
/* Nodes without a body are not interesting. Especially do not
visit clones at this point for now - we get duplicate decls
there for inline clones at least. */
- if (!node->has_gimple_body_p () || node->global.inlined_to)
+ if (!node->has_gimple_body_p () || node->inlined_to)
continue;
node->get_body ();
