[3/4] First usage of cgraph_summary in ipa-prop pass.

On 11/14/2014 04:23 PM, Martin Liška wrote:
> On 11/14/2014 03:05 PM, Martin Liška wrote:
>> On 11/11/2014 01:26 PM, mliska wrote:
>>> gcc/ChangeLog:
>>>
>>> 2014-11-12  Martin Liska  <mliska@suse.cz>
>>>
>>>     * auto-profile.c: Include cgraph_summary.h.
>>>     * cgraph.c: Likewise.
>>>     * cgraphbuild.c: Likewise.
>>>     * cgraphclones.c: Likewise.
>>>     * cgraphunit.c: Likewise.
>>>     * ipa-cp.c: Likewise.
>>>     * ipa-devirt.c: Likewise.
>>>     * ipa-icf.c: Likewise.
>>>     * ipa-inline-analysis.c (evaluate_properties_for_edge): Usage of
>>>     ipa_node_params_vector is replaced with ipa_node_params_summary.
>>>     (inline_node_duplication_hook): Likewise.
>>>     (estimate_function_body_sizes): Likewise.
>>>     (remap_edge_change_prob): Likewise.
>>>     (inline_merge_summary): Likewise.
>>>     * ipa-inline-transform.c: Include of cgraph_summary.h.
>>>     * ipa-inline.c (early_inliner): Usage of
>>>     ipa_node_params_vector is replaced with ipa_node_params_summary.
>>>     * ipa-polymorphic-call.c: Include of cgraph_summary.h.
>>>     * ipa-profile.c: Include of cgraph_summary.h.
>>>     * ipa-prop.c (struct func_body_info): Struct keyword is removed.
>>>     (struct ipa_cst_ref_desc): Likewise.
>>>     (ipa_func_spec_opts_forbid_analysis_p): Likewise.
>>>     (ipa_alloc_node_params): Likewise.
>>>     (ipa_initialize_node_params): Likewise.
>>>     (ipa_print_node_jump_functions_for_edge): Likewise.
>>>     (ipa_print_node_jump_functions): Likewise.
>>>     (ipa_print_all_jump_functions): Likewise.
>>>     (ipa_set_jf_constant): Likewise.
>>>     (check_stmt_for_type_change): Likewise.
>>>     (detect_type_change_from_memory_writes): Likewise.
>>>     (find_dominating_aa_status): Likewise.
>>>     (parm_bb_aa_status_for_bb): Likewise.
>>>     (parm_preserved_before_stmt_p): Likewise.
>>>     (parm_ref_data_preserved_p): Likewise.
>>>     (parm_ref_data_pass_through_p): Likewise.
>>>     (struct ipa_known_agg_contents_list): Likewise.
>>>     (get_place_in_agg_contents_list): Likewise.
>>>     (build_agg_jump_func_from_list): Likewise.
>>>     (determine_locally_known_aggregate_parts): Likewise.
>>>     (ipa_compute_jump_functions_for_edge): Likewise.
>>>     (ipa_compute_jump_functions_for_bb): Likewise.
>>>     (ipa_note_param_call): Likewise.
>>>     (ipa_analyze_indirect_call_uses) Likewise.:
>>>     (ipa_analyze_virtual_call_uses): Likewise.
>>>     (ipa_analyze_call_uses): Likewise.
>>>     (visit_ref_for_mod_analysis): Likewise.
>>>     (ipa_analyze_controlled_uses): Likewise.
>>>     (ipa_analyze_node): Likewise.
>>>     (update_jump_functions_after_inlining): Likewise.
>>>     (ipa_make_edge_direct_to_target): Likewise.
>>>     (ipa_find_agg_cst_for_param): Likewise.
>>>     (remove_described_reference): Likewise.
>>>     (jfunc_rdesc_usable): Likewise.
>>>     (try_decrement_rdesc_refcount): Likewise.
>>>     (try_make_edge_direct_simple_call): Likewise.
>>>     (try_make_edge_direct_virtual_call): Likewise.
>>>     (update_indirect_edges_after_inlining): Likewise.
>>>     (propagate_info_to_inlined_callees): Likewise.
>>>     (propagate_controlled_uses): Likewise.
>>>     (ipa_propagate_indirect_call_infos): Likewise.
>>>     (ipa_free_all_edge_args): Likewise.
>>>     (ipa_node_params::~ipa_node_params): Likewise.
>>>     (ipa_free_all_node_params): Likewise.
>>>     (ipa_edge_removal_hook): Likewise.
>>>     (ipa_node_removal_hook): Likewise.
>>>     (ipa_edge_duplication_hook): Likewise.
>>>     (ipa_add_new_function): Removed
>>>     (ipa_node_params_cgraph_summary::duplication_hook): New function.
>>>     (ipa_node_duplication_hook): Struct keyword removed.
>>>     (ipa_register_cgraph_hooks): Removal of old hooks.
>>>     (ipa_unregister_cgraph_hooks): Likewise.
>>>     (ipa_print_node_params): Struct keyword is removed.
>>>     (ipa_print_all_params): Likewise.
>>>     (ipa_modify_formal_parameters): Likewise.
>>>     (ipa_modify_call_arguments): Likewise.
>>>     (ipa_modify_expr): Likewise.
>>>     (ipa_get_adjustment_candidate): Likewise.
>>>     (index_in_adjustments_multiple_times_p): Likewise.
>>>     (ipa_combine_adjustments): Likewise.
>>>     (ipa_dump_param_adjustments): Likewise.
>>>     (ipa_write_jump_function): Likewise.
>>>     (ipa_read_jump_function): Likewise.
>>>     (ipa_write_indirect_edge_info): Likewise.
>>>     (ipa_read_indirect_edge_info): Likewise.
>>>     (ipa_write_node_info): Likewise.
>>>     (ipa_read_node_info): Likewise.
>>>     (ipa_prop_write_jump_functions): Likewise.
>>>     (ipa_prop_read_section): Likewise.
>>>     (ipa_prop_read_jump_functions): Likewise.
>>>     (write_agg_replacement_chain): Likewise.
>>>     (read_agg_replacement_chain): Likewise.
>>>     (ipa_prop_write_all_agg_replacement): Likewise.
>>>     (read_replacements_section): Likewise.
>>>     (ipa_prop_read_all_agg_replacement): Likewise.
>>>     (adjust_agg_replacement_values): Likewise.
>>>     (ipcp_modif_dom_walker::before_dom_children): Likewise.
>>>     (ipcp_transform_function): Likewise.
>>>     * ipa-prop.h (struct ipa_node_params): Introduction of new class
>>>     ipa_node_params_cgraph_summary.
>>>     * ipa-split.c: Include cgraph_summary.h.
>>>     * ipa-utils.c: Likewise.
>>>     * ipa.c: Likewise.
>>>     * omp-low.c: Likewise.
>>>     * tree-inline.c: Likewise.
>>>     * tree-sra.c: Likewise.
>>>     * tree-ssa-pre.c: Likewise.
>>>
>>> gcc/lto/ChangeLog:
>>>
>>> 2014-11-12  Martin Liska  <mliska@suse.cz>
>>>
>>>     * lto-partition.c: Include cgraph_summary.h.
>>>     * lto-symtab.c: Likewise.
>>>     * lto.c: Likewise.
>>> ---
>>>   gcc/auto-profile.c         |   1 +
>>>   gcc/cgraph.c               |   1 +
>>>   gcc/cgraphbuild.c          |   1 +
>>>   gcc/cgraphclones.c         |   1 +
>>>   gcc/cgraphunit.c           |   1 +
>>>   gcc/ipa-cp.c               |   1 +
>>>   gcc/ipa-devirt.c           |   1 +
>>>   gcc/ipa-icf.c              |   1 +
>>>   gcc/ipa-inline-analysis.c  |  13 +-
>>>   gcc/ipa-inline-transform.c |   1 +
>>>   gcc/ipa-inline.c           |   3 +-
>>>   gcc/ipa-polymorphic-call.c |   1 +
>>>   gcc/ipa-profile.c          |   1 +
>>>   gcc/ipa-prop.c             | 700 ++++++++++++++++++++++-----------------------
>>>   gcc/ipa-prop.h             |  46 +--
>>>   gcc/ipa-split.c            |   1 +
>>>   gcc/ipa-utils.c            |   1 +
>>>   gcc/ipa.c                  |   1 +
>>>   gcc/lto/lto-partition.c    |   1 +
>>>   gcc/lto/lto-symtab.c       |   1 +
>>>   gcc/lto/lto.c              |   1 +
>>>   gcc/omp-low.c              |   1 +
>>>   gcc/tree-inline.c          |   1 +
>>>   gcc/tree-sra.c             |   1 +
>>>   gcc/tree-ssa-pre.c         |   1 +
>>>   25 files changed, 397 insertions(+), 386 deletions(-)
>>>
>>> diff --git a/gcc/auto-profile.c b/gcc/auto-profile.c
>>> index 8c7b4ca..49f9b8c 100644
>>> --- a/gcc/auto-profile.c
>>> +++ b/gcc/auto-profile.c
>>> @@ -67,6 +67,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "coverage.h"
>>>   #include "params.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "tree-inline.h"
>>> diff --git a/gcc/cgraph.c b/gcc/cgraph.c
>>> index 7216b89..af1835a 100644
>>> --- a/gcc/cgraph.c
>>> +++ b/gcc/cgraph.c
>>> @@ -72,6 +72,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-utils.h"
>>>   #include "lto-streamer.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "cfgloop.h"
>>> diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c
>>> index c72ceab..a93b0aa 100644
>>> --- a/gcc/cgraphbuild.c
>>> +++ b/gcc/cgraphbuild.c
>>> @@ -52,6 +52,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-utils.h"
>>>   #include "except.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>
>>> diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c
>>> index c8892da..79f95ef 100644
>>> --- a/gcc/cgraphclones.c
>>> +++ b/gcc/cgraphclones.c
>>> @@ -103,6 +103,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "tree-iterator.h"
>>>   #include "tree-dump.h"
>>> diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
>>> index 25af234..dbbdc44 100644
>>> --- a/gcc/cgraphunit.c
>>> +++ b/gcc/cgraphunit.c
>>> @@ -204,6 +204,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "tree-iterator.h"
>>>   #include "tree-pass.h"
>>> diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c
>>> index 47f9f5c..da589af 100644
>>> --- a/gcc/ipa-cp.c
>>> +++ b/gcc/ipa-cp.c
>>> @@ -123,6 +123,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "bitmap.h"
>>>   #include "tree-pass.h"
>>> diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
>>> index 32c6549..8e1f9ce 100644
>>> --- a/gcc/ipa-devirt.c
>>> +++ b/gcc/ipa-devirt.c
>>> @@ -139,6 +139,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "gimple-expr.h"
>>>   #include "gimple.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "diagnostic.h"
>>> diff --git a/gcc/ipa-icf.c b/gcc/ipa-icf.c
>>> index 92ec82d..9778323 100644
>>> --- a/gcc/ipa-icf.c
>>> +++ b/gcc/ipa-icf.c
>>> @@ -87,6 +87,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "cfgloop.h"
>>> diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
>>> index eb1c6ec..c7a52d2 100644
>>> --- a/gcc/ipa-inline-analysis.c
>>> +++ b/gcc/ipa-inline-analysis.c
>>> @@ -110,6 +110,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "lto-streamer.h"
>>>   #include "data-streamer.h"
>>> @@ -910,7 +911,7 @@ evaluate_properties_for_edge (struct cgraph_edge *e, bool inline_p,
>>>     if (known_binfos_ptr)
>>>       known_binfos_ptr->create (0);
>>>
>>> -  if (ipa_node_params_vector.exists ()
>>> +  if (ipa_node_params_summary
>>>         && !e->call_stmt_cannot_inline_p
>>>         && ((clause_ptr && info->conds) || known_vals_ptr || known_binfos_ptr))
>>>       {
>>> @@ -1130,7 +1131,7 @@ inline_node_duplication_hook (struct cgraph_node *src,
>>>
>>>     /* When there are any replacements in the function body, see if we can figure
>>>        out that something was optimized out.  */
>>> -  if (ipa_node_params_vector.exists () && dst->clone.tree_map)
>>> +  if (ipa_node_params_summary && dst->clone.tree_map)
>>>       {
>>>         vec<size_time_entry, va_gc> *entry = info->entry;
>>>         /* Use SRC parm info since it may not be copied yet.  */
>>> @@ -2476,7 +2477,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
>>>         calculate_dominance_info (CDI_DOMINATORS);
>>>         loop_optimizer_init (LOOPS_NORMAL | LOOPS_HAVE_RECORDED_EXITS);
>>>
>>> -      if (ipa_node_params_vector.exists ())
>>> +      if (ipa_node_params_summary)
>>>       {
>>>         parms_info = IPA_NODE_REF (node);
>>>         nonconstant_names.safe_grow_cleared
>>> @@ -2624,7 +2625,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
>>>             nonconstant_names[SSA_NAME_VERSION (gimple_call_lhs (stmt))]
>>>               = false_p;
>>>           }
>>> -          if (ipa_node_params_vector.exists ())
>>> +          if (ipa_node_params_summary)
>>>           {
>>>             int count = gimple_call_num_args (stmt);
>>>             int i;
>>> @@ -3367,7 +3368,7 @@ static void
>>>   remap_edge_change_prob (struct cgraph_edge *inlined_edge,
>>>               struct cgraph_edge *edge)
>>>   {
>>> -  if (ipa_node_params_vector.exists ())
>>> +  if (ipa_node_params_summary)
>>>       {
>>>         int i;
>>>         struct ipa_edge_args *args = IPA_EDGE_REF (edge);
>>> @@ -3523,7 +3524,7 @@ inline_merge_summary (struct cgraph_edge *edge)
>>>     else
>>>       toplev_predicate = true_predicate ();
>>>
>>> -  if (ipa_node_params_vector.exists () && callee_info->conds)
>>> +  if (ipa_node_params_summary && callee_info->conds)
>>>       {
>>>         struct ipa_edge_args *args = IPA_EDGE_REF (edge);
>>>         int count = ipa_get_cs_argument_count (args);
>>> diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c
>>> index dbc56c5..fd700ff 100644
>>> --- a/gcc/ipa-inline-transform.c
>>> +++ b/gcc/ipa-inline-transform.c
>>> @@ -51,6 +51,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "tree-inline.h"
>>> diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
>>> index 5c97815..8a08cd4 100644
>>> --- a/gcc/ipa-inline.c
>>> +++ b/gcc/ipa-inline.c
>>> @@ -129,6 +129,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "except.h"
>>>   #include "target.h"
>>> @@ -2400,7 +2401,7 @@ early_inliner (function *fun)
>>>        it.  This may confuse ourself when early inliner decide to inline call to
>>>        function clone, because function clones don't have parameter list in
>>>        ipa-prop matching their signature.  */
>>> -  if (ipa_node_params_vector.exists ())
>>> +  if (ipa_node_params_summary)
>>>       return 0;
>>>
>>>   #ifdef ENABLE_CHECKING
>>> diff --git a/gcc/ipa-polymorphic-call.c b/gcc/ipa-polymorphic-call.c
>>> index 33dd1a8..e0555f2 100644
>>> --- a/gcc/ipa-polymorphic-call.c
>>> +++ b/gcc/ipa-polymorphic-call.c
>>> @@ -52,6 +52,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "gimple-expr.h"
>>>   #include "gimple.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "diagnostic.h"
>>> diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c
>>> index b83d1cf..4fdee09 100644
>>> --- a/gcc/ipa-profile.c
>>> +++ b/gcc/ipa-profile.c
>>> @@ -82,6 +82,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "tree-inline.h"
>>>   #include "lto-streamer.h"
>>>   #include "data-streamer.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>
>>> diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
>>> index db85c7d..ce9745e 100644
>>> --- a/gcc/ipa-prop.c
>>> +++ b/gcc/ipa-prop.c
>>> @@ -54,6 +54,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "bitmap.h"
>>>   #include "gimple-ssa.h"
>>> @@ -119,7 +120,7 @@ struct func_body_info
>>>     cgraph_node *node;
>>>
>>>     /* Its info.  */
>>> -  struct ipa_node_params *info;
>>> +  ipa_node_params *info;
>>>
>>>     /* Information about individual BBs. */
>>>     vec<ipa_bb_info> bb_infos;
>>> @@ -131,7 +132,8 @@ struct func_body_info
>>>     unsigned int aa_walked;
>>>   };
>>>
>>> -/* Vector where the parameter infos are actually stored. */
>>> +/* Callgraph summary where the parameter infos are actually stored. */
>>> +ipa_node_params_cgraph_summary *ipa_node_params_summary = NULL;
>>>   vec<ipa_node_params> ipa_node_params_vector;
>>>   /* Vector of known aggregate values in cloned nodes.  */
>>>   vec<ipa_agg_replacement_value_p, va_gc> *ipa_node_agg_replacements;
>>> @@ -139,19 +141,17 @@ vec<ipa_agg_replacement_value_p, va_gc> *ipa_node_agg_replacements;
>>>   vec<ipa_edge_args, va_gc> *ipa_edge_args_vector;
>>>
>>>   /* Holders of ipa cgraph hooks: */
>>> -static struct cgraph_edge_hook_list *edge_removal_hook_holder;
>>> -static struct cgraph_node_hook_list *node_removal_hook_holder;
>>> -static struct cgraph_2edge_hook_list *edge_duplication_hook_holder;
>>> -static struct cgraph_2node_hook_list *node_duplication_hook_holder;
>>> -static struct cgraph_node_hook_list *function_insertion_hook_holder;
>>> +static cgraph_edge_hook_list *edge_removal_hook_holder;
>>> +static cgraph_2edge_hook_list *edge_duplication_hook_holder;
>>> +static cgraph_node_hook_list *function_insertion_hook_holder;
>>>
>>>   /* Description of a reference to an IPA constant.  */
>>>   struct ipa_cst_ref_desc
>>>   {
>>>     /* Edge that corresponds to the statement which took the reference.  */
>>> -  struct cgraph_edge *cs;
>>> +  cgraph_edge *cs;
>>>     /* Linked list of duplicates created when call graph edges are cloned.  */
>>> -  struct ipa_cst_ref_desc *next_duplicate;
>>> +  ipa_cst_ref_desc *next_duplicate;
>>>     /* Number of references in IPA structures, IPA_UNDESCRIBED_USE if the value
>>>        if out of control.  */
>>>     int refcount;
>>> @@ -165,10 +165,10 @@ static alloc_pool ipa_refdesc_pool;
>>>      with NODE should prevent us from analyzing it for the purposes of IPA-CP.  */
>>>
>>>   static bool
>>> -ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node *node)
>>> +ipa_func_spec_opts_forbid_analysis_p (cgraph_node *node)
>>>   {
>>>     tree fs_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node->decl);
>>> -  struct cl_optimization *os;
>>> +  cl_optimization *os;
>>>
>>>     if (!fs_opts)
>>>       return false;
>>> @@ -196,7 +196,7 @@ ipa_get_param_decl_index_1 (vec<ipa_param_descriptor> descriptors, tree ptree)
>>>      to INFO.  */
>>>
>>>   int
>>> -ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
>>> +ipa_get_param_decl_index (ipa_node_params *info, tree ptree)
>>>   {
>>>     return ipa_get_param_decl_index_1 (info->descriptors, ptree);
>>>   }
>>> @@ -205,7 +205,7 @@ ipa_get_param_decl_index (struct ipa_node_params *info, tree ptree)
>>>      NODE.  */
>>>
>>>   static void
>>> -ipa_populate_param_decls (struct cgraph_node *node,
>>> +ipa_populate_param_decls (cgraph_node *node,
>>>                 vec<ipa_param_descriptor> &descriptors)
>>>   {
>>>     tree fndecl;
>>> @@ -246,7 +246,7 @@ count_formal_params (tree fndecl)
>>>      using ipa_initialize_node_params. */
>>>
>>>   void
>>> -ipa_dump_param (FILE *file, struct ipa_node_params *info, int i)
>>> +ipa_dump_param (FILE *file, ipa_node_params *info, int i)
>>>   {
>>>     fprintf (file, "param #%i", i);
>>>     if (info->descriptors[i].decl)
>>> @@ -260,9 +260,9 @@ ipa_dump_param (FILE *file, struct ipa_node_params *info, int i)
>>>      to hold PARAM_COUNT parameters.  */
>>>
>>>   void
>>> -ipa_alloc_node_params (struct cgraph_node *node, int param_count)
>>> +ipa_alloc_node_params (cgraph_node *node, int param_count)
>>>   {
>>> -  struct ipa_node_params *info = IPA_NODE_REF (node);
>>> +  ipa_node_params *info = IPA_NODE_REF (node);
>>>
>>>     if (!info->descriptors.exists () && param_count)
>>>       info->descriptors.safe_grow_cleared (param_count);
>>> @@ -273,9 +273,9 @@ ipa_alloc_node_params (struct cgraph_node *node, int param_count)
>>>      param_decls.  */
>>>
>>>   void
>>> -ipa_initialize_node_params (struct cgraph_node *node)
>>> +ipa_initialize_node_params (cgraph_node *node)
>>>   {
>>> -  struct ipa_node_params *info = IPA_NODE_REF (node);
>>> +  ipa_node_params *info = IPA_NODE_REF (node);
>>>
>>>     if (!info->descriptors.exists ())
>>>       {
>>> @@ -287,14 +287,14 @@ ipa_initialize_node_params (struct cgraph_node *node)
>>>   /* Print the jump functions associated with call graph edge CS to file F.  */
>>>
>>>   static void
>>> -ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
>>> +ipa_print_node_jump_functions_for_edge (FILE *f, cgraph_edge *cs)
>>>   {
>>>     int i, count;
>>>
>>>     count = ipa_get_cs_argument_count (IPA_EDGE_REF (cs));
>>>     for (i = 0; i < count; i++)
>>>       {
>>> -      struct ipa_jump_func *jump_func;
>>> +      ipa_jump_func *jump_func;
>>>         enum jump_func_type type;
>>>
>>>         jump_func = ipa_get_ith_jump_func (IPA_EDGE_REF (cs), i);
>>> @@ -360,7 +360,7 @@ ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
>>>
>>>         if (jump_func->agg.items)
>>>       {
>>> -      struct ipa_agg_jf_item *item;
>>> +      ipa_agg_jf_item *item;
>>>         int j;
>>>
>>>         fprintf (f, "         Aggregate passed by %s:\n",
>>> @@ -390,9 +390,9 @@ ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
>>>      NODE to file F.  */
>>>
>>>   void
>>> -ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
>>> +ipa_print_node_jump_functions (FILE *f, cgraph_node *node)
>>>   {
>>> -  struct cgraph_edge *cs;
>>> +  cgraph_edge *cs;
>>>
>>>     fprintf (f, "  Jump functions of caller  %s/%i:\n", node->name (),
>>>          node->order);
>>> @@ -410,7 +410,7 @@ ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
>>>
>>>     for (cs = node->indirect_calls; cs; cs = cs->next_callee)
>>>       {
>>> -      struct cgraph_indirect_call_info *ii;
>>> +      cgraph_indirect_call_info *ii;
>>>         if (!ipa_edge_args_info_available_for_edge_p (cs))
>>>       continue;
>>>
>>> @@ -445,7 +445,7 @@ ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
>>>   void
>>>   ipa_print_all_jump_functions (FILE *f)
>>>   {
>>> -  struct cgraph_node *node;
>>> +  cgraph_node *node;
>>>
>>>     fprintf (f, "\nJump functions:\n");
>>>     FOR_EACH_FUNCTION (node)
>>> @@ -457,7 +457,7 @@ ipa_print_all_jump_functions (FILE *f)
>>>   /* Set JFUNC to be a known type jump function.  */
>>>
>>>   static void
>>> -ipa_set_jf_known_type (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
>>> +ipa_set_jf_known_type (ipa_jump_func *jfunc, HOST_WIDE_INT offset,
>>>                  tree base_type, tree component_type)
>>>   {
>>>     /* Recording and propagating main variants increases change that types
>>> @@ -480,8 +480,8 @@ ipa_set_jf_known_type (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
>>>      combination code).  The two functions will share their rdesc.  */
>>>
>>>   static void
>>> -ipa_set_jf_cst_copy (struct ipa_jump_func *dst,
>>> -             struct ipa_jump_func *src)
>>> +ipa_set_jf_cst_copy (ipa_jump_func *dst,
>>> +             ipa_jump_func *src)
>>>
>>>   {
>>>     gcc_checking_assert (src->type == IPA_JF_CONST);
>>> @@ -492,8 +492,8 @@ ipa_set_jf_cst_copy (struct ipa_jump_func *dst,
>>>   /* Set JFUNC to be a constant jmp function.  */
>>>
>>>   static void
>>> -ipa_set_jf_constant (struct ipa_jump_func *jfunc, tree constant,
>>> -             struct cgraph_edge *cs)
>>> +ipa_set_jf_constant (ipa_jump_func *jfunc, tree constant,
>>> +             cgraph_edge *cs)
>>>   {
>>>     constant = unshare_expr (constant);
>>>     if (constant && EXPR_P (constant))
>>> @@ -504,12 +504,12 @@ ipa_set_jf_constant (struct ipa_jump_func *jfunc, tree constant,
>>>     if (TREE_CODE (constant) == ADDR_EXPR
>>>         && TREE_CODE (TREE_OPERAND (constant, 0)) == FUNCTION_DECL)
>>>       {
>>> -      struct ipa_cst_ref_desc *rdesc;
>>> +      ipa_cst_ref_desc *rdesc;
>>>         if (!ipa_refdesc_pool)
>>>       ipa_refdesc_pool = create_alloc_pool ("IPA-PROP ref descriptions",
>>> -                    sizeof (struct ipa_cst_ref_desc), 32);
>>> +                    sizeof (ipa_cst_ref_desc), 32);
>>>
>>> -      rdesc = (struct ipa_cst_ref_desc *) pool_alloc (ipa_refdesc_pool);
>>> +      rdesc = (ipa_cst_ref_desc *) pool_alloc (ipa_refdesc_pool);
>>>         rdesc->cs = cs;
>>>         rdesc->next_duplicate = NULL;
>>>         rdesc->refcount = 1;
>>> @@ -521,7 +521,7 @@ ipa_set_jf_constant (struct ipa_jump_func *jfunc, tree constant,
>>>
>>>   /* Set JFUNC to be a simple pass-through jump function.  */
>>>   static void
>>> -ipa_set_jf_simple_pass_through (struct ipa_jump_func *jfunc, int formal_id,
>>> +ipa_set_jf_simple_pass_through (ipa_jump_func *jfunc, int formal_id,
>>>                   bool agg_preserved, bool type_preserved)
>>>   {
>>>     jfunc->type = IPA_JF_PASS_THROUGH;
>>> @@ -535,7 +535,7 @@ ipa_set_jf_simple_pass_through (struct ipa_jump_func *jfunc, int formal_id,
>>>   /* Set JFUNC to be an arithmetic pass through jump function.  */
>>>
>>>   static void
>>> -ipa_set_jf_arith_pass_through (struct ipa_jump_func *jfunc, int formal_id,
>>> +ipa_set_jf_arith_pass_through (ipa_jump_func *jfunc, int formal_id,
>>>                      tree operand, enum tree_code operation)
>>>   {
>>>     jfunc->type = IPA_JF_PASS_THROUGH;
>>> @@ -549,7 +549,7 @@ ipa_set_jf_arith_pass_through (struct ipa_jump_func *jfunc, int formal_id,
>>>   /* Set JFUNC to be an ancestor jump function.  */
>>>
>>>   static void
>>> -ipa_set_ancestor_jf (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
>>> +ipa_set_ancestor_jf (ipa_jump_func *jfunc, HOST_WIDE_INT offset,
>>>                tree type, int formal_id, bool agg_preserved,
>>>                bool type_preserved)
>>>   {
>>> @@ -572,7 +572,7 @@ ipa_set_ancestor_jf (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
>>>      jump function.  */
>>>
>>>   tree
>>> -ipa_binfo_from_known_type_jfunc (struct ipa_jump_func *jfunc)
>>> +ipa_binfo_from_known_type_jfunc (ipa_jump_func *jfunc)
>>>   {
>>>     if (!RECORD_OR_UNION_TYPE_P (jfunc->value.known_type.base_type))
>>>       return NULL_TREE;
>>> @@ -602,8 +602,8 @@ ipa_binfo_from_known_type_jfunc (struct ipa_jump_func *jfunc)
>>>   /* Get IPA BB information about the given BB.  FBI is the context of analyzis
>>>      of this function body.  */
>>>
>>> -static struct ipa_bb_info *
>>> -ipa_get_bb_info (struct func_body_info *fbi, basic_block bb)
>>> +static ipa_bb_info *
>>> +ipa_get_bb_info (func_body_info *fbi, basic_block bb)
>>>   {
>>>     gcc_checking_assert (fbi);
>>>     return &fbi->bb_infos[bb->index];
>>> @@ -700,7 +700,7 @@ stmt_may_be_vtbl_ptr_store (gimple stmt)
>>>      identified, return the type.  Otherwise return NULL_TREE.  */
>>>
>>>   static tree
>>> -extr_type_from_vtbl_ptr_store (gimple stmt, struct prop_type_change_info *tci)
>>> +extr_type_from_vtbl_ptr_store (gimple stmt, prop_type_change_info *tci)
>>>   {
>>>     HOST_WIDE_INT offset, size, max_size;
>>>     tree lhs, rhs, base, binfo;
>>> @@ -752,7 +752,7 @@ static bool
>>>   check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
>>>   {
>>>     gimple stmt = SSA_NAME_DEF_STMT (vdef);
>>> -  struct prop_type_change_info *tci = (struct prop_type_change_info *) data;
>>> +  prop_type_change_info *tci = (prop_type_change_info *) data;
>>>
>>>     if (stmt_may_be_vtbl_ptr_store (stmt))
>>>       {
>>> @@ -847,10 +847,10 @@ param_type_may_change_p (tree function, tree arg, gimple call)
>>>
>>>   static bool
>>>   detect_type_change_from_memory_writes (tree arg, tree base, tree comp_type,
>>> -                       gimple call, struct ipa_jump_func *jfunc,
>>> +                       gimple call, ipa_jump_func *jfunc,
>>>                          HOST_WIDE_INT offset)
>>>   {
>>> -  struct prop_type_change_info tci;
>>> +  prop_type_change_info tci;
>>>     ao_ref ao;
>>>     bool entry_reached = false;
>>>
>>> @@ -908,7 +908,7 @@ detect_type_change_from_memory_writes (tree arg, tree base, tree comp_type,
>>>
>>>   static bool
>>>   detect_type_change (tree arg, tree base, tree comp_type, gimple call,
>>> -            struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
>>> +            ipa_jump_func *jfunc, HOST_WIDE_INT offset)
>>>   {
>>>     if (!flag_devirtualize)
>>>       return false;
>>> @@ -928,7 +928,7 @@ detect_type_change (tree arg, tree base, tree comp_type, gimple call,
>>>
>>>   static bool
>>>   detect_type_change_ssa (tree arg, tree comp_type,
>>> -            gimple call, struct ipa_jump_func *jfunc)
>>> +            gimple call, ipa_jump_func *jfunc)
>>>   {
>>>     gcc_checking_assert (TREE_CODE (arg) == SSA_NAME);
>>>     if (!flag_devirtualize
>>> @@ -961,7 +961,7 @@ mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
>>>      should really just start giving up.  */
>>>
>>>   static bool
>>> -aa_overwalked (struct func_body_info *fbi)
>>> +aa_overwalked (func_body_info *fbi)
>>>   {
>>>     gcc_checking_assert (fbi);
>>>     return fbi->aa_walked > (unsigned) PARAM_VALUE (PARAM_IPA_MAX_AA_STEPS);
>>> @@ -970,8 +970,8 @@ aa_overwalked (struct func_body_info *fbi)
>>>   /* Find the nearest valid aa status for parameter specified by INDEX that
>>>      dominates BB.  */
>>>
>>> -static struct param_aa_status *
>>> -find_dominating_aa_status (struct func_body_info *fbi, basic_block bb,
>>> +static param_aa_status *
>>> +find_dominating_aa_status (func_body_info *fbi, basic_block bb,
>>>                  int index)
>>>   {
>>>     while (true)
>>> @@ -979,7 +979,7 @@ find_dominating_aa_status (struct func_body_info *fbi, basic_block bb,
>>>         bb = get_immediate_dominator (CDI_DOMINATORS, bb);
>>>         if (!bb)
>>>       return NULL;
>>> -      struct ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
>>> +      ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
>>>         if (!bi->param_aa_statuses.is_empty ()
>>>         && bi->param_aa_statuses[index].valid)
>>>       return &bi->param_aa_statuses[index];
>>> @@ -990,21 +990,21 @@ find_dominating_aa_status (struct func_body_info *fbi, basic_block bb,
>>>      structures and/or intialize the result with a dominating description as
>>>      necessary.  */
>>>
>>> -static struct param_aa_status *
>>> -parm_bb_aa_status_for_bb (struct func_body_info *fbi, basic_block bb,
>>> +static param_aa_status *
>>> +parm_bb_aa_status_for_bb (func_body_info *fbi, basic_block bb,
>>>                 int index)
>>>   {
>>>     gcc_checking_assert (fbi);
>>> -  struct ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
>>> +  ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
>>>     if (bi->param_aa_statuses.is_empty ())
>>>       bi->param_aa_statuses.safe_grow_cleared (fbi->param_count);
>>> -  struct param_aa_status *paa = &bi->param_aa_statuses[index];
>>> +  param_aa_status *paa = &bi->param_aa_statuses[index];
>>>     if (!paa->valid)
>>>       {
>>>         gcc_checking_assert (!paa->parm_modified
>>>                  && !paa->ref_modified
>>>                  && !paa->pt_modified);
>>> -      struct param_aa_status *dom_paa;
>>> +      param_aa_status *dom_paa;
>>>         dom_paa = find_dominating_aa_status (fbi, bb, index);
>>>         if (dom_paa)
>>>       *paa = *dom_paa;
>>> @@ -1021,10 +1021,10 @@ parm_bb_aa_status_for_bb (struct func_body_info *fbi, basic_block bb,
>>>      gathered but do not survive the summary building stage.  */
>>>
>>>   static bool
>>> -parm_preserved_before_stmt_p (struct func_body_info *fbi, int index,
>>> +parm_preserved_before_stmt_p (func_body_info *fbi, int index,
>>>                     gimple stmt, tree parm_load)
>>>   {
>>> -  struct param_aa_status *paa;
>>> +  param_aa_status *paa;
>>>     bool modified = false;
>>>     ao_ref refd;
>>>
>>> @@ -1060,7 +1060,7 @@ parm_preserved_before_stmt_p (struct func_body_info *fbi, int index,
>>>      modified.  Otherwise return -1.  */
>>>
>>>   static int
>>> -load_from_unmodified_param (struct func_body_info *fbi,
>>> +load_from_unmodified_param (func_body_info *fbi,
>>>                   vec<ipa_param_descriptor> descriptors,
>>>                   gimple stmt)
>>>   {
>>> @@ -1087,10 +1087,10 @@ load_from_unmodified_param (struct func_body_info *fbi,
>>>      before reaching statement STMT.  */
>>>
>>>   static bool
>>> -parm_ref_data_preserved_p (struct func_body_info *fbi,
>>> +parm_ref_data_preserved_p (func_body_info *fbi,
>>>                  int index, gimple stmt, tree ref)
>>>   {
>>> -  struct param_aa_status *paa;
>>> +  param_aa_status *paa;
>>>     bool modified = false;
>>>     ao_ref refd;
>>>
>>> @@ -1126,7 +1126,7 @@ parm_ref_data_preserved_p (struct func_body_info *fbi,
>>>      CALL into which it is passed.  FBI describes the function body.  */
>>>
>>>   static bool
>>> -parm_ref_data_pass_through_p (struct func_body_info *fbi, int index,
>>> +parm_ref_data_pass_through_p (func_body_info *fbi, int index,
>>>                     gimple call, tree parm)
>>>   {
>>>     bool modified = false;
>>> @@ -1140,7 +1140,7 @@ parm_ref_data_pass_through_p (struct func_body_info *fbi, int index,
>>>         || aa_overwalked (fbi))
>>>       return false;
>>>
>>> -  struct param_aa_status *paa = parm_bb_aa_status_for_bb (fbi, gimple_bb (call),
>>> +  param_aa_status *paa = parm_bb_aa_status_for_bb (fbi, gimple_bb (call),
>>>                                 index);
>>>     if (paa->pt_modified)
>>>       return false;
>>> @@ -1165,7 +1165,7 @@ parm_ref_data_pass_through_p (struct func_body_info *fbi, int index,
>>>      reference respectively.  */
>>>
>>>   static bool
>>> -ipa_load_from_parm_agg_1 (struct func_body_info *fbi,
>>> +ipa_load_from_parm_agg_1 (func_body_info *fbi,
>>>                 vec<ipa_param_descriptor> descriptors,
>>>                 gimple stmt, tree op, int *index_p,
>>>                 HOST_WIDE_INT *offset_p, HOST_WIDE_INT *size_p,
>>> @@ -1240,7 +1240,7 @@ ipa_load_from_parm_agg_1 (struct func_body_info *fbi,
>>>      pointer, for users outside of this file.  */
>>>
>>>   bool
>>> -ipa_load_from_parm_agg (struct ipa_node_params *info, gimple stmt,
>>> +ipa_load_from_parm_agg (ipa_node_params *info, gimple stmt,
>>>               tree op, int *index_p, HOST_WIDE_INT *offset_p,
>>>               bool *by_ref_p)
>>>   {
>>> @@ -1302,9 +1302,9 @@ ipa_load_from_parm_agg (struct ipa_node_params *info, gimple stmt,
>>>      only needed for intraprocedural analysis.  */
>>>
>>>   static void
>>> -compute_complex_assign_jump_func (struct func_body_info *fbi,
>>> -                  struct ipa_node_params *info,
>>> -                  struct ipa_jump_func *jfunc,
>>> +compute_complex_assign_jump_func (func_body_info *fbi,
>>> +                  ipa_node_params *info,
>>> +                  ipa_jump_func *jfunc,
>>>                     gimple call, gimple stmt, tree name,
>>>                     tree param_type)
>>>   {
>>> @@ -1458,9 +1458,9 @@ get_ancestor_addr_info (gimple assign, tree *obj_p, HOST_WIDE_INT *offset)
>>>        return D.1879_6;  */
>>>
>>>   static void
>>> -compute_complex_ancestor_jump_func (struct func_body_info *fbi,
>>> -                    struct ipa_node_params *info,
>>> -                    struct ipa_jump_func *jfunc,
>>> +compute_complex_ancestor_jump_func (func_body_info *fbi,
>>> +                    ipa_node_params *info,
>>> +                    ipa_jump_func *jfunc,
>>>                       gimple call, gimple phi, tree param_type)
>>>   {
>>>     HOST_WIDE_INT offset;
>>> @@ -1531,7 +1531,7 @@ compute_complex_ancestor_jump_func (struct func_body_info *fbi,
>>>      EXPECTED_TYPE represents a type the argument should be in  */
>>>
>>>   static void
>>> -compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc,
>>> +compute_known_type_jump_func (tree op, ipa_jump_func *jfunc,
>>>                     gimple call, tree expected_type)
>>>   {
>>>     HOST_WIDE_INT offset, size, max_size;
>>> @@ -1629,7 +1629,7 @@ struct ipa_known_agg_contents_list
>>>     /* Known constant value or NULL if the contents is known to be unknown.  */
>>>     tree constant;
>>>     /* Pointer to the next structure in the list.  */
>>> -  struct ipa_known_agg_contents_list *next;
>>> +  ipa_known_agg_contents_list *next;
>>>   };
>>>
>>>   /* Find the proper place in linked list of ipa_known_agg_contents_list
>>> @@ -1637,13 +1637,13 @@ struct ipa_known_agg_contents_list
>>>      unless there is a partial overlap, in which case return NULL, or such
>>>      element is already there, in which case set *ALREADY_THERE to true.  */
>>>
>>> -static struct ipa_known_agg_contents_list **
>>> -get_place_in_agg_contents_list (struct ipa_known_agg_contents_list **list,
>>> +static ipa_known_agg_contents_list **
>>> +get_place_in_agg_contents_list (ipa_known_agg_contents_list **list,
>>>                   HOST_WIDE_INT lhs_offset,
>>>                   HOST_WIDE_INT lhs_size,
>>>                   bool *already_there)
>>>   {
>>> -  struct ipa_known_agg_contents_list **p = list;
>>> +  ipa_known_agg_contents_list **p = list;
>>>     while (*p && (*p)->offset < lhs_offset)
>>>       {
>>>         if ((*p)->offset + (*p)->size > lhs_offset)
>>> @@ -1670,16 +1670,16 @@ get_place_in_agg_contents_list (struct ipa_known_agg_contents_list **list,
>>>      is ARG_OFFSET and store it into JFUNC.  */
>>>
>>>   static void
>>> -build_agg_jump_func_from_list (struct ipa_known_agg_contents_list *list,
>>> +build_agg_jump_func_from_list (ipa_known_agg_contents_list *list,
>>>                      int const_count, HOST_WIDE_INT arg_offset,
>>> -                   struct ipa_jump_func *jfunc)
>>> +                   ipa_jump_func *jfunc)
>>>   {
>>>     vec_alloc (jfunc->agg.items, const_count);
>>>     while (list)
>>>       {
>>>         if (list->constant)
>>>       {
>>> -      struct ipa_agg_jf_item item;
>>> +      ipa_agg_jf_item item;
>>>         item.offset = list->offset - arg_offset;
>>>         gcc_assert ((item.offset % BITS_PER_UNIT) == 0);
>>>         item.value = unshare_expr_without_location (list->constant);
>>> @@ -1697,9 +1697,9 @@ build_agg_jump_func_from_list (struct ipa_known_agg_contents_list *list,
>>>
>>>   static void
>>>   determine_locally_known_aggregate_parts (gimple call, tree arg, tree arg_type,
>>> -                     struct ipa_jump_func *jfunc)
>>> +                     ipa_jump_func *jfunc)
>>>   {
>>> -  struct ipa_known_agg_contents_list *list = NULL;
>>> +  ipa_known_agg_contents_list *list = NULL;
>>>     int item_count = 0, const_count = 0;
>>>     HOST_WIDE_INT arg_offset, arg_size;
>>>     gimple_stmt_iterator gsi;
>>> @@ -1774,7 +1774,7 @@ determine_locally_known_aggregate_parts (gimple call, tree arg, tree arg_type,
>>>     gsi_prev (&gsi);
>>>     for (; !gsi_end_p (gsi); gsi_prev (&gsi))
>>>       {
>>> -      struct ipa_known_agg_contents_list *n, **p;
>>> +      ipa_known_agg_contents_list *n, **p;
>>>         gimple stmt = gsi_stmt (gsi);
>>>         HOST_WIDE_INT lhs_offset, lhs_size, lhs_max_size;
>>>         tree lhs, rhs, lhs_base;
>>> @@ -1821,7 +1821,7 @@ determine_locally_known_aggregate_parts (gimple call, tree arg, tree arg_type,
>>>       continue;
>>>
>>>         rhs = get_ssa_def_if_simple_copy (rhs);
>>> -      n = XALLOCA (struct ipa_known_agg_contents_list);
>>> +      n = XALLOCA (ipa_known_agg_contents_list);
>>>         n->size = lhs_size;
>>>         n->offset = lhs_offset;
>>>         if (is_gimple_ip_invariant (rhs))
>>> @@ -1852,7 +1852,7 @@ determine_locally_known_aggregate_parts (gimple call, tree arg, tree arg_type,
>>>   }
>>>
>>>   static tree
>>> -ipa_get_callee_param_type (struct cgraph_edge *e, int i)
>>> +ipa_get_callee_param_type (cgraph_edge *e, int i)
>>>   {
>>>     int n;
>>>     tree type = (e->callee
>>> @@ -1887,11 +1887,11 @@ ipa_get_callee_param_type (struct cgraph_edge *e, int i)
>>>      to this callsite.  */
>>>
>>>   static void
>>> -ipa_compute_jump_functions_for_edge (struct func_body_info *fbi,
>>> -                     struct cgraph_edge *cs)
>>> +ipa_compute_jump_functions_for_edge (func_body_info *fbi,
>>> +                     cgraph_edge *cs)
>>>   {
>>> -  struct ipa_node_params *info = IPA_NODE_REF (cs->caller);
>>> -  struct ipa_edge_args *args = IPA_EDGE_REF (cs);
>>> +  ipa_node_params *info = IPA_NODE_REF (cs->caller);
>>> +  ipa_edge_args *args = IPA_EDGE_REF (cs);
>>>     gimple call = cs->call_stmt;
>>>     int n, arg_num = gimple_call_num_args (call);
>>>     bool useful_context = false;
>>> @@ -1909,13 +1909,13 @@ ipa_compute_jump_functions_for_edge (struct func_body_info *fbi,
>>>
>>>     for (n = 0; n < arg_num; n++)
>>>       {
>>> -      struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, n);
>>> +      ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, n);
>>>         tree arg = gimple_call_arg (call, n);
>>>         tree param_type = ipa_get_callee_param_type (cs, n);
>>>         if (flag_devirtualize && POINTER_TYPE_P (TREE_TYPE (arg)))
>>>       {
>>>         tree instance;
>>> -      struct ipa_polymorphic_call_context context (cs->caller->decl,
>>> +      ipa_polymorphic_call_context context (cs->caller->decl,
>>>                                  arg, cs->call_stmt,
>>>                                  &instance);
>>>         context.get_dynamic_type (instance, arg, NULL, cs->call_stmt);
>>> @@ -2003,15 +2003,15 @@ ipa_compute_jump_functions_for_edge (struct func_body_info *fbi,
>>>      from BB.  */
>>>
>>>   static void
>>> -ipa_compute_jump_functions_for_bb (struct func_body_info *fbi, basic_block bb)
>>> +ipa_compute_jump_functions_for_bb (func_body_info *fbi, basic_block bb)
>>>   {
>>> -  struct ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
>>> +  ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
>>>     int i;
>>> -  struct cgraph_edge *cs;
>>> +  cgraph_edge *cs;
>>>
>>>     FOR_EACH_VEC_ELT_REVERSE (bi->cg_edges, i, cs)
>>>       {
>>> -      struct cgraph_node *callee = cs->callee;
>>> +      cgraph_node *callee = cs->callee;
>>>
>>>         if (callee)
>>>       {
>>> @@ -2093,10 +2093,10 @@ ipa_is_ssa_with_stmt_def (tree t)
>>>      call to a parameter number PARAM_INDEX.  NODE is the caller.  Return the
>>>      indirect call graph edge.  */
>>>
>>> -static struct cgraph_edge *
>>> -ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt)
>>> +static cgraph_edge *
>>> +ipa_note_param_call (cgraph_node *node, int param_index, gimple stmt)
>>>   {
>>> -  struct cgraph_edge *cs;
>>> +  cgraph_edge *cs;
>>>
>>>     cs = node->get_edge (stmt);
>>>     cs->indirect_info->param_index = param_index;
>>> @@ -2165,10 +2165,10 @@ ipa_note_param_call (struct cgraph_node *node, int param_index, gimple stmt)
>>>      passed by value or reference.  */
>>>
>>>   static void
>>> -ipa_analyze_indirect_call_uses (struct func_body_info *fbi, gimple call,
>>> +ipa_analyze_indirect_call_uses (func_body_info *fbi, gimple call,
>>>                   tree target)
>>>   {
>>> -  struct ipa_node_params *info = fbi->info;
>>> +  ipa_node_params *info = fbi->info;
>>>     HOST_WIDE_INT offset;
>>>     bool by_ref;
>>>
>>> @@ -2188,7 +2188,7 @@ ipa_analyze_indirect_call_uses (struct func_body_info *fbi, gimple call,
>>>                      gimple_assign_rhs1 (def), &index, &offset,
>>>                      NULL, &by_ref))
>>>       {
>>> -      struct cgraph_edge *cs = ipa_note_param_call (fbi->node, index, call);
>>> +      cgraph_edge *cs = ipa_note_param_call (fbi->node, index, call);
>>>         cs->indirect_info->offset = offset;
>>>         cs->indirect_info->agg_contents = 1;
>>>         cs->indirect_info->by_ref = by_ref;
>>> @@ -2288,7 +2288,7 @@ ipa_analyze_indirect_call_uses (struct func_body_info *fbi, gimple call,
>>>     if (index >= 0
>>>         && parm_preserved_before_stmt_p (fbi, index, call, rec))
>>>       {
>>> -      struct cgraph_edge *cs = ipa_note_param_call (fbi->node, index, call);
>>> +      cgraph_edge *cs = ipa_note_param_call (fbi->node, index, call);
>>>         cs->indirect_info->offset = offset;
>>>         cs->indirect_info->agg_contents = 1;
>>>         cs->indirect_info->member_ptr = 1;
>>> @@ -2303,7 +2303,7 @@ ipa_analyze_indirect_call_uses (struct func_body_info *fbi, gimple call,
>>>      statement.  */
>>>
>>>   static void
>>> -ipa_analyze_virtual_call_uses (struct func_body_info *fbi,
>>> +ipa_analyze_virtual_call_uses (func_body_info *fbi,
>>>                      gimple call, tree target)
>>>   {
>>>     tree obj = OBJ_TYPE_REF_OBJECT (target);
>>> @@ -2316,10 +2316,10 @@ ipa_analyze_virtual_call_uses (struct func_body_info *fbi,
>>>     if (TREE_CODE (obj) != SSA_NAME)
>>>       return;
>>>
>>> -  struct ipa_node_params *info = fbi->info;
>>> +  ipa_node_params *info = fbi->info;
>>>     if (SSA_NAME_IS_DEFAULT_DEF (obj))
>>>       {
>>> -      struct ipa_jump_func jfunc;
>>> +      ipa_jump_func jfunc;
>>>         if (TREE_CODE (SSA_NAME_VAR (obj)) != PARM_DECL)
>>>       return;
>>>
>>> @@ -2332,7 +2332,7 @@ ipa_analyze_virtual_call_uses (struct func_body_info *fbi,
>>>       }
>>>     else
>>>       {
>>> -      struct ipa_jump_func jfunc;
>>> +      ipa_jump_func jfunc;
>>>         gimple stmt = SSA_NAME_DEF_STMT (obj);
>>>         tree expr;
>>>
>>> @@ -2347,8 +2347,8 @@ ipa_analyze_virtual_call_uses (struct func_body_info *fbi,
>>>       return;
>>>       }
>>>
>>> -  struct cgraph_edge *cs = ipa_note_param_call (fbi->node, index, call);
>>> -  struct cgraph_indirect_call_info *ii = cs->indirect_info;
>>> +  cgraph_edge *cs = ipa_note_param_call (fbi->node, index, call);
>>> +  cgraph_indirect_call_info *ii = cs->indirect_info;
>>>     ii->offset = anc_offset;
>>>     ii->otr_token = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target));
>>>     ii->otr_type = obj_type_ref_class (target);
>>> @@ -2360,7 +2360,7 @@ ipa_analyze_virtual_call_uses (struct func_body_info *fbi,
>>>      containing intermediate information about each formal parameter.  */
>>>
>>>   static void
>>> -ipa_analyze_call_uses (struct func_body_info *fbi, gimple call)
>>> +ipa_analyze_call_uses (func_body_info *fbi, gimple call)
>>>   {
>>>     tree target = gimple_call_fn (call);
>>>
>>> @@ -2369,7 +2369,7 @@ ipa_analyze_call_uses (struct func_body_info *fbi, gimple call)
>>>             && !virtual_method_call_p (target)))
>>>       return;
>>>
>>> -  struct cgraph_edge *cs = fbi->node->get_edge (call);
>>> +  cgraph_edge *cs = fbi->node->get_edge (call);
>>>     /* If we previously turned the call into a direct call, there is
>>>        no need to analyze.  */
>>>     if (cs && !cs->indirect_unknown_callee)
>>> @@ -2406,7 +2406,7 @@ ipa_analyze_call_uses (struct func_body_info *fbi, gimple call)
>>>      formal parameters are called.  */
>>>
>>>   static void
>>> -ipa_analyze_stmt_uses (struct func_body_info *fbi, gimple stmt)
>>> +ipa_analyze_stmt_uses (func_body_info *fbi, gimple stmt)
>>>   {
>>>     if (is_gimple_call (stmt))
>>>       ipa_analyze_call_uses (fbi, stmt);
>>> @@ -2419,7 +2419,7 @@ ipa_analyze_stmt_uses (struct func_body_info *fbi, gimple stmt)
>>>   static bool
>>>   visit_ref_for_mod_analysis (gimple, tree op, tree, void *data)
>>>   {
>>> -  struct ipa_node_params *info = (struct ipa_node_params *) data;
>>> +  ipa_node_params *info = (ipa_node_params *) data;
>>>
>>>     op = get_base_address (op);
>>>     if (op
>>> @@ -2439,7 +2439,7 @@ visit_ref_for_mod_analysis (gimple, tree op, tree, void *data)
>>>      the function being analyzed.  */
>>>
>>>   static void
>>> -ipa_analyze_params_uses_in_bb (struct func_body_info *fbi, basic_block bb)
>>> +ipa_analyze_params_uses_in_bb (func_body_info *fbi, basic_block bb)
>>>   {
>>>     gimple_stmt_iterator gsi;
>>>     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
>>> @@ -2465,9 +2465,9 @@ ipa_analyze_params_uses_in_bb (struct func_body_info *fbi, basic_block bb)
>>>   /* Calculate controlled uses of parameters of NODE.  */
>>>
>>>   static void
>>> -ipa_analyze_controlled_uses (struct cgraph_node *node)
>>> +ipa_analyze_controlled_uses (cgraph_node *node)
>>>   {
>>> -  struct ipa_node_params *info = IPA_NODE_REF (node);
>>> +  ipa_node_params *info = IPA_NODE_REF (node);
>>>
>>>     for (int i = 0; i < ipa_get_param_count (info); i++)
>>>       {
>>> @@ -2510,7 +2510,7 @@ ipa_analyze_controlled_uses (struct cgraph_node *node)
>>>   /* Free stuff in BI.  */
>>>
>>>   static void
>>> -free_ipa_bb_info (struct ipa_bb_info *bi)
>>> +free_ipa_bb_info (ipa_bb_info *bi)
>>>   {
>>>     bi->cg_edges.release ();
>>>     bi->param_aa_statuses.release ();
>>> @@ -2521,13 +2521,13 @@ free_ipa_bb_info (struct ipa_bb_info *bi)
>>>   class analysis_dom_walker : public dom_walker
>>>   {
>>>   public:
>>> -  analysis_dom_walker (struct func_body_info *fbi)
>>> +  analysis_dom_walker (func_body_info *fbi)
>>>       : dom_walker (CDI_DOMINATORS), m_fbi (fbi) {}
>>>
>>>     virtual void before_dom_children (basic_block);
>>>
>>>   private:
>>> -  struct func_body_info *m_fbi;
>>> +  func_body_info *m_fbi;
>>>   };
>>>
>>>   void
>>> @@ -2542,10 +2542,10 @@ analysis_dom_walker::before_dom_children (basic_block bb)
>>>      with actual arguments of calls from within NODE.  */
>>>
>>>   void
>>> -ipa_analyze_node (struct cgraph_node *node)
>>> +ipa_analyze_node (cgraph_node *node)
>>>   {
>>> -  struct func_body_info fbi;
>>> -  struct ipa_node_params *info;
>>> +  func_body_info fbi;
>>> +  ipa_node_params *info;
>>>
>>>     ipa_check_create_node_params ();
>>>     ipa_check_create_edge_args ();
>>> @@ -2565,7 +2565,7 @@ ipa_analyze_node (struct cgraph_node *node)
>>>         return;
>>>       }
>>>
>>> -  struct function *func = DECL_STRUCT_FUNCTION (node->decl);
>>> +  function *func = DECL_STRUCT_FUNCTION (node->decl);
>>>     push_cfun (func);
>>>     calculate_dominance_info (CDI_DOMINATORS);
>>>     ipa_initialize_node_params (node);
>>> @@ -2578,13 +2578,13 @@ ipa_analyze_node (struct cgraph_node *node)
>>>     fbi.param_count = ipa_get_param_count (info);
>>>     fbi.aa_walked = 0;
>>>
>>> -  for (struct cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
>>> +  for (cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
>>>       {
>>>         ipa_bb_info *bi = ipa_get_bb_info (&fbi, gimple_bb (cs->call_stmt));
>>>         bi->cg_edges.safe_push (cs);
>>>       }
>>>
>>> -  for (struct cgraph_edge *cs = node->indirect_calls; cs; cs = cs->next_callee)
>>> +  for (cgraph_edge *cs = node->indirect_calls; cs; cs = cs->next_callee)
>>>       {
>>>         ipa_bb_info *bi = ipa_get_bb_info (&fbi, gimple_bb (cs->call_stmt));
>>>         bi->cg_edges.safe_push (cs);
>>> @@ -2593,7 +2593,7 @@ ipa_analyze_node (struct cgraph_node *node)
>>>     analysis_dom_walker (&fbi).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun));
>>>
>>>     int i;
>>> -  struct ipa_bb_info *bi;
>>> +  ipa_bb_info *bi;
>>>     FOR_EACH_VEC_ELT (fbi.bb_infos, i, bi)
>>>       free_ipa_bb_info (bi);
>>>     fbi.bb_infos.release ();
>>> @@ -2606,8 +2606,8 @@ ipa_analyze_node (struct cgraph_node *node)
>>>      type.  */
>>>
>>>   static void
>>> -combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
>>> -                     struct ipa_jump_func *dst)
>>> +combine_known_type_and_ancestor_jfs (ipa_jump_func *src,
>>> +                     ipa_jump_func *dst)
>>>   {
>>>     HOST_WIDE_INT combined_offset;
>>>     tree combined_type;
>>> @@ -2632,25 +2632,25 @@ combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
>>>      indirectly) inlined into CS->callee and that E has not been inlined.  */
>>>
>>>   static void
>>> -update_jump_functions_after_inlining (struct cgraph_edge *cs,
>>> -                      struct cgraph_edge *e)
>>> +update_jump_functions_after_inlining (cgraph_edge *cs,
>>> +                      cgraph_edge *e)
>>>   {
>>> -  struct ipa_edge_args *top = IPA_EDGE_REF (cs);
>>> -  struct ipa_edge_args *args = IPA_EDGE_REF (e);
>>> +  ipa_edge_args *top = IPA_EDGE_REF (cs);
>>> +  ipa_edge_args *args = IPA_EDGE_REF (e);
>>>     int count = ipa_get_cs_argument_count (args);
>>>     int i;
>>>
>>>     for (i = 0; i < count; i++)
>>>       {
>>> -      struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
>>> -      struct ipa_polymorphic_call_context *dst_ctx
>>> +      ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
>>> +      ipa_polymorphic_call_context *dst_ctx
>>>       = ipa_get_ith_polymorhic_call_context (args, i);
>>>
>>>         if (dst->type == IPA_JF_ANCESTOR)
>>>       {
>>> -      struct ipa_jump_func *src;
>>> +      ipa_jump_func *src;
>>>         int dst_fid = dst->value.ancestor.formal_id;
>>> -      struct ipa_polymorphic_call_context *src_ctx
>>> +      ipa_polymorphic_call_context *src_ctx
>>>           = ipa_get_ith_polymorhic_call_context (top, dst_fid);
>>>
>>>         /* Variable number of arguments can cause havoc if we try to access
>>> @@ -2666,7 +2666,7 @@ update_jump_functions_after_inlining (struct cgraph_edge *cs,
>>>
>>>         if (src_ctx && !src_ctx->useless_p ())
>>>           {
>>> -          struct ipa_polymorphic_call_context ctx = *src_ctx;
>>> +          ipa_polymorphic_call_context ctx = *src_ctx;
>>>
>>>             /* TODO: Make type preserved safe WRT contexts.  */
>>>             if (!dst->value.ancestor.agg_preserved)
>>> @@ -2683,7 +2683,7 @@ update_jump_functions_after_inlining (struct cgraph_edge *cs,
>>>         if (src->agg.items
>>>             && (dst->value.ancestor.agg_preserved || !src->agg.by_ref))
>>>           {
>>> -          struct ipa_agg_jf_item *item;
>>> +          ipa_agg_jf_item *item;
>>>             int j;
>>>
>>>             /* Currently we do not produce clobber aggregate jump functions,
>>> @@ -2721,7 +2721,7 @@ update_jump_functions_after_inlining (struct cgraph_edge *cs,
>>>       }
>>>         else if (dst->type == IPA_JF_PASS_THROUGH)
>>>       {
>>> -      struct ipa_jump_func *src;
>>> +      ipa_jump_func *src;
>>>         /* We must check range due to calls with variable number of arguments
>>>            and we cannot combine jump functions with operations.  */
>>>         if (dst->value.pass_through.operation == NOP_EXPR
>>> @@ -2731,12 +2731,12 @@ update_jump_functions_after_inlining (struct cgraph_edge *cs,
>>>             int dst_fid = dst->value.pass_through.formal_id;
>>>             src = ipa_get_ith_jump_func (top, dst_fid);
>>>             bool dst_agg_p = ipa_get_jf_pass_through_agg_preserved (dst);
>>> -          struct ipa_polymorphic_call_context *src_ctx
>>> +          ipa_polymorphic_call_context *src_ctx
>>>           = ipa_get_ith_polymorhic_call_context (top, dst_fid);
>>>
>>>             if (src_ctx && !src_ctx->useless_p ())
>>>           {
>>> -          struct ipa_polymorphic_call_context ctx = *src_ctx;
>>> +          ipa_polymorphic_call_context ctx = *src_ctx;
>>>
>>>             /* TODO: Make type preserved safe WRT contexts.  */
>>>             if (!dst->value.ancestor.agg_preserved)
>>> @@ -2833,11 +2833,11 @@ update_jump_functions_after_inlining (struct cgraph_edge *cs,
>>>      (SPECULATIVE)destination of an indirect edge IE and return the edge.
>>>      Otherwise, return NULL.  */
>>>
>>> -struct cgraph_edge *
>>> -ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
>>> +cgraph_edge *
>>> +ipa_make_edge_direct_to_target (cgraph_edge *ie, tree target,
>>>                   bool speculative)
>>>   {
>>> -  struct cgraph_node *callee;
>>> +  cgraph_node *callee;
>>>     struct inline_edge_summary *es = inline_edge_summary (ie);
>>>     bool unreachable = false;
>>>
>>> @@ -2898,8 +2898,8 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
>>>     /* If the edge is already speculated.  */
>>>     if (speculative && ie->speculative)
>>>       {
>>> -      struct cgraph_edge *e2;
>>> -      struct ipa_ref *ref;
>>> +      cgraph_edge *e2;
>>> +      ipa_ref *ref;
>>>         ie->speculative_call_info (e2, ie, ref);
>>>         if (e2->callee->ultimate_alias_target ()
>>>         != callee->ultimate_alias_target ())
>>> @@ -2987,10 +2987,10 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
>>>      be passed by reference or by value.  */
>>>
>>>   tree
>>> -ipa_find_agg_cst_for_param (struct ipa_agg_jump_function *agg,
>>> +ipa_find_agg_cst_for_param (ipa_agg_jump_function *agg,
>>>                   HOST_WIDE_INT offset, bool by_ref)
>>>   {
>>> -  struct ipa_agg_jf_item *item;
>>> +  ipa_agg_jf_item *item;
>>>     int i;
>>>
>>>     if (by_ref != agg->by_ref)
>>> @@ -3012,10 +3012,10 @@ ipa_find_agg_cst_for_param (struct ipa_agg_jump_function *agg,
>>>      successfully found and removed.  */
>>>
>>>   static bool
>>> -remove_described_reference (symtab_node *symbol, struct ipa_cst_ref_desc *rdesc)
>>> +remove_described_reference (symtab_node *symbol, ipa_cst_ref_desc *rdesc)
>>>   {
>>> -  struct ipa_ref *to_del;
>>> -  struct cgraph_edge *origin;
>>> +  ipa_ref *to_del;
>>> +  cgraph_edge *origin;
>>>
>>>     origin = rdesc->cs;
>>>     if (!origin)
>>> @@ -3037,10 +3037,10 @@ remove_described_reference (symtab_node *symbol, struct ipa_cst_ref_desc *rdesc)
>>>      IPA_UNDESCRIBED_USE, return the reference description, otherwise return
>>>      NULL.  JFUNC must be a constant jump function.  */
>>>
>>> -static struct ipa_cst_ref_desc *
>>> -jfunc_rdesc_usable (struct ipa_jump_func *jfunc)
>>> +static ipa_cst_ref_desc *
>>> +jfunc_rdesc_usable (ipa_jump_func *jfunc)
>>>   {
>>> -  struct ipa_cst_ref_desc *rdesc = ipa_get_jf_constant_rdesc (jfunc);
>>> +  ipa_cst_ref_desc *rdesc = ipa_get_jf_constant_rdesc (jfunc);
>>>     if (rdesc && rdesc->refcount != IPA_UNDESCRIBED_USE)
>>>       return rdesc;
>>>     else
>>> @@ -3052,7 +3052,7 @@ jfunc_rdesc_usable (struct ipa_jump_func *jfunc)
>>>      NULL.  */
>>>
>>>   static cgraph_node *
>>> -cgraph_node_for_jfunc (struct ipa_jump_func *jfunc)
>>> +cgraph_node_for_jfunc (ipa_jump_func *jfunc)
>>>   {
>>>     gcc_checking_assert (jfunc->type == IPA_JF_CONST);
>>>     tree cst = ipa_get_jf_constant (jfunc);
>>> @@ -3070,9 +3070,9 @@ cgraph_node_for_jfunc (struct ipa_jump_func *jfunc)
>>>      reference could not be found, otherwise return true.  */
>>>
>>>   static bool
>>> -try_decrement_rdesc_refcount (struct ipa_jump_func *jfunc)
>>> +try_decrement_rdesc_refcount (ipa_jump_func *jfunc)
>>>   {
>>> -  struct ipa_cst_ref_desc *rdesc;
>>> +  ipa_cst_ref_desc *rdesc;
>>>     if (jfunc->type == IPA_JF_CONST
>>>         && (rdesc = jfunc_rdesc_usable (jfunc))
>>>         && --rdesc->refcount == 0)
>>> @@ -3092,12 +3092,12 @@ try_decrement_rdesc_refcount (struct ipa_jump_func *jfunc)
>>>      determined, return the newly direct edge, otherwise return NULL.
>>>      NEW_ROOT_INFO is the node info that JFUNC lattices are relative to.  */
>>>
>>> -static struct cgraph_edge *
>>> -try_make_edge_direct_simple_call (struct cgraph_edge *ie,
>>> -                  struct ipa_jump_func *jfunc,
>>> -                  struct ipa_node_params *new_root_info)
>>> +static cgraph_edge *
>>> +try_make_edge_direct_simple_call (cgraph_edge *ie,
>>> +                  ipa_jump_func *jfunc,
>>> +                  ipa_node_params *new_root_info)
>>>   {
>>> -  struct cgraph_edge *cs;
>>> +  cgraph_edge *cs;
>>>     tree target;
>>>     bool agg_contents = ie->indirect_info->agg_contents;
>>>
>>> @@ -3130,7 +3130,7 @@ try_make_edge_direct_simple_call (struct cgraph_edge *ie,
>>>      and target (the latter can be NULL) are dumped when dumping is enabled.  */
>>>
>>>   tree
>>> -ipa_impossible_devirt_target (struct cgraph_edge *ie, tree target)
>>> +ipa_impossible_devirt_target (cgraph_edge *ie, tree target)
>>>   {
>>>     if (dump_file)
>>>       {
>>> @@ -3155,11 +3155,11 @@ ipa_impossible_devirt_target (struct cgraph_edge *ie, tree target)
>>>      Otherwise, return NULL.  NEW_ROOT_INFO is the node info that JFUNC lattices
>>>      are relative to.  */
>>>
>>> -static struct cgraph_edge *
>>> -try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
>>> -                   struct ipa_jump_func *jfunc,
>>> -                   struct ipa_node_params *new_root_info,
>>> -                   struct ipa_polymorphic_call_context *ctx_ptr)
>>> +static cgraph_edge *
>>> +try_make_edge_direct_virtual_call (cgraph_edge *ie,
>>> +                   ipa_jump_func *jfunc,
>>> +                   ipa_node_params *new_root_info,
>>> +                   ipa_polymorphic_call_context *ctx_ptr)
>>>   {
>>>     tree binfo, target = NULL;
>>>     bool speculative = false;
>>> @@ -3172,7 +3172,7 @@ try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
>>>        based on knowlede of the context.  */
>>>     if (ctx_ptr && !ie->indirect_info->by_ref)
>>>       {
>>> -      struct ipa_polymorphic_call_context ctx = *ctx_ptr;
>>> +      ipa_polymorphic_call_context ctx = *ctx_ptr;
>>>
>>>         ctx.offset_by (ie->indirect_info->offset);
>>>
>>> @@ -3221,7 +3221,7 @@ try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
>>>
>>>     if (binfo && TREE_CODE (binfo) != TREE_BINFO)
>>>       {
>>> -      struct ipa_polymorphic_call_context ctx (binfo,
>>> +      ipa_polymorphic_call_context ctx (binfo,
>>>                              ie->indirect_info->otr_type,
>>>                              ie->indirect_info->offset);
>>>         updated |= ie->indirect_info->context.combine_with
>>> @@ -3296,13 +3296,13 @@ try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
>>>      unless NEW_EDGES is NULL.  Return true iff a new edge(s) were created.  */
>>>
>>>   static bool
>>> -update_indirect_edges_after_inlining (struct cgraph_edge *cs,
>>> -                      struct cgraph_node *node,
>>> +update_indirect_edges_after_inlining (cgraph_edge *cs,
>>> +                      cgraph_node *node,
>>>                         vec<cgraph_edge *> *new_edges)
>>>   {
>>> -  struct ipa_edge_args *top;
>>> -  struct cgraph_edge *ie, *next_ie, *new_direct_edge;
>>> -  struct ipa_node_params *new_root_info;
>>> +  ipa_edge_args *top;
>>> +  cgraph_edge *ie, *next_ie, *new_direct_edge;
>>> +  ipa_node_params *new_root_info;
>>>     bool res = false;
>>>
>>>     ipa_check_create_edge_args ();
>>> @@ -3313,8 +3313,8 @@ update_indirect_edges_after_inlining (struct cgraph_edge *cs,
>>>
>>>     for (ie = node->indirect_calls; ie; ie = next_ie)
>>>       {
>>> -      struct cgraph_indirect_call_info *ici = ie->indirect_info;
>>> -      struct ipa_jump_func *jfunc;
>>> +      cgraph_indirect_call_info *ici = ie->indirect_info;
>>> +      ipa_jump_func *jfunc;
>>>         int param_index;
>>>
>>>         next_ie = ie->next_callee;
>>> @@ -3408,11 +3408,11 @@ update_indirect_edges_after_inlining (struct cgraph_edge *cs,
>>>      created.  */
>>>
>>>   static bool
>>> -propagate_info_to_inlined_callees (struct cgraph_edge *cs,
>>> -                   struct cgraph_node *node,
>>> +propagate_info_to_inlined_callees (cgraph_edge *cs,
>>> +                   cgraph_node *node,
>>>                      vec<cgraph_edge *> *new_edges)
>>>   {
>>> -  struct cgraph_edge *e;
>>> +  cgraph_edge *e;
>>>     bool res;
>>>
>>>     res = update_indirect_edges_after_inlining (cs, node, new_edges);
>>> @@ -3443,21 +3443,21 @@ combine_controlled_uses_counters (int c, int d)
>>>      tree of inlined nodes.  */
>>>
>>>   static void
>>> -propagate_controlled_uses (struct cgraph_edge *cs)
>>> +propagate_controlled_uses (cgraph_edge *cs)
>>>   {
>>> -  struct ipa_edge_args *args = IPA_EDGE_REF (cs);
>>> -  struct cgraph_node *new_root = cs->caller->global.inlined_to
>>> +  ipa_edge_args *args = IPA_EDGE_REF (cs);
>>> +  cgraph_node *new_root = cs->caller->global.inlined_to
>>>       ? cs->caller->global.inlined_to : cs->caller;
>>> -  struct ipa_node_params *new_root_info = IPA_NODE_REF (new_root);
>>> -  struct ipa_node_params *old_root_info = IPA_NODE_REF (cs->callee);
>>> +  ipa_node_params *new_root_info = IPA_NODE_REF (new_root);
>>> +  ipa_node_params *old_root_info = IPA_NODE_REF (cs->callee);
>>>     int count, i;
>>>
>>>     count = MIN (ipa_get_cs_argument_count (args),
>>>              ipa_get_param_count (old_root_info));
>>>     for (i = 0; i < count; i++)
>>>       {
>>> -      struct ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);
>>> -      struct ipa_cst_ref_desc *rdesc;
>>> +      ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);
>>> +      ipa_cst_ref_desc *rdesc;
>>>
>>>         if (jf->type == IPA_JF_PASS_THROUGH)
>>>       {
>>> @@ -3472,8 +3472,8 @@ propagate_controlled_uses (struct cgraph_edge *cs)
>>>         ipa_set_controlled_uses (new_root_info, src_idx, c);
>>>         if (c == 0 && new_root_info->ipcp_orig_node)
>>>           {
>>> -          struct cgraph_node *n;
>>> -          struct ipa_ref *ref;
>>> +          cgraph_node *n;
>>> +          ipa_ref *ref;
>>>             tree t = new_root_info->known_vals[src_idx];
>>>
>>>             if (t && TREE_CODE (t) == ADDR_EXPR
>>> @@ -3500,14 +3500,14 @@ propagate_controlled_uses (struct cgraph_edge *cs)
>>>         if (rdesc->refcount == 0)
>>>           {
>>>             tree cst = ipa_get_jf_constant (jf);
>>> -          struct cgraph_node *n;
>>> +          cgraph_node *n;
>>>             gcc_checking_assert (TREE_CODE (cst) == ADDR_EXPR
>>>                      && TREE_CODE (TREE_OPERAND (cst, 0))
>>>                      == FUNCTION_DECL);
>>>             n = cgraph_node::get (TREE_OPERAND (cst, 0));
>>>             if (n)
>>>           {
>>> -          struct cgraph_node *clone;
>>> +          cgraph_node *clone;
>>>             bool ok;
>>>             ok = remove_described_reference (n, rdesc);
>>>             gcc_checking_assert (ok);
>>> @@ -3517,7 +3517,7 @@ propagate_controlled_uses (struct cgraph_edge *cs)
>>>                && clone != rdesc->cs->caller
>>>                && IPA_NODE_REF (clone)->ipcp_orig_node)
>>>               {
>>> -              struct ipa_ref *ref;
>>> +              ipa_ref *ref;
>>>                 ref = clone->find_reference (n, NULL, 0);
>>>                 if (ref)
>>>               {
>>> @@ -3542,11 +3542,11 @@ propagate_controlled_uses (struct cgraph_edge *cs)
>>>          i < ipa_get_cs_argument_count (args);
>>>          i++)
>>>       {
>>> -      struct ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);
>>> +      ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);
>>>
>>>         if (jf->type == IPA_JF_CONST)
>>>       {
>>> -      struct ipa_cst_ref_desc *rdesc = jfunc_rdesc_usable (jf);
>>> +      ipa_cst_ref_desc *rdesc = jfunc_rdesc_usable (jf);
>>>         if (rdesc)
>>>           rdesc->refcount = IPA_UNDESCRIBED_USE;
>>>       }
>>> @@ -3564,13 +3564,13 @@ propagate_controlled_uses (struct cgraph_edge *cs)
>>>      created.  */
>>>
>>>   bool
>>> -ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
>>> +ipa_propagate_indirect_call_infos (cgraph_edge *cs,
>>>                      vec<cgraph_edge *> *new_edges)
>>>   {
>>>     bool changed;
>>>     /* Do nothing if the preparation phase has not been carried out yet
>>>        (i.e. during early inlining).  */
>>> -  if (!ipa_node_params_vector.exists ())
>>> +  if (!ipa_node_params_summary)
>>>       return false;
>>>     gcc_assert (ipa_edge_args_vector);
>>>
>>> @@ -3584,7 +3584,7 @@ ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
>>>      to.  */
>>>
>>>   void
>>> -ipa_free_edge_args_substructures (struct ipa_edge_args *args)
>>> +ipa_free_edge_args_substructures (ipa_edge_args *args)
>>>   {
>>>     vec_free (args->jump_functions);
>>>     memset (args, 0, sizeof (*args));
>>> @@ -3596,7 +3596,7 @@ void
>>>   ipa_free_all_edge_args (void)
>>>   {
>>>     int i;
>>> -  struct ipa_edge_args *args;
>>> +  ipa_edge_args *args;
>>>
>>>     if (!ipa_edge_args_vector)
>>>       return;
>>> @@ -3610,15 +3610,21 @@ ipa_free_all_edge_args (void)
>>>   /* Frees all dynamically allocated structures that the param info points
>>>      to.  */
>>>
>>> -void
>>> -ipa_free_node_params_substructures (struct ipa_node_params *info)
>>> +ipa_node_params::~ipa_node_params ()
>>>   {
>>> -  info->descriptors.release ();
>>> -  free (info->lattices);
>>> +  descriptors.release ();
>>> +  free (lattices);
>>>     /* Lattice values and their sources are deallocated with their alocation
>>>        pool.  */
>>> -  info->known_vals.release ();
>>> -  memset (info, 0, sizeof (*info));
>>> +  known_vals.release ();
>>> +
>>> +  lattices = NULL;
>>> +  ipcp_orig_node = NULL;
>>> +  analysis_done = 0;
>>> +  node_enqueued = 0;
>>> +  do_clone_for_all_contexts = 0;
>>> +  is_all_contexts_clone = 0;
>>> +  node_dead = 0;
>>>   }
>>>
>>>   /* Free all ipa_node_params structures.  */
>>> @@ -3626,11 +3632,8 @@ ipa_free_node_params_substructures (struct ipa_node_params *info)
>>>   void
>>>   ipa_free_all_node_params (void)
>>>   {
>>> -  int i;
>>> -  struct ipa_node_params *info;
>>> -
>>> -  FOR_EACH_VEC_ELT (ipa_node_params_vector, i, info)
>>> -    ipa_free_node_params_substructures (info);
>>> +  delete ipa_node_params_summary;
>>> +  ipa_node_params_summary = NULL;
>>>
>>>     ipa_node_params_vector.release ();
>>>   }
>>> @@ -3638,8 +3641,8 @@ ipa_free_all_node_params (void)
>>>   /* Set the aggregate replacements of NODE to be AGGVALS.  */
>>>
>>>   void
>>> -ipa_set_node_agg_value_chain (struct cgraph_node *node,
>>> -                  struct ipa_agg_replacement_value *aggvals)
>>> +ipa_set_node_agg_value_chain (const cgraph_node *node,
>>> +                  ipa_agg_replacement_value *aggvals)
>>>   {
>>>     if (vec_safe_length (ipa_node_agg_replacements)
>>>         <= (unsigned) symtab->cgraph_max_uid)
>>> @@ -3652,9 +3655,9 @@ ipa_set_node_agg_value_chain (struct cgraph_node *node,
>>>   /* Hook that is called by cgraph.c when an edge is removed.  */
>>>
>>>   static void
>>> -ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
>>> +ipa_edge_removal_hook (cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
>>>   {
>>> -  struct ipa_edge_args *args;
>>> +  ipa_edge_args *args;
>>>
>>>     /* During IPA-CP updating we can be called on not-yet analyzed clones.  */
>>>     if (vec_safe_length (ipa_edge_args_vector) <= (unsigned)cs->uid)
>>> @@ -3663,11 +3666,11 @@ ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
>>>     args = IPA_EDGE_REF (cs);
>>>     if (args->jump_functions)
>>>       {
>>> -      struct ipa_jump_func *jf;
>>> +      ipa_jump_func *jf;
>>>         int i;
>>>         FOR_EACH_VEC_ELT (*args->jump_functions, i, jf)
>>>       {
>>> -      struct ipa_cst_ref_desc *rdesc;
>>> +      ipa_cst_ref_desc *rdesc;
>>>         try_decrement_rdesc_refcount (jf);
>>>         if (jf->type == IPA_JF_CONST
>>>             && (rdesc = ipa_get_jf_constant_rdesc (jf))
>>> @@ -3679,25 +3682,13 @@ ipa_edge_removal_hook (struct cgraph_edge *cs, void *data ATTRIBUTE_UNUSED)
>>>     ipa_free_edge_args_substructures (IPA_EDGE_REF (cs));
>>>   }
>>>
>>> -/* Hook that is called by cgraph.c when a node is removed.  */
>>> -
>>> -static void
>>> -ipa_node_removal_hook (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
>>> -{
>>> -  /* During IPA-CP updating we can be called on not-yet analyze clones.  */
>>> -  if (ipa_node_params_vector.length () > (unsigned)node->uid)
>>> -    ipa_free_node_params_substructures (IPA_NODE_REF (node));
>>> -  if (vec_safe_length (ipa_node_agg_replacements) > (unsigned)node->uid)
>>> -    (*ipa_node_agg_replacements)[(unsigned)node->uid] = NULL;
>>> -}
>>> -
>>>   /* Hook that is called by cgraph.c when an edge is duplicated.  */
>>>
>>>   static void
>>> -ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
>>> +ipa_edge_duplication_hook (cgraph_edge *src, cgraph_edge *dst,
>>>                  __attribute__((unused)) void *data)
>>>   {
>>> -  struct ipa_edge_args *old_args, *new_args;
>>> +  ipa_edge_args *old_args, *new_args;
>>>     unsigned int i;
>>>
>>>     ipa_check_create_edge_args ();
>>> @@ -3712,20 +3703,20 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
>>>
>>>     for (i = 0; i < vec_safe_length (old_args->jump_functions); i++)
>>>       {
>>> -      struct ipa_jump_func *src_jf = ipa_get_ith_jump_func (old_args, i);
>>> -      struct ipa_jump_func *dst_jf = ipa_get_ith_jump_func (new_args, i);
>>> +      ipa_jump_func *src_jf = ipa_get_ith_jump_func (old_args, i);
>>> +      ipa_jump_func *dst_jf = ipa_get_ith_jump_func (new_args, i);
>>>
>>>         dst_jf->agg.items = vec_safe_copy (dst_jf->agg.items);
>>>
>>>         if (src_jf->type == IPA_JF_CONST)
>>>       {
>>> -      struct ipa_cst_ref_desc *src_rdesc = jfunc_rdesc_usable (src_jf);
>>> +      ipa_cst_ref_desc *src_rdesc = jfunc_rdesc_usable (src_jf);
>>>
>>>         if (!src_rdesc)
>>>           dst_jf->value.constant.rdesc = NULL;
>>>         else if (src->caller == dst->caller)
>>>           {
>>> -          struct ipa_ref *ref;
>>> +          ipa_ref *ref;
>>>             symtab_node *n = cgraph_node_for_jfunc (src_jf);
>>>             gcc_checking_assert (n);
>>>             ref = src->caller->find_reference (n, src->call_stmt,
>>> @@ -3734,8 +3725,8 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
>>>             dst->caller->clone_reference (ref, ref->stmt);
>>>
>>>             gcc_checking_assert (ipa_refdesc_pool);
>>> -          struct ipa_cst_ref_desc *dst_rdesc
>>> -        = (struct ipa_cst_ref_desc *) pool_alloc (ipa_refdesc_pool);
>>> +          ipa_cst_ref_desc *dst_rdesc
>>> +        = (ipa_cst_ref_desc *) pool_alloc (ipa_refdesc_pool);
>>>             dst_rdesc->cs = dst;
>>>             dst_rdesc->refcount = src_rdesc->refcount;
>>>             dst_rdesc->next_duplicate = NULL;
>>> @@ -3743,10 +3734,10 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
>>>           }
>>>         else if (src_rdesc->cs == src)
>>>           {
>>> -          struct ipa_cst_ref_desc *dst_rdesc;
>>> +          ipa_cst_ref_desc *dst_rdesc;
>>>             gcc_checking_assert (ipa_refdesc_pool);
>>>             dst_rdesc
>>> -        = (struct ipa_cst_ref_desc *) pool_alloc (ipa_refdesc_pool);
>>> +        = (ipa_cst_ref_desc *) pool_alloc (ipa_refdesc_pool);
>>>             dst_rdesc->cs = dst;
>>>             dst_rdesc->refcount = src_rdesc->refcount;
>>>             dst_rdesc->next_duplicate = src_rdesc->next_duplicate;
>>> @@ -3755,7 +3746,7 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
>>>           }
>>>         else
>>>           {
>>> -          struct ipa_cst_ref_desc *dst_rdesc;
>>> +          ipa_cst_ref_desc *dst_rdesc;
>>>             /* This can happen during inlining, when a JFUNC can refer to a
>>>            reference taken in a function up in the tree of inline clones.
>>>            We need to find the duplicate that refers to our tree of
>>> @@ -3766,7 +3757,7 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
>>>              dst_rdesc;
>>>              dst_rdesc = dst_rdesc->next_duplicate)
>>>           {
>>> -          struct cgraph_node *top;
>>> +          cgraph_node *top;
>>>             top = dst_rdesc->cs->caller->global.inlined_to
>>>               ? dst_rdesc->cs->caller->global.inlined_to
>>>               : dst_rdesc->cs->caller;
>>> @@ -3780,9 +3771,9 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct 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
>>> +      cgraph_node *inline_root = dst->caller->global.inlined_to
>>>           ? dst->caller->global.inlined_to : dst->caller;
>>> -      struct ipa_node_params *root_info = IPA_NODE_REF (inline_root);
>>> +      ipa_node_params *root_info = IPA_NODE_REF (inline_root);
>>>         int idx = ipa_get_jf_pass_through_formal_id (dst_jf);
>>>
>>>         int c = ipa_get_controlled_uses (root_info, idx);
>>> @@ -3795,18 +3786,24 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
>>>       }
>>>   }
>>>
>>> -/* Hook that is called by cgraph.c when a node is duplicated.  */
>>> +/* Analyze newly added function into callgraph.  */
>>>
>>>   static void
>>> -ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
>>> -               ATTRIBUTE_UNUSED void *data)
>>> +ipa_add_new_function (cgraph_node *node, void *data ATTRIBUTE_UNUSED)
>>>   {
>>> -  struct ipa_node_params *old_info, *new_info;
>>> -  struct ipa_agg_replacement_value *old_av, *new_av;
>>> +  if (node->has_gimple_body_p ())
>>> +    ipa_analyze_node (node);
>>> +}
>>>
>>> -  ipa_check_create_node_params ();
>>> -  old_info = IPA_NODE_REF (src);
>>> -  new_info = IPA_NODE_REF (dst);
>>> +/* Hook that is called by summary when a node is duplicated.  */
>>> +
>>> +void
>>> +ipa_node_params_cgraph_summary::duplication_hook(cgraph_node *src,
>>> +                            cgraph_node *dst,
>>> +                            ipa_node_params *old_info,
>>> +                            ipa_node_params *new_info)
>>> +{
>>> +  ipa_agg_replacement_value *old_av, *new_av;
>>>
>>>     new_info->descriptors = old_info->descriptors.copy ();
>>>     new_info->lattices = NULL;
>>> @@ -3822,7 +3819,7 @@ ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
>>>     new_av = NULL;
>>>     while (old_av)
>>>       {
>>> -      struct ipa_agg_replacement_value *v;
>>> +      ipa_agg_replacement_value *v;
>>>
>>>         v = ggc_alloc<ipa_agg_replacement_value> ();
>>>         memcpy (v, old_av, sizeof (*v));
>>> @@ -3833,33 +3830,19 @@ ipa_node_duplication_hook (struct cgraph_node *src, struct cgraph_node *dst,
>>>     ipa_set_node_agg_value_chain (dst, new_av);
>>>   }
>>>
>>> -
>>> -/* Analyze newly added function into callgraph.  */
>>> -
>>> -static void
>>> -ipa_add_new_function (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
>>> -{
>>> -  if (node->has_gimple_body_p ())
>>> -    ipa_analyze_node (node);
>>> -}
>>> -
>>>   /* Register our cgraph hooks if they are not already there.  */
>>>
>>>   void
>>>   ipa_register_cgraph_hooks (void)
>>>   {
>>> +  ipa_check_create_node_params ();
>>> +
>>>     if (!edge_removal_hook_holder)
>>>       edge_removal_hook_holder =
>>>         symtab->add_edge_removal_hook (&ipa_edge_removal_hook, NULL);
>>> -  if (!node_removal_hook_holder)
>>> -    node_removal_hook_holder =
>>> -      symtab->add_cgraph_removal_hook (&ipa_node_removal_hook, NULL);
>>>     if (!edge_duplication_hook_holder)
>>>       edge_duplication_hook_holder =
>>>         symtab->add_edge_duplication_hook (&ipa_edge_duplication_hook, NULL);
>>> -  if (!node_duplication_hook_holder)
>>> -    node_duplication_hook_holder =
>>> -      symtab->add_cgraph_duplication_hook (&ipa_node_duplication_hook, NULL);
>>>     function_insertion_hook_holder =
>>>         symtab->add_cgraph_insertion_hook (&ipa_add_new_function, NULL);
>>>   }
>>> @@ -3871,12 +3854,8 @@ ipa_unregister_cgraph_hooks (void)
>>>   {
>>>     symtab->remove_edge_removal_hook (edge_removal_hook_holder);
>>>     edge_removal_hook_holder = NULL;
>>> -  symtab->remove_cgraph_removal_hook (node_removal_hook_holder);
>>> -  node_removal_hook_holder = NULL;
>>>     symtab->remove_edge_duplication_hook (edge_duplication_hook_holder);
>>>     edge_duplication_hook_holder = NULL;
>>> -  symtab->remove_cgraph_duplication_hook (node_duplication_hook_holder);
>>> -  node_duplication_hook_holder = NULL;
>>>     symtab->remove_cgraph_insertion_hook (function_insertion_hook_holder);
>>>     function_insertion_hook_holder = NULL;
>>>   }
>>> @@ -3923,10 +3902,10 @@ ipa_free_all_structures_after_iinln (void)
>>>      callgraph to F.  */
>>>
>>>   void
>>> -ipa_print_node_params (FILE *f, struct cgraph_node *node)
>>> +ipa_print_node_params (FILE *f, cgraph_node *node)
>>>   {
>>>     int i, count;
>>> -  struct ipa_node_params *info;
>>> +  ipa_node_params *info;
>>>
>>>     if (!node->definition)
>>>       return;
>>> @@ -3957,7 +3936,7 @@ ipa_print_node_params (FILE *f, struct cgraph_node *node)
>>>   void
>>>   ipa_print_all_params (FILE * f)
>>>   {
>>> -  struct cgraph_node *node;
>>> +  cgraph_node *node;
>>>
>>>     fprintf (f, "\nFunction parameters:\n");
>>>     FOR_EACH_FUNCTION (node)
>>> @@ -4040,7 +4019,7 @@ ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments)
>>>     tree new_arg_types = NULL;
>>>     for (int i = 0; i < len; i++)
>>>       {
>>> -      struct ipa_parm_adjustment *adj;
>>> +      ipa_parm_adjustment *adj;
>>>         gcc_assert (link);
>>>
>>>         adj = &adjustments[i];
>>> @@ -4158,10 +4137,10 @@ ipa_modify_formal_parameters (tree fndecl, ipa_parm_adjustment_vec adjustments)
>>>      contain the corresponding call graph edge.  */
>>>
>>>   void
>>> -ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
>>> +ipa_modify_call_arguments (cgraph_edge *cs, gimple stmt,
>>>                  ipa_parm_adjustment_vec adjustments)
>>>   {
>>> -  struct cgraph_node *current_node = cgraph_node::get (current_function_decl);
>>> +  cgraph_node *current_node = cgraph_node::get (current_function_decl);
>>>     vec<tree> vargs;
>>>     vec<tree, va_gc> **debug_args = NULL;
>>>     gimple new_stmt;
>>> @@ -4179,7 +4158,7 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
>>>     gsi_prev (&prev_gsi);
>>>     for (i = 0; i < len; i++)
>>>       {
>>> -      struct ipa_parm_adjustment *adj;
>>> +      ipa_parm_adjustment *adj;
>>>
>>>         adj = &adjustments[i];
>>>
>>> @@ -4412,7 +4391,7 @@ bool
>>>   ipa_modify_expr (tree *expr, bool convert,
>>>            ipa_parm_adjustment_vec adjustments)
>>>   {
>>> -  struct ipa_parm_adjustment *cand
>>> +  ipa_parm_adjustment *cand
>>>       = ipa_get_adjustment_candidate (&expr, &convert, adjustments, false);
>>>     if (!cand)
>>>       return false;
>>> @@ -4500,11 +4479,11 @@ ipa_get_adjustment_candidate (tree **expr, bool *convert,
>>>     if (!base || TREE_CODE (base) != PARM_DECL)
>>>       return NULL;
>>>
>>> -  struct ipa_parm_adjustment *cand = NULL;
>>> +  ipa_parm_adjustment *cand = NULL;
>>>     unsigned int len = adjustments.length ();
>>>     for (unsigned i = 0; i < len; i++)
>>>       {
>>> -      struct ipa_parm_adjustment *adj = &adjustments[i];
>>> +      ipa_parm_adjustment *adj = &adjustments[i];
>>>
>>>         if (adj->base == base
>>>         && (adj->offset == offset || adj->op == IPA_PARM_OP_REMOVE))
>>> @@ -4530,7 +4509,7 @@ index_in_adjustments_multiple_times_p (int base_index,
>>>
>>>     for (i = 0; i < len; i++)
>>>       {
>>> -      struct ipa_parm_adjustment *adj;
>>> +      ipa_parm_adjustment *adj;
>>>         adj = &adjustments[i];
>>>
>>>         if (adj->base_index == base_index)
>>> @@ -4561,7 +4540,7 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
>>>     tmp.create (inlen);
>>>     for (i = 0; i < inlen; i++)
>>>       {
>>> -      struct ipa_parm_adjustment *n;
>>> +      ipa_parm_adjustment *n;
>>>         n = &inner[i];
>>>
>>>         if (n->op == IPA_PARM_OP_REMOVE)
>>> @@ -4577,9 +4556,9 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
>>>     adjustments.create (outlen + removals);
>>>     for (i = 0; i < outlen; i++)
>>>       {
>>> -      struct ipa_parm_adjustment r;
>>> -      struct ipa_parm_adjustment *out = &outer[i];
>>> -      struct ipa_parm_adjustment *in = &tmp[out->base_index];
>>> +      ipa_parm_adjustment r;
>>> +      ipa_parm_adjustment *out = &outer[i];
>>> +      ipa_parm_adjustment *in = &tmp[out->base_index];
>>>
>>>         memset (&r, 0, sizeof (r));
>>>         gcc_assert (in->op != IPA_PARM_OP_REMOVE);
>>> @@ -4616,7 +4595,7 @@ ipa_combine_adjustments (ipa_parm_adjustment_vec inner,
>>>
>>>     for (i = 0; i < inlen; i++)
>>>       {
>>> -      struct ipa_parm_adjustment *n = &inner[i];
>>> +      ipa_parm_adjustment *n = &inner[i];
>>>
>>>         if (n->op == IPA_PARM_OP_REMOVE)
>>>       adjustments.quick_push (*n);
>>> @@ -4640,7 +4619,7 @@ ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
>>>     fprintf (file, "IPA param adjustments: ");
>>>     for (i = 0; i < len; i++)
>>>       {
>>> -      struct ipa_parm_adjustment *adj;
>>> +      ipa_parm_adjustment *adj;
>>>         adj = &adjustments[i];
>>>
>>>         if (!first)
>>> @@ -4683,7 +4662,7 @@ ipa_dump_param_adjustments (FILE *file, ipa_parm_adjustment_vec adjustments,
>>>   /* Dump the AV linked list.  */
>>>
>>>   void
>>> -ipa_dump_agg_replacement_values (FILE *f, struct ipa_agg_replacement_value *av)
>>> +ipa_dump_agg_replacement_values (FILE *f, ipa_agg_replacement_value *av)
>>>   {
>>>     bool comma = false;
>>>     fprintf (f, "     Aggregate replacements:");
>>> @@ -4700,11 +4679,11 @@ ipa_dump_agg_replacement_values (FILE *f, struct ipa_agg_replacement_value *av)
>>>   /* Stream out jump function JUMP_FUNC to OB.  */
>>>
>>>   static void
>>> -ipa_write_jump_function (struct output_block *ob,
>>> -             struct ipa_jump_func *jump_func)
>>> +ipa_write_jump_function (output_block *ob,
>>> +             ipa_jump_func *jump_func)
>>>   {
>>> -  struct ipa_agg_jf_item *item;
>>> -  struct bitpack_d bp;
>>> +  ipa_agg_jf_item *item;
>>> +  bitpack_d bp;
>>>     int i, count;
>>>
>>>     streamer_write_uhwi (ob, jump_func->type);
>>> @@ -4768,10 +4747,10 @@ ipa_write_jump_function (struct output_block *ob,
>>>   /* Read in jump function JUMP_FUNC from IB.  */
>>>
>>>   static void
>>> -ipa_read_jump_function (struct lto_input_block *ib,
>>> -            struct ipa_jump_func *jump_func,
>>> -            struct cgraph_edge *cs,
>>> -            struct data_in *data_in)
>>> +ipa_read_jump_function (lto_input_block *ib,
>>> +            ipa_jump_func *jump_func,
>>> +            cgraph_edge *cs,
>>> +            data_in *data_in)
>>>   {
>>>     enum jump_func_type jftype;
>>>     enum tree_code operation;
>>> @@ -4800,7 +4779,7 @@ ipa_read_jump_function (struct lto_input_block *ib,
>>>         if (operation == NOP_EXPR)
>>>       {
>>>         int formal_id =  streamer_read_uhwi (ib);
>>> -      struct bitpack_d bp = streamer_read_bitpack (ib);
>>> +      bitpack_d bp = streamer_read_bitpack (ib);
>>>         bool agg_preserved = bp_unpack_value (&bp, 1);
>>>         bool type_preserved = bp_unpack_value (&bp, 1);
>>>         ipa_set_jf_simple_pass_through (jump_func, formal_id, agg_preserved,
>>> @@ -4819,7 +4798,7 @@ ipa_read_jump_function (struct lto_input_block *ib,
>>>       HOST_WIDE_INT offset = streamer_read_uhwi (ib);
>>>       tree type = stream_read_tree (ib, data_in);
>>>       int formal_id = streamer_read_uhwi (ib);
>>> -    struct bitpack_d bp = streamer_read_bitpack (ib);
>>> +    bitpack_d bp = streamer_read_bitpack (ib);
>>>       bool agg_preserved = bp_unpack_value (&bp, 1);
>>>       bool type_preserved = bp_unpack_value (&bp, 1);
>>>
>>> @@ -4833,12 +4812,12 @@ ipa_read_jump_function (struct lto_input_block *ib,
>>>     vec_alloc (jump_func->agg.items, count);
>>>     if (count)
>>>       {
>>> -      struct bitpack_d bp = streamer_read_bitpack (ib);
>>> +      bitpack_d bp = streamer_read_bitpack (ib);
>>>         jump_func->agg.by_ref = bp_unpack_value (&bp, 1);
>>>       }
>>>     for (i = 0; i < count; i++)
>>>       {
>>> -      struct ipa_agg_jf_item item;
>>> +      ipa_agg_jf_item item;
>>>         item.offset = streamer_read_uhwi (ib);
>>>         item.value = stream_read_tree (ib, data_in);
>>>         jump_func->agg.items->quick_push (item);
>>> @@ -4849,11 +4828,11 @@ ipa_read_jump_function (struct lto_input_block *ib,
>>>      relevant to indirect inlining to OB.  */
>>>
>>>   static void
>>> -ipa_write_indirect_edge_info (struct output_block *ob,
>>> -                  struct cgraph_edge *cs)
>>> +ipa_write_indirect_edge_info (output_block *ob,
>>> +                  cgraph_edge *cs)
>>>   {
>>> -  struct cgraph_indirect_call_info *ii = cs->indirect_info;
>>> -  struct bitpack_d bp;
>>> +  cgraph_indirect_call_info *ii = cs->indirect_info;
>>> +  bitpack_d bp;
>>>
>>>     streamer_write_hwi (ob, ii->param_index);
>>>     bp = bitpack_create (ob->main_stream);
>>> @@ -4880,12 +4859,12 @@ ipa_write_indirect_edge_info (struct output_block *ob,
>>>      relevant to indirect inlining from IB.  */
>>>
>>>   static void
>>> -ipa_read_indirect_edge_info (struct lto_input_block *ib,
>>> -                 struct data_in *data_in,
>>> -                 struct cgraph_edge *cs)
>>> +ipa_read_indirect_edge_info (lto_input_block *ib,
>>> +                 data_in *data_in,
>>> +                 cgraph_edge *cs)
>>>   {
>>> -  struct cgraph_indirect_call_info *ii = cs->indirect_info;
>>> -  struct bitpack_d bp;
>>> +  cgraph_indirect_call_info *ii = cs->indirect_info;
>>> +  bitpack_d bp;
>>>
>>>     ii->param_index = (int) streamer_read_hwi (ib);
>>>     bp = streamer_read_bitpack (ib);
>>> @@ -4909,14 +4888,14 @@ ipa_read_indirect_edge_info (struct lto_input_block *ib,
>>>   /* Stream out NODE info to OB.  */
>>>
>>>   static void
>>> -ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
>>> +ipa_write_node_info (output_block *ob, cgraph_node *node)
>>>   {
>>>     int node_ref;
>>>     lto_symtab_encoder_t encoder;
>>> -  struct ipa_node_params *info = IPA_NODE_REF (node);
>>> +  ipa_node_params *info = IPA_NODE_REF (node);
>>>     int j;
>>> -  struct cgraph_edge *e;
>>> -  struct bitpack_d bp;
>>> +  cgraph_edge *e;
>>> +  bitpack_d bp;
>>>
>>>     encoder = ob->decl_state->symtab_node_encoder;
>>>     node_ref = lto_symtab_encoder_encode (encoder, node);
>>> @@ -4937,7 +4916,7 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
>>>       streamer_write_hwi (ob, ipa_get_controlled_uses (info, j));
>>>     for (e = node->callees; e; e = e->next_callee)
>>>       {
>>> -      struct ipa_edge_args *args = IPA_EDGE_REF (e);
>>> +      ipa_edge_args *args = IPA_EDGE_REF (e);
>>>
>>>         streamer_write_uhwi (ob,
>>>                  ipa_get_cs_argument_count (args) * 2
>>> @@ -4951,7 +4930,7 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
>>>       }
>>>     for (e = node->indirect_calls; e; e = e->next_callee)
>>>       {
>>> -      struct ipa_edge_args *args = IPA_EDGE_REF (e);
>>> +      ipa_edge_args *args = IPA_EDGE_REF (e);
>>>
>>>         streamer_write_uhwi (ob,
>>>                  ipa_get_cs_argument_count (args) * 2
>>> @@ -4969,13 +4948,13 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
>>>   /* Stream in NODE info from IB.  */
>>>
>>>   static void
>>> -ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
>>> -            struct data_in *data_in)
>>> +ipa_read_node_info (lto_input_block *ib, cgraph_node *node,
>>> +            data_in *data_in)
>>>   {
>>> -  struct ipa_node_params *info = IPA_NODE_REF (node);
>>> +  ipa_node_params *info = IPA_NODE_REF (node);
>>>     int k;
>>> -  struct cgraph_edge *e;
>>> -  struct bitpack_d bp;
>>> +  cgraph_edge *e;
>>> +  bitpack_d bp;
>>>
>>>     ipa_alloc_node_params (node, streamer_read_uhwi (ib));
>>>
>>> @@ -4992,7 +4971,7 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
>>>       ipa_set_controlled_uses (info, k, streamer_read_hwi (ib));
>>>     for (e = node->callees; e; e = e->next_callee)
>>>       {
>>> -      struct ipa_edge_args *args = IPA_EDGE_REF (e);
>>> +      ipa_edge_args *args = IPA_EDGE_REF (e);
>>>         int count = streamer_read_uhwi (ib);
>>>         bool contexts_computed = count & 1;
>>>         count /= 2;
>>> @@ -5013,7 +4992,7 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
>>>       }
>>>     for (e = node->indirect_calls; e; e = e->next_callee)
>>>       {
>>> -      struct ipa_edge_args *args = IPA_EDGE_REF (e);
>>> +      ipa_edge_args *args = IPA_EDGE_REF (e);
>>>         int count = streamer_read_uhwi (ib);
>>>         bool contexts_computed = count & 1;
>>>         count /= 2;
>>> @@ -5040,14 +5019,13 @@ ipa_read_node_info (struct lto_input_block *ib, struct cgraph_node *node,
>>>   void
>>>   ipa_prop_write_jump_functions (void)
>>>   {
>>> -  struct cgraph_node *node;
>>> -  struct output_block *ob;
>>> +  cgraph_node *node;
>>> +  output_block *ob;
>>>     unsigned int count = 0;
>>>     lto_symtab_encoder_iterator lsei;
>>>     lto_symtab_encoder_t encoder;
>>>
>>> -
>>> -  if (!ipa_node_params_vector.exists ())
>>> +  if (!ipa_node_params_summary)
>>>       return;
>>>
>>>     ob = create_output_block (LTO_section_jump_functions);
>>> @@ -5081,15 +5059,15 @@ ipa_prop_write_jump_functions (void)
>>>   /* Read section in file FILE_DATA of length LEN with data DATA.  */
>>>
>>>   static void
>>> -ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
>>> +ipa_prop_read_section (lto_file_decl_data *file_data, const char *data,
>>>                  size_t len)
>>>   {
>>> -  const struct lto_function_header *header =
>>> -    (const struct lto_function_header *) data;
>>> -  const int cfg_offset = sizeof (struct lto_function_header);
>>> +  const lto_function_header *header =
>>> +    (const lto_function_header *) data;
>>> +  const int cfg_offset = sizeof (lto_function_header);
>>>     const int main_offset = cfg_offset + header->cfg_size;
>>>     const int string_offset = main_offset + header->main_size;
>>> -  struct data_in *data_in;
>>> +  data_in *data_in;
>>>     unsigned int i;
>>>     unsigned int count;
>>>
>>> @@ -5104,7 +5082,7 @@ ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
>>>     for (i = 0; i < count; i++)
>>>       {
>>>         unsigned int index;
>>> -      struct cgraph_node *node;
>>> +      cgraph_node *node;
>>>         lto_symtab_encoder_t encoder;
>>>
>>>         index = streamer_read_uhwi (&ib_main);
>>> @@ -5124,8 +5102,8 @@ ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
>>>   void
>>>   ipa_prop_read_jump_functions (void)
>>>   {
>>> -  struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
>>> -  struct lto_file_decl_data *file_data;
>>> +  lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
>>> +  lto_file_decl_data *file_data;
>>>     unsigned int j = 0;
>>>
>>>     ipa_check_create_node_params ();
>>> @@ -5154,12 +5132,12 @@ ipa_update_after_lto_read (void)
>>>   }
>>>
>>>   void
>>> -write_agg_replacement_chain (struct output_block *ob, struct cgraph_node *node)
>>> +write_agg_replacement_chain (output_block *ob, cgraph_node *node)
>>>   {
>>>     int node_ref;
>>>     unsigned int count = 0;
>>>     lto_symtab_encoder_t encoder;
>>> -  struct ipa_agg_replacement_value *aggvals, *av;
>>> +  ipa_agg_replacement_value *aggvals, *av;
>>>
>>>     aggvals = ipa_get_agg_replacements_for_node (node);
>>>     encoder = ob->decl_state->symtab_node_encoder;
>>> @@ -5172,7 +5150,7 @@ write_agg_replacement_chain (struct output_block *ob, struct cgraph_node *node)
>>>
>>>     for (av = aggvals; av; av = av->next)
>>>       {
>>> -      struct bitpack_d bp;
>>> +      bitpack_d bp;
>>>
>>>         streamer_write_uhwi (ob, av->offset);
>>>         streamer_write_uhwi (ob, av->index);
>>> @@ -5187,18 +5165,18 @@ write_agg_replacement_chain (struct output_block *ob, struct cgraph_node *node)
>>>   /* Stream in the aggregate value replacement chain for NODE from IB.  */
>>>
>>>   static void
>>> -read_agg_replacement_chain (struct lto_input_block *ib,
>>> -                struct cgraph_node *node,
>>> -                struct data_in *data_in)
>>> +read_agg_replacement_chain (lto_input_block *ib,
>>> +                cgraph_node *node,
>>> +                data_in *data_in)
>>>   {
>>> -  struct ipa_agg_replacement_value *aggvals = NULL;
>>> +  ipa_agg_replacement_value *aggvals = NULL;
>>>     unsigned int count, i;
>>>
>>>     count = streamer_read_uhwi (ib);
>>>     for (i = 0; i <count; i++)
>>>       {
>>> -      struct ipa_agg_replacement_value *av;
>>> -      struct bitpack_d bp;
>>> +      ipa_agg_replacement_value *av;
>>> +      bitpack_d bp;
>>>
>>>         av = ggc_alloc<ipa_agg_replacement_value> ();
>>>         av->offset = streamer_read_uhwi (ib);
>>> @@ -5217,8 +5195,8 @@ read_agg_replacement_chain (struct lto_input_block *ib,
>>>   void
>>>   ipa_prop_write_all_agg_replacement (void)
>>>   {
>>> -  struct cgraph_node *node;
>>> -  struct output_block *ob;
>>> +  cgraph_node *node;
>>> +  output_block *ob;
>>>     unsigned int count = 0;
>>>     lto_symtab_encoder_iterator lsei;
>>>     lto_symtab_encoder_t encoder;
>>> @@ -5257,16 +5235,16 @@ ipa_prop_write_all_agg_replacement (void)
>>>      DATA.  */
>>>
>>>   static void
>>> -read_replacements_section (struct lto_file_decl_data *file_data,
>>> +read_replacements_section (lto_file_decl_data *file_data,
>>>                  const char *data,
>>>                  size_t len)
>>>   {
>>> -  const struct lto_function_header *header =
>>> -    (const struct lto_function_header *) data;
>>> -  const int cfg_offset = sizeof (struct lto_function_header);
>>> +  const lto_function_header *header =
>>> +    (const lto_function_header *) data;
>>> +  const int cfg_offset = sizeof (lto_function_header);
>>>     const int main_offset = cfg_offset + header->cfg_size;
>>>     const int string_offset = main_offset + header->main_size;
>>> -  struct data_in *data_in;
>>> +  data_in *data_in;
>>>     unsigned int i;
>>>     unsigned int count;
>>>
>>> @@ -5280,7 +5258,7 @@ read_replacements_section (struct lto_file_decl_data *file_data,
>>>     for (i = 0; i < count; i++)
>>>       {
>>>         unsigned int index;
>>> -      struct cgraph_node *node;
>>> +      cgraph_node *node;
>>>         lto_symtab_encoder_t encoder;
>>>
>>>         index = streamer_read_uhwi (&ib_main);
>>> @@ -5300,8 +5278,8 @@ read_replacements_section (struct lto_file_decl_data *file_data,
>>>   void
>>>   ipa_prop_read_all_agg_replacement (void)
>>>   {
>>> -  struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
>>> -  struct lto_file_decl_data *file_data;
>>> +  lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
>>> +  lto_file_decl_data *file_data;
>>>     unsigned int j = 0;
>>>
>>>     while ((file_data = file_data_vec[j++]))
>>> @@ -5319,10 +5297,10 @@ ipa_prop_read_all_agg_replacement (void)
>>>      NODE.  */
>>>
>>>   static void
>>> -adjust_agg_replacement_values (struct cgraph_node *node,
>>> -                   struct ipa_agg_replacement_value *aggval)
>>> +adjust_agg_replacement_values (cgraph_node *node,
>>> +                   ipa_agg_replacement_value *aggval)
>>>   {
>>> -  struct ipa_agg_replacement_value *v;
>>> +  ipa_agg_replacement_value *v;
>>>     int i, c = 0, d = 0, *adj;
>>>
>>>     if (!node->clone.combined_args_to_skip)
>>> @@ -5355,9 +5333,9 @@ adjust_agg_replacement_values (struct cgraph_node *node,
>>>   class ipcp_modif_dom_walker : public dom_walker
>>>   {
>>>   public:
>>> -  ipcp_modif_dom_walker (struct func_body_info *fbi,
>>> +  ipcp_modif_dom_walker (func_body_info *fbi,
>>>                vec<ipa_param_descriptor> descs,
>>> -             struct ipa_agg_replacement_value *av,
>>> +             ipa_agg_replacement_value *av,
>>>                bool *sc, bool *cc)
>>>       : dom_walker (CDI_DOMINATORS), m_fbi (fbi), m_descriptors (descs),
>>>         m_aggval (av), m_something_changed (sc), m_cfg_changed (cc) {}
>>> @@ -5365,9 +5343,9 @@ public:
>>>     virtual void before_dom_children (basic_block);
>>>
>>>   private:
>>> -  struct func_body_info *m_fbi;
>>> +  func_body_info *m_fbi;
>>>     vec<ipa_param_descriptor> m_descriptors;
>>> -  struct ipa_agg_replacement_value *m_aggval;
>>> +  ipa_agg_replacement_value *m_aggval;
>>>     bool *m_something_changed, *m_cfg_changed;
>>>   };
>>>
>>> @@ -5377,7 +5355,7 @@ ipcp_modif_dom_walker::before_dom_children (basic_block bb)
>>>     gimple_stmt_iterator gsi;
>>>     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
>>>       {
>>> -      struct ipa_agg_replacement_value *v;
>>> +      ipa_agg_replacement_value *v;
>>>         gimple stmt = gsi_stmt (gsi);
>>>         tree rhs, val, t;
>>>         HOST_WIDE_INT offset, size;
>>> @@ -5468,11 +5446,11 @@ ipcp_modif_dom_walker::before_dom_children (basic_block bb)
>>>   /* IPCP transformation phase doing propagation of aggregate values.  */
>>>
>>>   unsigned int
>>> -ipcp_transform_function (struct cgraph_node *node)
>>> +ipcp_transform_function (cgraph_node *node)
>>>   {
>>>     vec<ipa_param_descriptor> descriptors = vNULL;
>>> -  struct func_body_info fbi;
>>> -  struct ipa_agg_replacement_value *aggval;
>>> +  func_body_info fbi;
>>> +  ipa_agg_replacement_value *aggval;
>>>     int param_count;
>>>     bool cfg_changed = false, something_changed = false;
>>>
>>> @@ -5507,7 +5485,7 @@ ipcp_transform_function (struct cgraph_node *node)
>>>                &cfg_changed).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun));
>>>
>>>     int i;
>>> -  struct ipa_bb_info *bi;
>>> +  ipa_bb_info *bi;
>>>     FOR_EACH_VEC_ELT (fbi.bb_infos, i, bi)
>>>       free_ipa_bb_info (bi);
>>>     fbi.bb_infos.release ();
>>> diff --git a/gcc/ipa-prop.h b/gcc/ipa-prop.h
>>> index 165fc1a..6c3b31f 100644
>>> --- a/gcc/ipa-prop.h
>>> +++ b/gcc/ipa-prop.h
>>> @@ -20,7 +20,6 @@ along with GCC; see the file COPYING3.  If not see
>>>   #ifndef IPA_PROP_H
>>>   #define IPA_PROP_H
>>>
>>> -
>>>   /* The following definitions and interfaces are used by
>>>      interprocedural analyses or parameters.  */
>>>
>>> @@ -356,6 +355,8 @@ struct ipcp_lattice;
>>>
>>>   struct ipa_node_params
>>>   {
>>> +  ~ipa_node_params ();
>>> +
>>>     /* Information about individual formal parameters that are gathered when
>>>        summaries are generated. */
>>>     vec<ipa_param_descriptor> descriptors;
>>> @@ -364,7 +365,7 @@ struct ipa_node_params
>>>     struct ipcp_param_lattices *lattices;
>>>     /* Only for versioned nodes this field would not be NULL,
>>>        it points to the node that IPA cp cloned from.  */
>>> -  struct cgraph_node *ipcp_orig_node;
>>> +  cgraph_node *ipcp_orig_node;
>>>     /* If this node is an ipa-cp clone, these are the known values that describe
>>>        what it has been specialized for.  */
>>>     vec<tree> known_vals;
>>> @@ -470,7 +471,7 @@ struct GTY(()) ipa_agg_replacement_value
>>>
>>>   typedef struct ipa_agg_replacement_value *ipa_agg_replacement_value_p;
>>>
>>> -void ipa_set_node_agg_value_chain (struct cgraph_node *node,
>>> +void ipa_set_node_agg_value_chain (const cgraph_node *node,
>>>                      struct ipa_agg_replacement_value *aggvals);
>>>
>>>   /* ipa_edge_args stores information related to a callsite and particularly its
>>> @@ -513,10 +514,22 @@ ipa_get_ith_polymorhic_call_context (struct ipa_edge_args *args, int i)
>>>     return &(*args->polymorphic_call_contexts)[i];
>>>   }
>>>
>>> -/* Types of vectors holding the infos.  */
>>> +/* Callgraph summary for ipa_node_params.  */
>>> +class ipa_node_params_cgraph_summary: public cgraph_summary <ipa_node_params *>
>>> +{
>>> +public:
>>> +  ipa_node_params_cgraph_summary (symbol_table *table):
>>> +    cgraph_summary <ipa_node_params *> (table) { }
>>> +
>>> +  /* Hook that is called by summary when a node is duplicated.  */
>>> +  virtual void duplication_hook (cgraph_node *node,
>>> +                 cgraph_node *node2,
>>> +                 ipa_node_params *data,
>>> +                 ipa_node_params *data2);
>>> +};
>>>
>>>   /* Vector where the parameter infos are actually stored. */
>>> -extern vec<ipa_node_params> ipa_node_params_vector;
>>> +extern ipa_node_params_cgraph_summary *ipa_node_params_summary;
>>>   /* Vector of known aggregate values in cloned nodes.  */
>>>   extern GTY(()) vec<ipa_agg_replacement_value_p, va_gc> *ipa_node_agg_replacements;
>>>   /* Vector where the parameter infos are actually stored. */
>>> @@ -524,7 +537,7 @@ extern GTY(()) vec<ipa_edge_args, va_gc> *ipa_edge_args_vector;
>>>
>>>   /* Return the associated parameter/argument info corresponding to the given
>>>      node/edge.  */
>>> -#define IPA_NODE_REF(NODE) (&ipa_node_params_vector[(NODE)->uid])
>>> +#define IPA_NODE_REF(NODE) ((*ipa_node_params_summary)[NODE])
>>>   #define IPA_EDGE_REF(EDGE) (&(*ipa_edge_args_vector)[(EDGE)->uid])
>>>   /* This macro checks validity of index returned by
>>>      ipa_get_param_decl_index function.  */
>>> @@ -534,11 +547,11 @@ extern GTY(()) vec<ipa_edge_args, va_gc> *ipa_edge_args_vector;
>>>   void ipa_create_all_node_params (void);
>>>   void ipa_create_all_edge_args (void);
>>>   void ipa_free_edge_args_substructures (struct ipa_edge_args *);
>>> -void ipa_free_node_params_substructures (struct ipa_node_params *);
>>>   void ipa_free_all_node_params (void);
>>>   void ipa_free_all_edge_args (void);
>>>   void ipa_free_all_structures_after_ipa_cp (void);
>>>   void ipa_free_all_structures_after_iinln (void);
>>> +
>>>   void ipa_register_cgraph_hooks (void);
>>>   int count_formal_params (tree fndecl);
>>>
>>> @@ -548,11 +561,8 @@ int count_formal_params (tree fndecl);
>>>   static inline void
>>>   ipa_check_create_node_params (void)
>>>   {
>>> -  if (!ipa_node_params_vector.exists ())
>>> -    ipa_node_params_vector.create (symtab->cgraph_max_uid);
>>> -
>>> -  if (ipa_node_params_vector.length () <= (unsigned) symtab->cgraph_max_uid)
>>> -    ipa_node_params_vector.safe_grow_cleared (symtab->cgraph_max_uid + 1);
>>> +  if (!ipa_node_params_summary)
>>> +    ipa_node_params_summary = new ipa_node_params_cgraph_summary (symtab);
>>>   }
>>>
>>>   /* This function ensures the array of edge arguments infos is big enough to
>>> @@ -579,7 +589,7 @@ ipa_edge_args_info_available_for_edge_p (struct cgraph_edge *edge)
>>>   /* Return the aggregate replacements for NODE, if there are any.  */
>>>
>>>   static inline struct ipa_agg_replacement_value *
>>> -ipa_get_agg_replacements_for_node (struct cgraph_node *node)
>>> +ipa_get_agg_replacements_for_node (const cgraph_node *node)
>>>   {
>>>     if ((unsigned) node->uid >= vec_safe_length (ipa_node_agg_replacements))
>>>       return NULL;
>>> @@ -587,7 +597,7 @@ ipa_get_agg_replacements_for_node (struct cgraph_node *node)
>>>   }
>>>
>>>   /* Function formal parameters related computations.  */
>>> -void ipa_initialize_node_params (struct cgraph_node *node);
>>> +void ipa_initialize_node_params (const cgraph_node *node);
>>>   bool ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
>>>                       vec<cgraph_edge *> *new_edges);
>>>
>>> @@ -602,7 +612,7 @@ tree ipa_binfo_from_known_type_jfunc (struct ipa_jump_func *);
>>>   tree ipa_impossible_devirt_target (struct cgraph_edge *, tree);
>>>
>>>   /* Functions related to both.  */
>>> -void ipa_analyze_node (struct cgraph_node *);
>>> +void ipa_analyze_node (cgraph_node *);
>>>
>>>   /* Aggregate jump function related functions.  */
>>>   tree ipa_find_agg_cst_for_param (struct ipa_agg_jump_function *, HOST_WIDE_INT,
>>> @@ -611,9 +621,9 @@ bool ipa_load_from_parm_agg (struct ipa_node_params *, gimple, tree, int *,
>>>                    HOST_WIDE_INT *, bool *);
>>>
>>>   /* Debugging interface.  */
>>> -void ipa_print_node_params (FILE *, struct cgraph_node *node);
>>> +void ipa_print_node_params (FILE *, cgraph_node *node);
>>>   void ipa_print_all_params (FILE *);
>>> -void ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node);
>>> +void ipa_print_node_jump_functions (FILE *f, cgraph_node *node);
>>>   void ipa_print_all_jump_functions (FILE * f);
>>>   void ipcp_verify_propagated_values (void);
>>>
>>> @@ -717,7 +727,7 @@ void ipa_update_after_lto_read (void);
>>>   int ipa_get_param_decl_index (struct ipa_node_params *, tree);
>>>   tree ipa_value_from_jfunc (struct ipa_node_params *info,
>>>                  struct ipa_jump_func *jfunc);
>>> -unsigned int ipcp_transform_function (struct cgraph_node *node);
>>> +unsigned int ipcp_transform_function (cgraph_node *node);
>>>   void ipa_dump_param (FILE *, struct ipa_node_params *info, int i);
>>>   bool ipa_modify_expr (tree *, bool, ipa_parm_adjustment_vec);
>>>   ipa_parm_adjustment *ipa_get_adjustment_candidate (tree **, bool *,
>>> diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
>>> index 98dbc63..0a7ca53 100644
>>> --- a/gcc/ipa-split.c
>>> +++ b/gcc/ipa-split.c
>>> @@ -109,6 +109,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "gimple-ssa.h"
>>>   #include "tree-cfg.h"
>>> diff --git a/gcc/ipa-utils.c b/gcc/ipa-utils.c
>>> index 22900cc..83111bc 100644
>>> --- a/gcc/ipa-utils.c
>>> +++ b/gcc/ipa-utils.c
>>> @@ -55,6 +55,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "langhooks.h"
>>>   #include "lto-streamer.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>
>>> diff --git a/gcc/ipa.c b/gcc/ipa.c
>>> index a6086d8..aded512 100644
>>> --- a/gcc/ipa.c
>>> +++ b/gcc/ipa.c
>>> @@ -46,6 +46,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "tree-iterator.h"
>>>   #include "ipa-utils.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "tree-inline.h"
>>> diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c
>>> index 0e1a95b..37d0f39 100644
>>> --- a/gcc/lto/lto-partition.c
>>> +++ b/gcc/lto/lto-partition.c
>>> @@ -45,6 +45,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "timevar.h"
>>>   #include "params.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "ipa-utils.h"
>>> diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c
>>> index 4c4e48a..ee97d06 100644
>>> --- a/gcc/lto/lto-symtab.c
>>> +++ b/gcc/lto/lto-symtab.c
>>> @@ -45,6 +45,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "lto-streamer.h"
>>>   #include "ipa-utils.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "ipa-inline.h"
>>>   #include "builtins.h"
>>> diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
>>> index d8519d9..c99dbdf 100644
>>> --- a/gcc/lto/lto.c
>>> +++ b/gcc/lto/lto.c
>>> @@ -47,6 +47,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "bitmap.h"
>>>   #include "inchash.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "common.h"
>>>   #include "debug.h"
>>> diff --git a/gcc/omp-low.c b/gcc/omp-low.c
>>> index b59d069..707379a 100644
>>> --- a/gcc/omp-low.c
>>> +++ b/gcc/omp-low.c
>>> @@ -82,6 +82,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "tree-cfgcleanup.h"
>>>   #include "pretty-print.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "tree-nested.h"
>>>   #include "tree-eh.h"
>>> diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
>>> index 8cb9510..a8e3561 100644
>>> --- a/gcc/tree-inline.c
>>> +++ b/gcc/tree-inline.c
>>> @@ -74,6 +74,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>>   #include "alloc-pool.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "value-prof.h"
>>>   #include "tree-pass.h"
>>> diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c
>>> index 1e629bc..99b19b8 100644
>>> --- a/gcc/tree-sra.c
>>> +++ b/gcc/tree-sra.c
>>> @@ -115,6 +115,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "plugin-api.h"
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "statistics.h"
>>>   #include "params.h"
>>> diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
>>> index ea99198..b526cc9 100644
>>> --- a/gcc/tree-ssa-pre.c
>>> +++ b/gcc/tree-ssa-pre.c
>>> @@ -77,6 +77,7 @@ along with GCC; see the file COPYING3.  If not see
>>>   #include "plugin-api.h"
>>>   #include "ipa-ref.h"
>>>   #include "cgraph.h"
>>> +#include "cgraph_summary.h"
>>>   #include "ipa-prop.h"
>>>   #include "tree-ssa-propagate.h"
>>>   #include "ipa-utils.h"
>>>
>>
>> Patch v2.
>>
>> Martin
>
> Patch v3.
>
> Martin

Version v4.

Martin

> 
> gcc/lto/ChangeLog:
> 
> 2014-12-08  Martin Liska  <mliska@suse.cz>
> 
> 	* lto-partition.c: Include of symbol-summary.h is added.
> 	* lto-symtab.c: Likewise.
> 	* lto.c: Likewise.

I must say I am not friend of flattening. Hope this will be resolved for 5.1
> 
> gcc/ChangeLog:
> 
> 2014-12-08  Martin Liska  <mliska@suse.cz>
> 
> 	* auto-profile.c: Include of symtab-summary.h is added.
> 	* cgraph.c: Likewise.
> 	* cgraphbuild.c: Likewise.
> 	* cgraphclones.c: Likewise.
> 	* cgraphunit.c: Likewise.
> 	* ipa-cp.c: Likewise.
> 	* ipa-devirt.c: Likewise.
> 	* ipa-icf.c: Likewise.
> 	* ipa-inline-analysis.c (evaluate_properties_for_edge): New
> 	ipa_node_params_d data structure is used.
> 	(inline_node_duplication_hook): Likewise.
> 	(estimate_function_body_sizes): Likewise.
> 	(remap_edge_change_prob): Likewise.
> 	(inline_merge_summary): Likewise.
> 	* ipa-inline-transform.c: Include of symtab-summary.h is added.
> 	* ipa-inline.c (early_inliner): New ipa_node_params_d data structure
> 	is used.
> 	* ipa-polymorphic-call.c: Include of symtab-summary.h is added.
> 	* ipa-profile.c: Include of symtab-summary.h is added.
> 	* ipa-prop.c (ipa_propagate_indirect_call_infos): New ipa_node_params_d
> 	data structure is used.
> 	(ipa_node_params::~ipa_node_params): New function.
> 	(ipa_free_all_node_params): Destruction is simplified.
> 	(ipa_node_removal_hook): Removed.
> 	(ipa_add_new_function): Renamed from ipa_node_duplication_hook.
> 	(ipa_node_params_t::duplicate): New function.
> 	(ipa_register_cgraph_hooks): Few hooks are removed.
> 	(ipa_unregister_cgraph_hooks): Likewise.
> 	(ipa_prop_write_jump_functions): New ipa_node_params_d is used.
> 	* ipa-prop.h (struct ipa_node_params): Destructor instroduced for
> 	the structure.
> 	(ipa_check_create_node_params): Vector for ipa_node_params is replaced
> 	with function_summary.
> 	* ipa-split.c: Include of symtab-summary.h is added.
> 	* ipa-utils.c: Include of symtab-summary.h is added.
> 	* ipa.c: Include of symtab-summary.h is added.
> 	* omp-low.c: Include of symtab-summary.h is added.
> 	* tree-inline.c: Include of symtab-summary.h is added.
> 	* tree-sra.c: Include of symtab-summary.h is added.
> 	* tree-ssa-pre.c: Include of symtab-summary.h is added.

OK.
Honza