From fd607e77883b8d3f8fb7c8091d0626dbbd31b9a5 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Fri, 6 Sep 2013 12:28:59 -0400
Subject: [PATCH 2/6] Automated conversion of symtab to class hierarchy

gcc/

	Patch autogenerated by refactor_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 761987353e7764909eca0e32c01040ed9574ce80

	* asan.c (asan_finish_file): Update for conversion of symtab types to
	a true class hierarchy.
	* cfgexpand.c (estimated_stack_frame_size): Likewise.
	* cgraph.c (cgraph_get_body): Likewise.
	(cgraph_get_create_real_symbol_node): Likewise.
	(verify_cgraph_node): Likewise.
	(verify_edge_corresponds_to_fndecl): Likewise.
	(verify_edge_count_and_frequency): Likewise.
	(cgraph_will_be_removed_from_program_if_no_direct_calls): Likewise.
	(cgraph_can_remove_if_no_direct_calls_p): Likewise.
	(cgraph_can_remove_if_no_direct_calls_and_refs_p): Likewise.
	(cgraph_node_cannot_return): Likewise.
	(cgraph_set_pure_flag_1): Likewise.
	(cgraph_set_const_flag_1): Likewise.
	(cgraph_set_nothrow_flag_1): Likewise.
	(cgraph_make_node_local_1): Likewise.
	(cgraph_for_node_and_aliases): Likewise.
	(cgraph_for_node_thunks_and_aliases): Likewise.
	(cgraph_node_can_be_local_p): Likewise.
	(cgraph_node_cannot_be_local_p_1): Likewise.
	(cgraph_function_body_availability): Likewise.
	(dump_cgraph_node): Likewise.
	(cgraph_rtl_info): Likewise.
	(cgraph_mark_address_taken_node): Likewise.
	(cgraph_remove_node): Likewise.
	(cgraph_release_function_body): Likewise.
	(cgraph_update_edges_for_call_stmt_node): Likewise.
	(cgraph_redirect_edge_call_stmt_to_callee): Likewise.
	(cgraph_make_edge_direct): Likewise.
	(cgraph_resolve_speculation): Likewise.
	(cgraph_speculative_call_info): Likewise.
	(cgraph_turn_edge_to_speculative): Likewise.
	(cgraph_create_edge_1): Likewise.
	(cgraph_set_call_stmt): Likewise.
	(cgraph_node_for_asm): Likewise.
	(cgraph_add_thunk): Likewise.
	(cgraph_same_body_alias): Likewise.
	(cgraph_create_function_alias): Likewise.
	(cgraph_create_node): Likewise.
	(cgraph_create_empty_node): Likewise.
	(record_function_versions): Likewise.
	(used_from_object_file_p): Likewise.
	* cgraph.h (symtab_can_be_discarded): Likewise.
	(symtab_real_symbol_p): Likewise.
	(cgraph_mark_force_output_node): Likewise.
	(cgraph_edge_recursive_p): Likewise.
	(symtab_alias_target): Likewise.
	(varpool_all_refs_explicit_p): Likewise.
	(varpool_can_remove_if_no_refs): Likewise.
	(cgraph_only_called_directly_or_aliased_p): Likewise.
	(cgraph_next_function_with_gimple_body): Likewise.
	(cgraph_first_function_with_gimple_body): Likewise.
	(cgraph_function_with_gimple_body_p): Likewise.
	(cgraph_next_function): Likewise.
	(cgraph_first_function): Likewise.
	(cgraph_next_defined_function): Likewise.
	(cgraph_first_defined_function): Likewise.
	(varpool_next_defined_variable): Likewise.
	(varpool_first_defined_variable): Likewise.
	(varpool_next_static_initializer): Likewise.
	(varpool_first_static_initializer): Likewise.
	(varpool_next_variable): Likewise.
	(varpool_first_variable): Likewise.
	(cgraph_node_asm_name): Likewise.
	(varpool): Likewise.
	(cgraph_turn_edge_to_speculative): Likewise.
	(is_a_helper <varpool_node>::test): Likewise.
	(is_a_helper <cgraph_node>::test): Likewise.
	(varpool_variable_node): Likewise.
	(cgraph_function_or_thunk_node): Likewise.
	(varpool_alias_target): Likewise.
	(cgraph_alias_target): Likewise.
	* cgraphbuild.c (remove_cgraph_callee_edges): Likewise.
	(cgraph_rebuild_references): Likewise.
	(rebuild_cgraph_edges): Likewise.
	(record_eh_tables): Likewise.
	(build_cgraph_edges): Likewise.
	(mark_store): Likewise.
	(mark_load): Likewise.
	(mark_address): Likewise.
	(record_type_list): Likewise.
	(record_reference): Likewise.
	* cgraphclones.c (cgraph_materialize_all_clones): Likewise.
	(cgraph_materialize_clone): Likewise.
	(cgraph_copy_node_for_versioning): Likewise.
	(update_call_expr): Likewise.
	(cgraph_find_replacement_node): Likewise.
	(cgraph_create_virtual_clone): Likewise.
	(cgraph_clone_node): Likewise.
	* cgraphunit.c (compile): Likewise.
	(output_weakrefs): Likewise.
	(output_in_order): Likewise.
	(expand_function): Likewise.
	(assemble_thunks_and_aliases): Likewise.
	(expand_thunk): Likewise.
	(mark_functions_to_output): Likewise.
	(handle_alias_pairs): Likewise.
	(analyze_functions): Likewise.
	(walk_polymorphic_call_targets): Likewise.
	(varpool_finalize_decl): Likewise.
	(process_function_and_variable_attributes): Likewise.
	(cgraph_process_same_body_aliases): Likewise.
	(analyze_function): Likewise.
	(cgraph_add_new_function): Likewise.
	(cgraph_finalize_function): Likewise.
	(referred_to_p): Likewise.
	(cgraph_reset_node): Likewise.
	(cgraph_process_new_functions): Likewise.
	(enqueue_node): Likewise.
	(decide_is_symbol_needed): Likewise.
	* coverage.c (coverage_compute_profile_id): Likewise.
	* dbxout.c (dbxout_expand_expr): Likewise.
	* dwarf2out.c (premark_types_used_by_global_vars_helper): Likewise.
	(reference_to_unused): Likewise.
	* gimple-fold.c (can_refer_decl_in_current_unit_p): Likewise.
	* gimplify.c (unvisit_body): Likewise.
	(unshare_body): Likewise.
	* ipa-cp.c (ipcp_generate_summary): Likewise.
	(ipcp_decision_stage): Likewise.
	(identify_dead_nodes): Likewise.
	(decide_whether_version_node): Likewise.
	(decide_about_value): Likewise.
	(perhaps_add_new_callers): Likewise.
	(create_specialized_node): Likewise.
	(update_profiling_info): Likewise.
	(ipcp_propagate_stage): Likewise.
	(propagate_constants_topo): Likewise.
	(estimate_local_effects): Likewise.
	(good_cloning_opportunity_p): Likewise.
	(devirtualization_time_bonus): Likewise.
	(propagate_constants_accross_call): Likewise.
	(initialize_node_lattices): Likewise.
	(ipcp_cloning_candidate_p): Likewise.
	(determine_versionability): Likewise.
	(print_all_lattices): Likewise.
	(print_lattice): Likewise.
	(edge_within_scc): Likewise.
	(ipcp_discover_new_direct_edges): Likewise.
	* ipa-devirt.c (ipa_devirt): Likewise.
	(likely_target_p): Likewise.
	(update_type_inheritance_graph): Likewise.
	(dump_possible_polymorphic_call_targets): Likewise.
	(build_type_inheritance_graph): Likewise.
	(maybe_record_node): Likewise.
	* ipa-inline-analysis.c (inline_write_summary): Likewise.
	(inline_generate_summary): Likewise.
	(inline_analyze_function): Likewise.
	(do_estimate_growth): Likewise.
	(simple_edge_hints): Likewise.
	(estimate_node_size_and_time): Likewise.
	(estimate_edge_devirt_benefit): Likewise.
	(compute_inline_parameters): Likewise.
	(estimate_function_body_sizes): Likewise.
	(compute_bb_predicates): Likewise.
	(initialize_inline_failed): Likewise.
	(dump_inline_summary): Likewise.
	(dump_inline_edge_summary): Likewise.
	* ipa-inline-transform.c (inline_transform): Likewise.
	(preserve_function_body_p): Likewise.
	(save_inline_function_body): Likewise.
	(inline_call): Likewise.
	(clone_inlined_nodes): Likewise.
	(can_remove_node_now_p): Likewise.
	(can_remove_node_now_p_1): Likewise.
	* ipa-inline.c (early_inliner): Likewise.
	(early_inline_small_functions): Likewise.
	(inline_always_inline_functions): Likewise.
	(ipa_inline): Likewise.
	(flatten_function): Likewise.
	(inline_small_functions): Likewise.
	(speculation_useful_p): Likewise.
	(recursive_inlining): Likewise.
	(update_caller_keys): Likewise.
	(reset_edge_caches): Likewise.
	(update_edge_key): Likewise.
	(edge_badness): Likewise.
	(relative_time_benefit): Likewise.
	(want_inline_self_recursive_call_p): Likewise.
	(want_inline_small_function_p): Likewise.
	(want_early_inline_function_p): Likewise.
	(num_calls): Likewise.
	(can_early_inline_edge_p): Likewise.
	(can_inline_edge_p): Likewise.
	(report_inline_failed_reason): Likewise.
	* ipa-profile.c (ipa_profile): Likewise.
	(ipa_propagate_frequency): Likewise.
	(ipa_propagate_frequency_1): Likewise.
	(ipa_profile_generate_summary): Likewise.
	* ipa-prop.c (ipcp_transform_function): Likewise.
	(read_replacements_section): Likewise.
	(ipa_prop_read_section): Likewise.
	(ipa_modify_call_arguments): Likewise.
	(ipa_print_node_params): Likewise.
	(propagate_controlled_uses): Likewise.
	(update_indirect_edges_after_inlining): Likewise.
	(remove_described_reference): Likewise.
	(ipa_make_edge_direct_to_target): Likewise.
	(ipa_analyze_node): Likewise.
	(ipa_analyze_params_uses): Likewise.
	(ipa_compute_jump_functions): Likewise.
	(ipa_get_callee_param_type): Likewise.
	(ipa_print_node_jump_functions): Likewise.
	(ipa_initialize_node_params): Likewise.
	(ipa_populate_param_decls): Likewise.
	(ipa_func_spec_opts_forbid_analysis_p): Likewise.
	(write_agg_replacement_chain): Likewise.
	(ipa_write_node_info): Likewise.
	(ipa_edge_duplication_hook): Likewise.
	(try_decrement_rdesc_refcount): Likewise.
	* ipa-pure-const.c (propagate_nothrow): Likewise.
	(propagate_pure_const): Likewise.
	(pure_const_read_summary): Likewise.
	(pure_const_write_summary): Likewise.
	(analyze_function): Likewise.
	* ipa-ref-inline.h (ipa_ref_referred_ref_list): Likewise.
	(ipa_ref_referring_ref_list): Likewise.
	* ipa-ref.c (ipa_clear_stmts_in_references): Likewise.
	(ipa_remove_stmt_references): Likewise.
	(ipa_find_reference): Likewise.
	(ipa_dump_referring): Likewise.
	(ipa_dump_references): Likewise.
	(ipa_record_reference): Likewise.
	* ipa-reference.c (ipa_reference_read_optimization_summary): Likewise.
	(ipa_reference_write_optimization_summary): Likewise.
	(write_node_summary_p): Likewise.
	(propagate): Likewise.
	(read_write_all_from_decl): Likewise.
	(generate_summary): Likewise.
	(analyze_function): Likewise.
	(propagate_bits): Likewise.
	(ipa_reference_get_not_written_global): Likewise.
	(ipa_reference_get_not_read_global): Likewise.
	* ipa-split.c (execute_split_functions): Likewise.
	(split_function): Likewise.
	* ipa-utils.c (ipa_merge_profiles): Likewise.
	(dump_cgraph_node_set): Likewise.
	(ipa_reverse_postorder): Likewise.
	(ipa_get_nodes_in_cycle): Likewise.
	(ipa_free_postorder_info): Likewise.
	(ipa_reduced_postorder): Likewise.
	(searchc): Likewise.
	(recursive_call_p): Likewise.
	* ipa.c (ipa_cdtor_merge): Likewise.
	(record_cdtor_fn): Likewise.
	(function_and_variable_visibility): Likewise.
	(varpool_externally_visible_p): Likewise.
	(cgraph_externally_visible_p): Likewise.
	(comdat_can_be_unshared_p): Likewise.
	(comdat_can_be_unshared_p_1): Likewise.
	(address_taken_from_non_vtable_p): Likewise.
	(ipa_discover_readonly_nonaddressable_vars): Likewise.
	(symtab_remove_unreachable_nodes): Likewise.
	(process_references): Likewise.
	(enqueue_node): Likewise.
	(has_addr_references_p): Likewise.
	(cgraph_non_local_node_p_1): Likewise.
	* is-a.h (is_a_helper <cgraph_node>::test): Likewise.
	* lto-cgraph.c (input_symtab): Likewise.
	(merge_profile_summaries): Likewise.
	(input_cgraph_1): Likewise.
	(input_edge): Likewise.
	(input_varpool_node): Likewise.
	(input_node): Likewise.
	(input_overwrite_node): Likewise.
	(compute_ltrans_boundary): Likewise.
	(output_refs): Likewise.
	(lto_output_varpool_node): Likewise.
	(lto_output_node): Likewise.
	(reachable_from_other_partition_p): Likewise.
	(referenced_from_other_partition_p): Likewise.
	(lto_output_edge): Likewise.
	(output_node_opt_summary): Likewise.
	(add_node_to): Likewise.
	(reachable_from_this_partition_p): Likewise.
	(lto_set_symtab_encoder_in_partition): Likewise.
	(lto_symtab_encoder_in_partition_p): Likewise.
	(lto_set_symtab_encoder_encode_initializer): Likewise.
	(lto_symtab_encoder_encode_initializer_p): Likewise.
	(lto_set_symtab_encoder_encode_body): Likewise.
	(lto_symtab_encoder_encode_body_p): Likewise.
	* lto-section-in.c (lto_free_function_in_decl_state_for_node):
	Likewise.
	* lto-streamer-in.c (lto_read_body): Likewise.
	(fixup_call_stmt_edges): Likewise.
	(fixup_call_stmt_edges_1): Likewise.
	* lto-streamer-out.c (produce_symtab): Likewise.
	(output_symbol_p): Likewise.
	(write_symbol): Likewise.
	(lto_output): Likewise.
	(copy_function): Likewise.
	(output_function): Likewise.
	* passes.c (function_called_by_processed_nodes_p): Likewise.
	(ipa_write_optimization_summaries): Likewise.
	(ipa_write_summaries): Likewise.
	(do_per_function_toporder): Likewise.
	(do_per_function): Likewise.
	(dump_passes): Likewise.
	* symtab.c (symtab_semantically_equivalent_p): Likewise.
	(symtab_nonoverwritable_alias): Likewise.
	(symtab_nonoverwritable_alias_1): Likewise.
	(symtab_for_node_and_aliases): Likewise.
	(symtab_resolve_alias): Likewise.
	(fixup_same_cpp_alias_visibility): Likewise.
	(symtab_alias_ultimate_target): Likewise.
	(symtab_used_from_object_file_p): Likewise.
	(verify_symtab_base): Likewise.
	(dump_symtab_base): Likewise.
	(symtab_node_name): Likewise.
	(symtab_node_asm_name): Likewise.
	(symtab_dissolve_same_comdat_group_list): Likewise.
	(symtab_add_to_same_comdat_group): Likewise.
	(symtab_unregister_node): Likewise.
	(symtab_insert_node_to_hashtable): Likewise.
	(symtab_register_node): Likewise.
	(unlink_from_assembler_name_hash): Likewise.
	(insert_to_assembler_name_hash): Likewise.
	(eq_assembler_name): Likewise.
	(hash_node_by_assembler_name): Likewise.
	(eq_node): Likewise.
	(hash_node): Likewise.
	* toplev.c (wrapup_global_declaration_2): Likewise.
	* trans-mem.c (ipa_tm_execute): Likewise.
	(ipa_tm_transform_clone): Likewise.
	(ipa_tm_transform_transaction): Likewise.
	(ipa_tm_transform_calls_redirect): Likewise.
	(ipa_tm_insert_gettmclone_call): Likewise.
	(ipa_tm_insert_irr_call): Likewise.
	(ipa_tm_create_version): Likewise.
	(ipa_tm_create_version_alias): Likewise.
	(ipa_tm_mark_forced_by_abi_node): Likewise.
	(ipa_tm_mark_force_output_node): Likewise.
	(ipa_tm_diagnose_tm_safe): Likewise.
	(ipa_tm_mayenterirr_function): Likewise.
	(ipa_tm_scan_irr_function): Likewise.
	(ipa_tm_note_irrevocable): Likewise.
	(ipa_tm_scan_calls_clone): Likewise.
	(get_cg_data): Likewise.
	* tree-eh.c (tree_could_trap_p): Likewise.
	* tree-emutls.c (ipa_lower_emutls): Likewise.
	(create_emultls_var): Likewise.
	(lower_emutls_function_body): Likewise.
	(gen_emutls_addr): Likewise.
	(emutls_decl): Likewise.
	(new_emutls_decl): Likewise.
	* tree-inline.c (tree_function_versioning): Likewise.
	(optimize_inline_calls): Likewise.
	(expand_call_inline): Likewise.
	(estimate_num_insns): Likewise.
	(copy_bb): Likewise.
	(delete_unreachable_blocks_update_callgraph): Likewise.
	* tree-nested.c (gimplify_all_functions): Likewise.
	(create_nesting_tree): Likewise.
	(check_for_nested_with_variably_modified): Likewise.
	* tree-pretty-print.c (dump_function_header): Likewise.
	* tree-profile.c (tree_profiling): Likewise.
	* tree-sra.c (ipa_sra_preliminary_function_checks): Likewise.
	(modify_function): Likewise.
	(convert_callers): Likewise.
	(convert_callers_for_node): Likewise.
	* tree-ssa-structalias.c (ipa_pta_execute): Likewise.
	(associate_varinfo_to_alias): Likewise.
	(create_variable_info_for): Likewise.
	(get_constraint_for_ssa_var): Likewise.
	* tree-vectorizer.c (increase_alignment): Likewise.
	* tree.c (find_decls_types_in_var): Likewise.
	(find_decls_types_in_node): Likewise.
	(free_lang_data_in_decl): Likewise.
	* value-prof.c (gimple_ic_transform): Likewise.
	(gimple_ic): Likewise.
	(check_ic_target): Likewise.
	(init_node_map): Likewise.
	* varasm.c (decl_binds_to_current_def_p): Likewise.
	(default_binds_local_p_1): Likewise.
	(dump_tm_clone_pairs): Likewise.
	(assemble_alias): Likewise.
	(find_decl): Likewise.
	(mark_decl_referenced): Likewise.
	* varpool.c (varpool_for_node_and_aliases): Likewise.
	(varpool_extra_name_alias): Likewise.
	(varpool_create_variable_alias): Likewise.
	(add_new_static_var): Likewise.
	(varpool_finalize_named_section_flags): Likewise.
	(varpool_remove_unreferenced_decls): Likewise.
	(enqueue_node): Likewise.
	(varpool_assemble_decl): Likewise.
	(assemble_aliases): Likewise.
	(varpool_analyze_node): Likewise.
	(cgraph_variable_initializer_availability): Likewise.
	(varpool_add_new_variable): Likewise.
	(ctor_for_folding): Likewise.
	(dump_varpool_node): Likewise.
	(varpool_remove_initializer): Likewise.
	(varpool_remove_node): Likewise.
	(varpool_node_for_decl): Likewise.
	(varpool_create_empty_node): Likewise.
	* config/i386/i386.c (ix86_generate_version_dispatcher_body):
	Likewise.
	(ix86_get_function_versions_dispatcher): Likewise.

gcc/ada/

	Patch autogenerated by refactor_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 761987353e7764909eca0e32c01040ed9574ce80

	* gcc-interface/trans.c (finalize_nrv): Update for conversion of
	symtab types to a true class hierarchy.
	* gcc-interface/utils.c (gnat_write_global_declarations): Likewise.

gcc/c-family/

	Patch autogenerated by refactor_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 761987353e7764909eca0e32c01040ed9574ce80

	* c-gimplify.c (c_genericize): Update for conversion of symtab types
	to a true class hierarchy.
	* c-pragma.c (maybe_apply_pending_pragma_weaks): Likewise.

gcc/cp/

	Patch autogenerated by refactor_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 761987353e7764909eca0e32c01040ed9574ce80

	* call.c (mark_versions_used): Update for conversion of symtab types
	to a true class hierarchy.
	* decl2.c (cp_write_global_declarations): Likewise.
	(clear_decl_external): Likewise.
	(build_java_method_aliases): Likewise.
	(collect_candidates_for_java_method_aliases): Likewise.
	(mark_needed): Likewise.
	(var_finalized_p): Likewise.
	(maybe_make_one_only): Likewise.
	(maybe_emit_vtables): Likewise.
	* lambda.c (maybe_add_lambda_conv_op): Likewise.
	* method.c (use_thunk): Likewise.
	* optimize.c (maybe_clone_body): Likewise.
	* tree.c (cp_fix_function_decl_p): Likewise.

gcc/java/

	Patch autogenerated by refactor_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 761987353e7764909eca0e32c01040ed9574ce80

	* decl.c (java_mark_decl_local): Update for conversion of symtab types
	to a true class hierarchy.

gcc/lto/

	Patch autogenerated by refactor_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 761987353e7764909eca0e32c01040ed9574ce80

	* lto-partition.c (lto_promote_cross_file_statics): Update for
	conversion of symtab types to a true class hierarchy.
	(rename_statics): Likewise.
	(promote_symbol): Likewise.
	(privatize_symbol_name): Likewise.
	(lto_balanced_map): Likewise.
	(varpool_node_cmp): Likewise.
	(node_cmp): Likewise.
	(lto_1_to_1_map): Likewise.
	(undo_partition): Likewise.
	(add_symbol_to_partition): Likewise.
	(contained_in_symbol): Likewise.
	(add_symbol_to_partition_1): Likewise.
	(add_references_to_partition): Likewise.
	(symbol_partitioned_p): Likewise.
	(get_symbol_class): Likewise.
	(lto_max_map): Likewise.
	* lto-symtab.c (lto_symtab_prevailing_decl): Likewise.
	(lto_symtab_merge_symbols): Likewise.
	(lto_symtab_merge_symbols_1): Likewise.
	(lto_symtab_merge_decls): Likewise.
	(lto_symtab_merge_decls_1): Likewise.
	(lto_symtab_merge_decls_2): Likewise.
	(lto_symtab_resolve_symbols): Likewise.
	(lto_symtab_resolve_can_prevail_p): Likewise.
	(lto_symtab_symbol_p): Likewise.
	(lto_symtab_resolve_replaceable_p): Likewise.
	(lto_symtab_merge): Likewise.
	(lto_varpool_replace_node): Likewise.
	(lto_cgraph_replace_node): Likewise.
	* lto.c (lto_main): Likewise.
	(do_whole_program_analysis): Likewise.
	(materialize_cgraph): Likewise.
	(read_cgraph_and_symbols): Likewise.
	(cmp_partitions_order): Likewise.
	(lto_materialize_function): Likewise.
	(has_analyzed_clone_p): Likewise.
---
 gcc/ada/gcc-interface/trans.c |   2 +-
 gcc/ada/gcc-interface/utils.c |   2 +-
 gcc/asan.c                    |  10 +-
 gcc/c-family/c-gimplify.c     |   2 +-
 gcc/c-family/c-pragma.c       |   2 +-
 gcc/cfgexpand.c               |   2 +-
 gcc/cgraph.c                  | 304 +++++++++++++++---------------
 gcc/cgraph.h                  | 130 ++++++-------
 gcc/cgraphbuild.c             |  46 ++---
 gcc/cgraphclones.c            |  90 ++++-----
 gcc/cgraphunit.c              | 300 +++++++++++++++---------------
 gcc/config/i386/i386.c        |  18 +-
 gcc/coverage.c                |   4 +-
 gcc/cp/call.c                 |   2 +-
 gcc/cp/decl2.c                |  26 +--
 gcc/cp/lambda.c               |   4 +-
 gcc/cp/method.c               |   4 +-
 gcc/cp/optimize.c             |   2 +-
 gcc/cp/tree.c                 |   4 +-
 gcc/dbxout.c                  |   2 +-
 gcc/dwarf2out.c               |   4 +-
 gcc/gimple-fold.c             |   8 +-
 gcc/gimplify.c                |   4 +-
 gcc/ipa-cp.c                  |  72 ++++----
 gcc/ipa-devirt.c              |  44 ++---
 gcc/ipa-inline-analysis.c     |  50 ++---
 gcc/ipa-inline-transform.c    |  52 +++---
 gcc/ipa-inline.c              | 168 ++++++++---------
 gcc/ipa-profile.c             |  36 ++--
 gcc/ipa-prop.c                |  86 ++++-----
 gcc/ipa-pure-const.c          |  56 +++---
 gcc/ipa-ref-inline.h          |   4 +-
 gcc/ipa-ref.c                 |  14 +-
 gcc/ipa-reference.c           |  60 +++---
 gcc/ipa-split.c               |  28 +--
 gcc/ipa-utils.c               |  92 +++++-----
 gcc/ipa.c                     | 418 +++++++++++++++++++++---------------------
 gcc/is-a.h                    |   2 +-
 gcc/java/decl.c               |   2 +-
 gcc/lto-cgraph.c              | 274 +++++++++++++--------------
 gcc/lto-section-in.c          |  10 +-
 gcc/lto-streamer-in.c         |   6 +-
 gcc/lto-streamer-out.c        |  38 ++--
 gcc/lto/lto-partition.c       | 200 ++++++++++----------
 gcc/lto/lto-symtab.c          | 206 ++++++++++-----------
 gcc/lto/lto.c                 |  26 +--
 gcc/passes.c                  |  34 ++--
 gcc/symtab.c                  | 386 +++++++++++++++++++-------------------
 gcc/toplev.c                  |   6 +-
 gcc/trans-mem.c               |  94 +++++-----
 gcc/tree-eh.c                 |   4 +-
 gcc/tree-emutls.c             |  40 ++--
 gcc/tree-inline.c             |  42 ++---
 gcc/tree-nested.c             |  10 +-
 gcc/tree-pretty-print.c       |   2 +-
 gcc/tree-profile.c            |  20 +-
 gcc/tree-sra.c                |  20 +-
 gcc/tree-ssa-structalias.c    |  40 ++--
 gcc/tree-vectorizer.c         |   2 +-
 gcc/tree.c                    |  10 +-
 gcc/value-prof.c              |  20 +-
 gcc/varasm.c                  |  30 +--
 gcc/varpool.c                 | 138 +++++++-------
 63 files changed, 1907 insertions(+), 1907 deletions(-)

diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index 4048e0a..7fc9720 100644
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -3207,7 +3207,7 @@ finalize_nrv (tree fndecl, bitmap nrv, vec<tree, va_gc> *other, Node_Id gnat_ret
   /* Prune also the candidates that are referenced by nested functions.  */
   node = cgraph_get_create_node (fndecl);
   for (node = node->nested; node; node = node->next_nested)
-    walk_tree_without_duplicates (&DECL_SAVED_TREE (node->symbol.decl), prune_nrv_r,
+    walk_tree_without_duplicates (&DECL_SAVED_TREE (node->decl), prune_nrv_r,
 				  &data);
   if (bitmap_empty_p (nrv))
     return;
diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c
index 2c3e096..58538e65 100644
--- a/gcc/ada/gcc-interface/utils.c
+++ b/gcc/ada/gcc-interface/utils.c
@@ -5609,7 +5609,7 @@ gnat_write_global_declarations (void)
       TREE_STATIC (dummy_global) = 1;
       TREE_ASM_WRITTEN (dummy_global) = 1;
       node = varpool_node_for_decl (dummy_global);
-      node->symbol.force_output = 1;
+      node->force_output = 1;
 
       while (!types_used_by_cur_var_decl->is_empty ())
 	{
diff --git a/gcc/asan.c b/gcc/asan.c
index e7b1f47..ae4dc4d 100644
--- a/gcc/asan.c
+++ b/gcc/asan.c
@@ -2170,8 +2170,8 @@ asan_finish_file (void)
   tree fn = builtin_decl_implicit (BUILT_IN_ASAN_INIT);
   append_to_statement_list (build_call_expr (fn, 0), &asan_ctor_statements);
   FOR_EACH_DEFINED_VARIABLE (vnode)
-    if (TREE_ASM_WRITTEN (vnode->symbol.decl)
-	&& asan_protect_global (vnode->symbol.decl))
+    if (TREE_ASM_WRITTEN (vnode->decl)
+	&& asan_protect_global (vnode->decl))
       ++gcount;
   htab_t const_desc_htab = constant_pool_htab ();
   htab_traverse (const_desc_htab, count_string_csts, &gcount);
@@ -2192,9 +2192,9 @@ asan_finish_file (void)
       DECL_IGNORED_P (var) = 1;
       vec_alloc (v, gcount);
       FOR_EACH_DEFINED_VARIABLE (vnode)
-	if (TREE_ASM_WRITTEN (vnode->symbol.decl)
-	    && asan_protect_global (vnode->symbol.decl))
-	  asan_add_global (vnode->symbol.decl, TREE_TYPE (type), v);
+	if (TREE_ASM_WRITTEN (vnode->decl)
+	    && asan_protect_global (vnode->decl))
+	  asan_add_global (vnode->decl, TREE_TYPE (type), v);
       struct asan_add_string_csts_data aascd;
       aascd.type = TREE_TYPE (type);
       aascd.v = v;
diff --git a/gcc/c-family/c-gimplify.c b/gcc/c-family/c-gimplify.c
index 3ff0a31..2a4f633 100644
--- a/gcc/c-family/c-gimplify.c
+++ b/gcc/c-family/c-gimplify.c
@@ -98,7 +98,7 @@ c_genericize (tree fndecl)
   /* Dump all nested functions now.  */
   cgn = cgraph_get_create_node (fndecl);
   for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
-    c_genericize (cgn->symbol.decl);
+    c_genericize (cgn->decl);
 }
 
 static void
diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c
index 309859f..409fcb1 100644
--- a/gcc/c-family/c-pragma.c
+++ b/gcc/c-family/c-pragma.c
@@ -322,7 +322,7 @@ maybe_apply_pending_pragma_weaks (void)
 
       target = symtab_node_for_asm (id);
       decl = build_decl (UNKNOWN_LOCATION,
-			 target ? TREE_CODE (target->symbol.decl) : FUNCTION_DECL,
+			 target ? TREE_CODE (target->decl) : FUNCTION_DECL,
 			 alias_id, default_function_type);
 
       DECL_ARTIFICIAL (decl) = 1;
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index 4da5e7e..3a2b413 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -1497,7 +1497,7 @@ estimated_stack_frame_size (struct cgraph_node *node)
   HOST_WIDE_INT size = 0;
   size_t i;
   tree var;
-  struct function *fn = DECL_STRUCT_FUNCTION (node->symbol.decl);
+  struct function *fn = DECL_STRUCT_FUNCTION (node->decl);
 
   push_cfun (fn);
 
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 4b12163..84f617f 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -271,8 +271,8 @@ record_function_versions (tree decl1, tree decl2)
 
 /* Macros to access the next item in the list of free cgraph nodes and
    edges. */
-#define NEXT_FREE_NODE(NODE) cgraph ((NODE)->symbol.next)
-#define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->symbol.next = (symtab_node)NODE2
+#define NEXT_FREE_NODE(NODE) cgraph ((NODE)->next)
+#define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->next = NODE2
 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
 
 /* Register HOOK to be called with DATA on each removed edge.  */
@@ -510,7 +510,7 @@ cgraph_create_empty_node (void)
 {
   struct cgraph_node *node = cgraph_allocate_node ();
 
-  node->symbol.type = SYMTAB_FUNCTION;
+  node->type = SYMTAB_FUNCTION;
   node->frequency = NODE_FREQUENCY_NORMAL;
   node->count_materialization_scale = REG_BR_PROB_BASE;
   cgraph_n_nodes++;
@@ -525,8 +525,8 @@ cgraph_create_node (tree decl)
   struct cgraph_node *node = cgraph_create_empty_node ();
   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 
-  node->symbol.decl = decl;
-  symtab_register_node ((symtab_node) node);
+  node->decl = decl;
+  symtab_register_node (node);
 
   if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
     {
@@ -564,12 +564,12 @@ cgraph_create_function_alias (tree alias, tree target)
 	      || TREE_CODE (target) == IDENTIFIER_NODE);
   gcc_assert (TREE_CODE (alias) == FUNCTION_DECL);
   alias_node = cgraph_get_create_node (alias);
-  gcc_assert (!alias_node->symbol.definition);
-  alias_node->symbol.alias_target = target;
-  alias_node->symbol.definition = true;
-  alias_node->symbol.alias = true;
+  gcc_assert (!alias_node->definition);
+  alias_node->alias_target = target;
+  alias_node->definition = true;
+  alias_node->alias = true;
   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
-    alias_node->symbol.weakref = true;
+    alias_node->weakref = true;
   return alias_node;
 }
 
@@ -592,10 +592,10 @@ cgraph_same_body_alias (struct cgraph_node *decl_node ATTRIBUTE_UNUSED, tree ali
     return NULL;
 
   n = cgraph_create_function_alias (alias, decl);
-  n->symbol.cpp_implicit_alias = true;
+  n->cpp_implicit_alias = true;
   if (cpp_implicit_aliases_done)
-    symtab_resolve_alias ((symtab_node)n,
-			  (symtab_node)cgraph_get_node (decl));
+    symtab_resolve_alias (n,
+			  cgraph_get_node (decl));
   return n;
 }
 
@@ -616,8 +616,8 @@ cgraph_add_thunk (struct cgraph_node *decl_node ATTRIBUTE_UNUSED,
   node = cgraph_get_node (alias);
   if (node)
     {
-      gcc_assert (node->symbol.definition);
-      gcc_assert (!node->symbol.alias);
+      gcc_assert (node->definition);
+      gcc_assert (!node->alias);
       gcc_assert (!node->thunk.thunk_p);
       cgraph_remove_node (node);
     }
@@ -632,7 +632,7 @@ cgraph_add_thunk (struct cgraph_node *decl_node ATTRIBUTE_UNUSED,
   node->thunk.virtual_offset_p = virtual_offset != NULL;
   node->thunk.alias = real_alias;
   node->thunk.thunk_p = true;
-  node->symbol.definition = true;
+  node->definition = true;
 
   return node;
 }
@@ -646,7 +646,7 @@ cgraph_node_for_asm (tree asmname)
   /* We do not want to look at inline clones.  */
   for (symtab_node node = symtab_node_for_asm (asmname);
        node;
-       node = node->symbol.next_sharing_asm_name)
+       node = node->next_sharing_asm_name)
     {
       cgraph_node *cn = dyn_cast <cgraph_node> (node);
       if (cn && !cn->global.inlined_to)
@@ -801,7 +801,7 @@ cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt,
       e = cgraph_make_edge_direct (e, new_callee);
     }
 
-  push_cfun (DECL_STRUCT_FUNCTION (e->caller->symbol.decl));
+  push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
   e->can_throw_external = stmt_can_throw_external (new_stmt);
   pop_cfun ();
   if (e->caller->call_site_hash)
@@ -859,13 +859,13 @@ cgraph_create_edge_1 (struct cgraph_node *caller, struct cgraph_node *callee,
   gcc_assert (freq <= CGRAPH_FREQ_MAX);
 
   edge->call_stmt = call_stmt;
-  push_cfun (DECL_STRUCT_FUNCTION (caller->symbol.decl));
+  push_cfun (DECL_STRUCT_FUNCTION (caller->decl));
   edge->can_throw_external
     = call_stmt ? stmt_can_throw_external (call_stmt) : false;
   pop_cfun ();
   if (call_stmt
-      && callee && callee->symbol.decl
-      && !gimple_check_call_matching_types (call_stmt, callee->symbol.decl,
+      && callee && callee->decl
+      && !gimple_check_call_matching_types (call_stmt, callee->decl,
 					    false))
     edge->call_stmt_cannot_inline_p = true;
   else
@@ -1078,14 +1078,14 @@ cgraph_turn_edge_to_speculative (struct cgraph_edge *e,
     {
       fprintf (dump_file, "Indirect call -> speculative call"
 	       " %s/%i => %s/%i\n",
-	       xstrdup (cgraph_node_name (n)), n->symbol.order,
-	       xstrdup (cgraph_node_name (n2)), n2->symbol.order);
+	       xstrdup (cgraph_node_name (n)), n->order,
+	       xstrdup (cgraph_node_name (n2)), n2->order);
     }
   e->speculative = true;
   e2 = cgraph_create_edge (n, n2, e->call_stmt, direct_count, direct_frequency);
   initialize_inline_failed (e2);
   e2->speculative = true;
-  if (TREE_NOTHROW (n2->symbol.decl))
+  if (TREE_NOTHROW (n2->decl))
     e2->can_throw_external = false;
   else
     e2->can_throw_external = e->can_throw_external;
@@ -1093,7 +1093,7 @@ cgraph_turn_edge_to_speculative (struct cgraph_edge *e,
   e->count -= e2->count;
   e->frequency -= e2->frequency;
   cgraph_call_edge_duplication_hooks (e, e2);
-  ref = ipa_record_reference ((symtab_node)n, (symtab_node)n2,
+  ref = ipa_record_reference (n, n2,
 			      IPA_REF_ADDR, e->call_stmt);
   ref->lto_stmt_uid = e->lto_stmt_uid;
   ref->speculative = e->speculative;
@@ -1147,7 +1147,7 @@ cgraph_speculative_call_info (struct cgraph_edge *e,
   indirect = e2;
 
   reference = NULL;
-  for (i = 0; ipa_ref_list_reference_iterate (&e->caller->symbol.ref_list,
+  for (i = 0; ipa_ref_list_reference_iterate (&e->caller->ref_list,
 					      i, ref); i++)
     if (ref->speculative
 	&& ((ref->stmt && ref->stmt == e->call_stmt)
@@ -1188,7 +1188,7 @@ cgraph_resolve_speculation (struct cgraph_edge *edge, tree callee_decl)
 
   gcc_assert (edge->speculative);
   cgraph_speculative_call_info (edge, e2, edge, ref);
-  if (ref->referred->symbol.decl != callee_decl)
+  if (ref->referred->decl != callee_decl)
     {
       if (dump_file)
 	{
@@ -1196,16 +1196,16 @@ cgraph_resolve_speculation (struct cgraph_edge *edge, tree callee_decl)
 	    {
 	      fprintf (dump_file, "Speculative indirect call %s/%i => %s/%i has "
 		       "turned out to have contradicting known target ",
-		       xstrdup (cgraph_node_name (edge->caller)), edge->caller->symbol.order,
-		       xstrdup (cgraph_node_name (e2->callee)), e2->callee->symbol.order);
+		       xstrdup (cgraph_node_name (edge->caller)), edge->caller->order,
+		       xstrdup (cgraph_node_name (e2->callee)), e2->callee->order);
 	      print_generic_expr (dump_file, callee_decl, 0);
 	      fprintf (dump_file, "\n");
 	    }
 	  else
 	    {
 	      fprintf (dump_file, "Removing speculative call %s/%i => %s/%i\n",
-		       xstrdup (cgraph_node_name (edge->caller)), edge->caller->symbol.order,
-		       xstrdup (cgraph_node_name (e2->callee)), e2->callee->symbol.order);
+		       xstrdup (cgraph_node_name (edge->caller)), edge->caller->order,
+		       xstrdup (cgraph_node_name (e2->callee)), e2->callee->order);
 	    }
 	}
     }
@@ -1247,7 +1247,7 @@ cgraph_make_edge_direct (struct cgraph_edge *edge, struct cgraph_node *callee)
   /* If we are redirecting speculative call, make it non-speculative.  */
   if (edge->indirect_unknown_callee && edge->speculative)
     {
-      edge = cgraph_resolve_speculation (edge, callee->symbol.decl);
+      edge = cgraph_resolve_speculation (edge, callee->decl);
 
       /* On successful speculation just return the pre existing direct edge.  */
       if (!edge->indirect_unknown_callee)
@@ -1278,7 +1278,7 @@ cgraph_make_edge_direct (struct cgraph_edge *edge, struct cgraph_node *callee)
 
   if (edge->call_stmt)
     edge->call_stmt_cannot_inline_p
-      = !gimple_check_call_matching_types (edge->call_stmt, callee->symbol.decl,
+      = !gimple_check_call_matching_types (edge->call_stmt, callee->decl,
 					   false);
 
   /* We need to re-determine the inlining status of the edge.  */
@@ -1315,23 +1315,23 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
 	 signature.  We did not update the call statement yet, so compare it 
 	 with the reference that still points to the proper type.  */
       else if (!gimple_check_call_matching_types (e->call_stmt,
-						  ref->referred->symbol.decl,
+						  ref->referred->decl,
 						  true))
 	{
 	  if (dump_file)
 	    fprintf (dump_file, "Not expanding speculative call of %s/%i -> %s/%i\n"
 		     "Type mismatch.\n",
 		     xstrdup (cgraph_node_name (e->caller)),
-		     e->caller->symbol.order,
+		     e->caller->order,
 		     xstrdup (cgraph_node_name (e->callee)),
-		     e->callee->symbol.order);
+		     e->callee->order);
 	  e = cgraph_resolve_speculation (e, NULL);
 	  /* We are producing the final function body and will throw away the
 	     callgraph edges really soon.  Reset the counts/frequencies to
 	     keep verifier happy in the case of roundoff errors.  */
 	  e->count = gimple_bb (e->call_stmt)->count;
 	  e->frequency = compute_call_stmt_bb_frequency
-			  (e->caller->symbol.decl, gimple_bb (e->call_stmt));
+			  (e->caller->decl, gimple_bb (e->call_stmt));
 	}
       /* Expand speculation into GIMPLE code.  */
       else
@@ -1341,12 +1341,12 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
 		     "Expanding speculative call of %s/%i -> %s/%i count:"
 		     HOST_WIDEST_INT_PRINT_DEC"\n",
 		     xstrdup (cgraph_node_name (e->caller)),
-		     e->caller->symbol.order,
+		     e->caller->order,
 		     xstrdup (cgraph_node_name (e->callee)),
-		     e->callee->symbol.order,
+		     e->callee->order,
 		     (HOST_WIDEST_INT)e->count);
 	  gcc_assert (e2->speculative);
-	  push_cfun (DECL_STRUCT_FUNCTION (e->caller->symbol.decl));
+	  push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
 	  new_stmt = gimple_ic (e->call_stmt, cgraph (ref->referred),
 				e->count || e2->count
 				?  RDIV (e->count * REG_BR_PROB_BASE,
@@ -1360,9 +1360,9 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
 	  cgraph_set_call_stmt_including_clones (e->caller, e->call_stmt,
 						 new_stmt, false);
 	  e->frequency = compute_call_stmt_bb_frequency
-			   (e->caller->symbol.decl, gimple_bb (e->call_stmt));
+			   (e->caller->decl, gimple_bb (e->call_stmt));
 	  e2->frequency = compute_call_stmt_bb_frequency
-			   (e2->caller->symbol.decl, gimple_bb (e2->call_stmt));
+			   (e2->caller->decl, gimple_bb (e2->call_stmt));
 	  e2->speculative = false;
 	  ref->speculative = false;
 	  ref->stmt = NULL;
@@ -1376,7 +1376,7 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
     }
 
   if (e->indirect_unknown_callee
-      || decl == e->callee->symbol.decl)
+      || decl == e->callee->decl)
     return e->call_stmt;
 
 #ifdef ENABLE_CHECKING
@@ -1390,8 +1390,8 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
   if (cgraph_dump_file)
     {
       fprintf (cgraph_dump_file, "updating call of %s/%i -> %s/%i: ",
-	       xstrdup (cgraph_node_name (e->caller)), e->caller->symbol.order,
-	       xstrdup (cgraph_node_name (e->callee)), e->callee->symbol.order);
+	       xstrdup (cgraph_node_name (e->caller)), e->caller->order,
+	       xstrdup (cgraph_node_name (e->callee)), e->callee->order);
       print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
       if (e->callee->clone.combined_args_to_skip)
 	{
@@ -1408,7 +1408,7 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
       new_stmt
 	= gimple_call_copy_skip_args (e->call_stmt,
 				      e->callee->clone.combined_args_to_skip);
-      gimple_call_set_fndecl (new_stmt, e->callee->symbol.decl);
+      gimple_call_set_fndecl (new_stmt, e->callee->decl);
       gimple_call_set_fntype (new_stmt, gimple_call_fntype (e->call_stmt));
 
       if (gimple_vdef (new_stmt)
@@ -1431,7 +1431,7 @@ cgraph_redirect_edge_call_stmt_to_callee (struct cgraph_edge *e)
   else
     {
       new_stmt = e->call_stmt;
-      gimple_call_set_fndecl (new_stmt, e->callee->symbol.decl);
+      gimple_call_set_fndecl (new_stmt, e->callee->decl);
       update_stmt (new_stmt);
     }
 
@@ -1481,7 +1481,7 @@ cgraph_update_edges_for_call_stmt_node (struct cgraph_node *node,
 	      struct cgraph_node *callee = e->callee;
 	      while (callee)
 		{
-		  if (callee->symbol.decl == new_call
+		  if (callee->decl == new_call
 		      || callee->former_clone_of == new_call)
 		    return;
 		  callee = callee->clone_of;
@@ -1654,17 +1654,17 @@ cgraph_release_function_body (struct cgraph_node *node)
   node->ipa_transforms_to_apply.release ();
   if (!node->used_as_abstract_origin && cgraph_state != CGRAPH_STATE_PARSING)
     {
-      DECL_RESULT (node->symbol.decl) = NULL;
-      DECL_ARGUMENTS (node->symbol.decl) = NULL;
+      DECL_RESULT (node->decl) = NULL;
+      DECL_ARGUMENTS (node->decl) = NULL;
     }
   /* If the node is abstract and needed, then do not clear DECL_INITIAL
      of its associated function function declaration because it's
      needed to emit debug info later.  */
-  if (!node->used_as_abstract_origin && DECL_INITIAL (node->symbol.decl))
-    DECL_INITIAL (node->symbol.decl) = error_mark_node;
-  release_function_body (node->symbol.decl);
-  if (node->symbol.lto_file_data)
-    lto_free_function_in_decl_state_for_node ((symtab_node) node);
+  if (!node->used_as_abstract_origin && DECL_INITIAL (node->decl))
+    DECL_INITIAL (node->decl) = error_mark_node;
+  release_function_body (node->decl);
+  if (node->lto_file_data)
+    lto_free_function_in_decl_state_for_node (node);
 }
 
 /* Remove the node from cgraph.  */
@@ -1682,8 +1682,8 @@ cgraph_remove_node (struct cgraph_node *node)
 
   /* Incremental inlining access removed nodes stored in the postorder list.
      */
-  node->symbol.force_output = false;
-  node->symbol.forced_by_abi = false;
+  node->force_output = false;
+  node->forced_by_abi = false;
   for (n = node->nested; n; n = n->next_nested)
     n->origin = NULL;
   node->nested = NULL;
@@ -1695,7 +1695,7 @@ cgraph_remove_node (struct cgraph_node *node)
 	node2 = &(*node2)->next_nested;
       *node2 = node->next_nested;
     }
-  symtab_unregister_node ((symtab_node)node);
+  symtab_unregister_node (node);
   if (node->prev_sibling_clone)
     node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
   else if (node->clone_of)
@@ -1739,18 +1739,18 @@ cgraph_remove_node (struct cgraph_node *node)
      */
   if (cgraph_state != CGRAPH_LTO_STREAMING)
     {
-      n = cgraph_get_node (node->symbol.decl);
+      n = cgraph_get_node (node->decl);
       if (!n
 	  || (!n->clones && !n->clone_of && !n->global.inlined_to
 	      && (cgraph_global_info_ready
-		  && (TREE_ASM_WRITTEN (n->symbol.decl)
-		      || DECL_EXTERNAL (n->symbol.decl)
-		      || !n->symbol.analyzed
-		      || (!flag_wpa && n->symbol.in_other_partition)))))
+		  && (TREE_ASM_WRITTEN (n->decl)
+		      || DECL_EXTERNAL (n->decl)
+		      || !n->analyzed
+		      || (!flag_wpa && n->in_other_partition)))))
 	cgraph_release_function_body (node);
     }
 
-  node->symbol.decl = NULL;
+  node->decl = NULL;
   if (node->call_site_hash)
     {
       htab_delete (node->call_site_hash);
@@ -1761,7 +1761,7 @@ cgraph_remove_node (struct cgraph_node *node)
   /* Clear out the node to NULL all pointers and add the node to the free
      list.  */
   memset (node, 0, sizeof(*node));
-  node->symbol.type = SYMTAB_FUNCTION;
+  node->type = SYMTAB_FUNCTION;
   node->uid = uid;
   SET_NEXT_FREE_NODE (node, free_nodes);
   free_nodes = node;
@@ -1786,9 +1786,9 @@ cgraph_mark_address_taken_node (struct cgraph_node *node)
      of the object was taken (and thus it should be set on node alias is
      referring to).  We should remove the first use and the remove the
      following set.  */
-  node->symbol.address_taken = 1;
+  node->address_taken = 1;
   node = cgraph_function_or_thunk_node (node, NULL);
-  node->symbol.address_taken = 1;
+  node->address_taken = 1;
 }
 
 /* Return local info for the compiled function.  */
@@ -1830,7 +1830,7 @@ cgraph_rtl_info (tree decl)
   node = cgraph_get_node (decl);
   if (!node
       || (decl != current_function_decl
-	  && !TREE_ASM_WRITTEN (node->symbol.decl)))
+	  && !TREE_ASM_WRITTEN (node->decl)))
     return NULL;
   return &node->rtl;
 }
@@ -1866,18 +1866,18 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
   struct cgraph_edge *edge;
   int indirect_calls_count = 0;
 
-  dump_symtab_base (f, (symtab_node) node);
+  dump_symtab_base (f, node);
 
   if (node->global.inlined_to)
     fprintf (f, "  Function %s/%i is inline copy in %s/%i\n",
 	     xstrdup (cgraph_node_name (node)),
-	     node->symbol.order,
+	     node->order,
 	     xstrdup (cgraph_node_name (node->global.inlined_to)),
-	     node->global.inlined_to->symbol.order);
+	     node->global.inlined_to->order);
   if (node->clone_of)
     fprintf (f, "  Clone of %s/%i\n",
 	     cgraph_node_asm_name (node->clone_of),
-	     node->clone_of->symbol.order);
+	     node->clone_of->order);
   if (cgraph_function_flags_ready)
     fprintf (f, "  Availability: %s\n",
 	     cgraph_availability_names [cgraph_function_body_availability (node)]);
@@ -1891,7 +1891,7 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
 	     (HOST_WIDEST_INT)node->count);
   if (node->origin)
     fprintf (f, " nested in: %s", cgraph_node_asm_name (node->origin));
-  if (gimple_has_body_p (node->symbol.decl))
+  if (gimple_has_body_p (node->decl))
     fprintf (f, " body");
   if (node->process)
     fprintf (f, " process");
@@ -1921,7 +1921,7 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
 	       (int)node->thunk.virtual_value,
 	       (int)node->thunk.virtual_offset_p);
     }
-  if (node->symbol.alias && node->thunk.alias
+  if (node->alias && node->thunk.alias
       && DECL_P (node->thunk.alias))
     {
       fprintf (f, "  Alias of %s",
@@ -1937,7 +1937,7 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
   for (edge = node->callers; edge; edge = edge->next_caller)
     {
       fprintf (f, "%s/%i ", cgraph_node_asm_name (edge->caller),
-	       edge->caller->symbol.order);
+	       edge->caller->order);
       if (edge->count)
 	fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
 		 (HOST_WIDEST_INT)edge->count);
@@ -1958,7 +1958,7 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
   for (edge = node->callees; edge; edge = edge->next_callee)
     {
       fprintf (f, "%s/%i ", cgraph_node_asm_name (edge->callee),
-	       edge->callee->symbol.order);
+	       edge->callee->order);
       if (edge->speculative)
 	fprintf(f, "(speculative) ");
       if (!edge->inline_failed)
@@ -2042,18 +2042,18 @@ enum availability
 cgraph_function_body_availability (struct cgraph_node *node)
 {
   enum availability avail;
-  if (!node->symbol.analyzed)
+  if (!node->analyzed)
     avail = AVAIL_NOT_AVAILABLE;
   else if (node->local.local)
     avail = AVAIL_LOCAL;
-  else if (node->symbol.alias && node->symbol.weakref)
+  else if (node->alias && node->weakref)
     cgraph_function_or_thunk_node (node, &avail);
-  else if (!node->symbol.externally_visible)
+  else if (!node->externally_visible)
     avail = AVAIL_AVAILABLE;
   /* Inline functions are safe to be analyzed even if their symbol can
      be overwritten at runtime.  It is not meaningful to enforce any sane
      behaviour on replacing inline function by different body.  */
-  else if (DECL_DECLARED_INLINE_P (node->symbol.decl))
+  else if (DECL_DECLARED_INLINE_P (node->decl))
     avail = AVAIL_AVAILABLE;
 
   /* If the function can be overwritten, return OVERWRITABLE.  Take
@@ -2066,8 +2066,8 @@ cgraph_function_body_availability (struct cgraph_node *node)
      AVAIL_AVAILABLE here?  That would be good reason to preserve this
      bit.  */
 
-  else if (decl_replaceable_p (node->symbol.decl)
-	   && !DECL_EXTERNAL (node->symbol.decl))
+  else if (decl_replaceable_p (node->decl)
+	   && !DECL_EXTERNAL (node->decl))
     avail = AVAIL_OVERWRITABLE;
   else avail = AVAIL_AVAILABLE;
 
@@ -2079,12 +2079,12 @@ static bool
 cgraph_node_cannot_be_local_p_1 (struct cgraph_node *node,
 				 void *data ATTRIBUTE_UNUSED)
 {
-  return !(!node->symbol.force_output
-	   && ((DECL_COMDAT (node->symbol.decl)
-		&& !node->symbol.forced_by_abi
-	        && !symtab_used_from_object_file_p ((symtab_node) node)
-		&& !node->symbol.same_comdat_group)
-	       || !node->symbol.externally_visible));
+  return !(!node->force_output
+	   && ((DECL_COMDAT (node->decl)
+		&& !node->forced_by_abi
+	        && !symtab_used_from_object_file_p (node)
+		&& !node->same_comdat_group)
+	       || !node->externally_visible));
 }
 
 /* Return true if NODE can be made local for API change.
@@ -2094,7 +2094,7 @@ cgraph_node_cannot_be_local_p_1 (struct cgraph_node *node,
 bool
 cgraph_node_can_be_local_p (struct cgraph_node *node)
 {
-  return (!node->symbol.address_taken
+  return (!node->address_taken
 	  && !cgraph_for_node_and_aliases (node,
 					   cgraph_node_cannot_be_local_p_1,
 					   NULL, true));
@@ -2123,7 +2123,7 @@ cgraph_for_node_thunks_and_aliases (struct cgraph_node *node,
       if (cgraph_for_node_thunks_and_aliases (e->caller, callback, data,
 					      include_overwritable))
 	return true;
-  for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list, i, ref); i++)
+  for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
     if (ref->use == IPA_REF_ALIAS)
       {
 	struct cgraph_node *alias = ipa_ref_referring_node (ref);
@@ -2151,7 +2151,7 @@ cgraph_for_node_and_aliases (struct cgraph_node *node,
 
   if (callback (node, data))
     return true;
-  for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list, i, ref); i++)
+  for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
     if (ref->use == IPA_REF_ALIAS)
       {
 	struct cgraph_node *alias = ipa_ref_referring_node (ref);
@@ -2170,16 +2170,16 @@ static bool
 cgraph_make_node_local_1 (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
 {
   gcc_checking_assert (cgraph_node_can_be_local_p (node));
-  if (DECL_COMDAT (node->symbol.decl) || DECL_EXTERNAL (node->symbol.decl))
+  if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
     {
-      symtab_make_decl_local (node->symbol.decl);
+      symtab_make_decl_local (node->decl);
 
-      node->symbol.externally_visible = false;
-      node->symbol.forced_by_abi = false;
+      node->externally_visible = false;
+      node->forced_by_abi = false;
       node->local.local = true;
-      node->symbol.unique_name = (node->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY
-				  || node->symbol.resolution == LDPR_PREVAILING_DEF_IRONLY_EXP);
-      node->symbol.resolution = LDPR_PREVAILING_DEF_IRONLY;
+      node->unique_name = (node->resolution == LDPR_PREVAILING_DEF_IRONLY
+				  || node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP);
+      node->resolution = LDPR_PREVAILING_DEF_IRONLY;
       gcc_assert (cgraph_function_body_availability (node) == AVAIL_LOCAL);
     }
   return false;
@@ -2201,7 +2201,7 @@ cgraph_set_nothrow_flag_1 (struct cgraph_node *node, void *data)
 {
   struct cgraph_edge *e;
 
-  TREE_NOTHROW (node->symbol.decl) = data != NULL;
+  TREE_NOTHROW (node->decl) = data != NULL;
 
   if (data != NULL)
     for (e = node->callers; e; e = e->next_caller)
@@ -2228,13 +2228,13 @@ cgraph_set_const_flag_1 (struct cgraph_node *node, void *data)
      optimized out.  */
   if (data && !((size_t)data & 2))
     {
-      if (DECL_STATIC_CONSTRUCTOR (node->symbol.decl))
-	DECL_STATIC_CONSTRUCTOR (node->symbol.decl) = 0;
-      if (DECL_STATIC_DESTRUCTOR (node->symbol.decl))
-	DECL_STATIC_DESTRUCTOR (node->symbol.decl) = 0;
+      if (DECL_STATIC_CONSTRUCTOR (node->decl))
+	DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
+      if (DECL_STATIC_DESTRUCTOR (node->decl))
+	DECL_STATIC_DESTRUCTOR (node->decl) = 0;
     }
-  TREE_READONLY (node->symbol.decl) = data != NULL;
-  DECL_LOOPING_CONST_OR_PURE_P (node->symbol.decl) = ((size_t)data & 2) != 0;
+  TREE_READONLY (node->decl) = data != NULL;
+  DECL_LOOPING_CONST_OR_PURE_P (node->decl) = ((size_t)data & 2) != 0;
   return false;
 }
 
@@ -2258,13 +2258,13 @@ cgraph_set_pure_flag_1 (struct cgraph_node *node, void *data)
      optimized out.  */
   if (data && !((size_t)data & 2))
     {
-      if (DECL_STATIC_CONSTRUCTOR (node->symbol.decl))
-	DECL_STATIC_CONSTRUCTOR (node->symbol.decl) = 0;
-      if (DECL_STATIC_DESTRUCTOR (node->symbol.decl))
-	DECL_STATIC_DESTRUCTOR (node->symbol.decl) = 0;
+      if (DECL_STATIC_CONSTRUCTOR (node->decl))
+	DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
+      if (DECL_STATIC_DESTRUCTOR (node->decl))
+	DECL_STATIC_DESTRUCTOR (node->decl) = 0;
     }
-  DECL_PURE_P (node->symbol.decl) = data != NULL;
-  DECL_LOOPING_CONST_OR_PURE_P (node->symbol.decl) = ((size_t)data & 2) != 0;
+  DECL_PURE_P (node->decl) = data != NULL;
+  DECL_LOOPING_CONST_OR_PURE_P (node->decl) = ((size_t)data & 2) != 0;
   return false;
 }
 
@@ -2285,7 +2285,7 @@ cgraph_set_pure_flag (struct cgraph_node *node, bool pure, bool looping)
 bool
 cgraph_node_cannot_return (struct cgraph_node *node)
 {
-  int flags = flags_from_decl_or_type (node->symbol.decl);
+  int flags = flags_from_decl_or_type (node->decl);
   if (!flag_exceptions)
     return (flags & ECF_NORETURN) != 0;
   else
@@ -2324,19 +2324,19 @@ cgraph_can_remove_if_no_direct_calls_and_refs_p (struct cgraph_node *node)
 {
   gcc_assert (!node->global.inlined_to);
   /* Extern inlines can always go, we will use the external definition.  */
-  if (DECL_EXTERNAL (node->symbol.decl))
+  if (DECL_EXTERNAL (node->decl))
     return true;
   /* When function is needed, we can not remove it.  */
-  if (node->symbol.force_output || node->symbol.used_from_other_partition)
+  if (node->force_output || node->used_from_other_partition)
     return false;
-  if (DECL_STATIC_CONSTRUCTOR (node->symbol.decl)
-      || DECL_STATIC_DESTRUCTOR (node->symbol.decl))
+  if (DECL_STATIC_CONSTRUCTOR (node->decl)
+      || DECL_STATIC_DESTRUCTOR (node->decl))
     return false;
   /* Only COMDAT functions can be removed if externally visible.  */
-  if (node->symbol.externally_visible
-      && (!DECL_COMDAT (node->symbol.decl)
-	  || node->symbol.forced_by_abi
-	  || symtab_used_from_object_file_p ((symtab_node) node)))
+  if (node->externally_visible
+      && (!DECL_COMDAT (node->decl)
+	  || node->forced_by_abi
+	  || symtab_used_from_object_file_p (node)))
     return false;
   return true;
 }
@@ -2356,9 +2356,9 @@ bool
 cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node)
 {
   /* Extern inlines can always go, we will use the external definition.  */
-  if (DECL_EXTERNAL (node->symbol.decl))
+  if (DECL_EXTERNAL (node->decl))
     return true;
-  if (node->symbol.address_taken)
+  if (node->address_taken)
     return false;
   return !cgraph_for_node_and_aliases (node, nonremovable_p, NULL, true);
 }
@@ -2368,7 +2368,7 @@ cgraph_can_remove_if_no_direct_calls_p (struct cgraph_node *node)
 static bool
 used_from_object_file_p (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED)
 {
-  return symtab_used_from_object_file_p ((symtab_node) node);
+  return symtab_used_from_object_file_p (node);
 }
 
 /* Return true when function NODE can be expected to be removed
@@ -2395,7 +2395,7 @@ cgraph_will_be_removed_from_program_if_no_direct_calls (struct cgraph_node *node
     return cgraph_only_called_directly_p (node);
   else
     {
-       if (DECL_EXTERNAL (node->symbol.decl))
+       if (DECL_EXTERNAL (node->decl))
          return true;
       return cgraph_can_remove_if_no_direct_calls_p (node);
     }
@@ -2485,7 +2485,7 @@ verify_edge_count_and_frequency (struct cgraph_edge *e)
       error ("caller edge frequency is too large");
       error_found = true;
     }
-  if (gimple_has_body_p (e->caller->symbol.decl)
+  if (gimple_has_body_p (e->caller->decl)
       && !e->caller->global.inlined_to
       && !e->speculative
       /* FIXME: Inline-analysis sets frequency to 0 when edge is optimized out.
@@ -2495,12 +2495,12 @@ verify_edge_count_and_frequency (struct cgraph_edge *e)
 	      && ((inline_edge_summary_vec.length () <= (unsigned) e->uid)
 	          || !inline_edge_summary (e)->predicate)))
       && (e->frequency
-	  != compute_call_stmt_bb_frequency (e->caller->symbol.decl,
+	  != compute_call_stmt_bb_frequency (e->caller->decl,
 					     gimple_bb (e->call_stmt))))
     {
       error ("caller edge frequency %i does not match BB frequency %i",
 	     e->frequency,
-	     compute_call_stmt_bb_frequency (e->caller->symbol.decl,
+	     compute_call_stmt_bb_frequency (e->caller->decl,
 					     gimple_bb (e->call_stmt)));
       error_found = true;
     }
@@ -2542,11 +2542,11 @@ verify_edge_corresponds_to_fndecl (struct cgraph_edge *e, tree decl)
 
   /* We do not know if a node from a different partition is an alias or what it
      aliases and therefore cannot do the former_clone_of check reliably.  */
-  if (!node || node->symbol.in_other_partition || e->callee->symbol.in_other_partition)
+  if (!node || node->in_other_partition || e->callee->in_other_partition)
     return false;
   node = cgraph_function_or_thunk_node (node, NULL);
 
-  if (e->callee->former_clone_of != node->symbol.decl
+  if (e->callee->former_clone_of != node->decl
       /* IPA-CP sometimes redirect edge to clone and then back to the former
 	 function.  This ping-pong has to go, eventually.  */
       && (node != cgraph_function_or_thunk_node (e->callee, NULL))
@@ -2561,7 +2561,7 @@ DEBUG_FUNCTION void
 verify_cgraph_node (struct cgraph_node *node)
 {
   struct cgraph_edge *e;
-  struct function *this_cfun = DECL_STRUCT_FUNCTION (node->symbol.decl);
+  struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl);
   basic_block this_block;
   gimple_stmt_iterator gsi;
   bool error_found = false;
@@ -2570,7 +2570,7 @@ verify_cgraph_node (struct cgraph_node *node)
     return;
 
   timevar_push (TV_CGRAPH_VERIFY);
-  error_found |= verify_symtab_base ((symtab_node) node);
+  error_found |= verify_symtab_base (node);
   for (e = node->callees; e; e = e->next_callee)
     if (e->aux)
       {
@@ -2584,27 +2584,27 @@ verify_cgraph_node (struct cgraph_node *node)
       error ("execution count is negative");
       error_found = true;
     }
-  if (node->global.inlined_to && node->symbol.same_comdat_group)
+  if (node->global.inlined_to && node->same_comdat_group)
     {
       error ("inline clone in same comdat group list");
       error_found = true;
     }
-  if (!node->symbol.definition && !node->symbol.in_other_partition && node->local.local)
+  if (!node->definition && !node->in_other_partition && node->local.local)
     {
       error ("local symbols must be defined");
       error_found = true;
     }
-  if (node->global.inlined_to && node->symbol.externally_visible)
+  if (node->global.inlined_to && node->externally_visible)
     {
       error ("externally visible inline clone");
       error_found = true;
     }
-  if (node->global.inlined_to && node->symbol.address_taken)
+  if (node->global.inlined_to && node->address_taken)
     {
       error ("inline clone with address taken");
       error_found = true;
     }
-  if (node->global.inlined_to && node->symbol.force_output)
+  if (node->global.inlined_to && node->force_output)
     {
       error ("inline clone is forced to output");
       error_found = true;
@@ -2707,7 +2707,7 @@ verify_cgraph_node (struct cgraph_node *node)
       error_found = true;
     }
 
-  if (node->symbol.analyzed && node->symbol.alias)
+  if (node->analyzed && node->alias)
     {
       bool ref_found = false;
       int i;
@@ -2718,7 +2718,7 @@ verify_cgraph_node (struct cgraph_node *node)
 	  error ("Alias has call edges");
           error_found = true;
 	}
-      for (i = 0; ipa_ref_list_reference_iterate (&node->symbol.ref_list,
+      for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list,
 						  i, ref); i++)
 	if (ref->use != IPA_REF_ALIAS)
 	  {
@@ -2738,7 +2738,7 @@ verify_cgraph_node (struct cgraph_node *node)
 	    error_found = true;
 	  }
     }
-  if (node->symbol.analyzed && node->thunk.thunk_p)
+  if (node->analyzed && node->thunk.thunk_p)
     {
       if (!node->callees)
 	{
@@ -2750,15 +2750,15 @@ verify_cgraph_node (struct cgraph_node *node)
 	  error ("More than one edge out of thunk node");
           error_found = true;
 	}
-      if (gimple_has_body_p (node->symbol.decl))
+      if (gimple_has_body_p (node->decl))
         {
 	  error ("Thunk is not supposed to have body");
           error_found = true;
         }
     }
-  else if (node->symbol.analyzed && gimple_has_body_p (node->symbol.decl)
-           && !TREE_ASM_WRITTEN (node->symbol.decl)
-           && (!DECL_EXTERNAL (node->symbol.decl) || node->global.inlined_to)
+  else if (node->analyzed && gimple_has_body_p (node->decl)
+           && !TREE_ASM_WRITTEN (node->decl)
+           && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to)
            && !flag_wpa)
     {
       if (this_cfun->cfg)
@@ -2797,7 +2797,7 @@ verify_cgraph_node (struct cgraph_node *node)
 			      if (verify_edge_corresponds_to_fndecl (e, decl))
 				{
 				  error ("edge points to wrong declaration:");
-				  debug_tree (e->callee->symbol.decl);
+				  debug_tree (e->callee->decl);
 				  fprintf (stderr," Instead of:");
 				  debug_tree (decl);
 				  error_found = true;
@@ -2823,7 +2823,7 @@ verify_cgraph_node (struct cgraph_node *node)
 		}
 	      }
 	    for (i = 0;
-		 ipa_ref_list_reference_iterate (&node->symbol.ref_list, i, ref);
+		 ipa_ref_list_reference_iterate (&node->ref_list, i, ref);
 		 i++)
 	      if (ref->stmt && !pointer_set_contains (stmts, ref->stmt))
 		{
@@ -2912,17 +2912,17 @@ cgraph_get_create_real_symbol_node (tree decl)
     {
       first_clone->clone_of = node;
       node->clones = first_clone;
-      symtab_prevail_in_asm_name_hash ((symtab_node) node);
-      symtab_insert_node_to_hashtable ((symtab_node) node);
+      symtab_prevail_in_asm_name_hash (node);
+      symtab_insert_node_to_hashtable (node);
       if (dump_file)
 	fprintf (dump_file, "Introduced new external node "
 		 "(%s/%i) and turned into root of the clone tree.\n",
-		 xstrdup (cgraph_node_name (node)), node->symbol.order);
+		 xstrdup (cgraph_node_name (node)), node->order);
     }
   else if (dump_file)
     fprintf (dump_file, "Introduced new external node "
 	     "(%s/%i).\n", xstrdup (cgraph_node_name (node)),
-	     node->symbol.order);
+	     node->order);
   return node;
 }
 
@@ -2961,14 +2961,14 @@ cgraph_get_body (struct cgraph_node *node)
   struct lto_file_decl_data *file_data;
   const char *data, *name;
   size_t len;
-  tree decl = node->symbol.decl;
+  tree decl = node->decl;
 
   if (DECL_RESULT (decl))
     return false;
 
   gcc_assert (in_lto_p);
 
-  file_data = node->symbol.lto_file_data;
+  file_data = node->lto_file_data;
   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
 
   /* We may have renamed the declaration, e.g., a static function.  */
@@ -2990,7 +2990,7 @@ cgraph_get_body (struct cgraph_node *node)
   lto_stats.num_function_bodies++;
   lto_free_section_data (file_data, LTO_section_function_body, name,
 			 data, len);
-  lto_free_function_in_decl_state_for_node ((symtab_node) node);
+  lto_free_function_in_decl_state_for_node (node);
   return true;
 }
 
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 2bd2dc4..6e825846 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -547,7 +547,7 @@ template <>
 inline bool
 is_a_helper <cgraph_node>::test (symtab_node_base *p)
 {
-  return p->symbol.type == SYMTAB_FUNCTION;
+  return p->type == SYMTAB_FUNCTION;
 }
 
 /* Report whether or not THIS symtab node is a vriable, aka varpool_node.  */
@@ -557,7 +557,7 @@ template <>
 inline bool
 is_a_helper <varpool_node>::test (symtab_node_base *p)
 {
-  return p->symbol.type == SYMTAB_VARIABLE;
+  return p->type == SYMTAB_VARIABLE;
 }
 
 extern GTY(()) symtab_node symtab_nodes;
@@ -850,7 +850,7 @@ void varpool_remove_initializer (struct varpool_node *);
 static inline struct cgraph_node *
 cgraph (symtab_node node)
 {
-  gcc_checking_assert (!node || node->symbol.type == SYMTAB_FUNCTION);
+  gcc_checking_assert (!node || node->type == SYMTAB_FUNCTION);
   return (struct cgraph_node *)node;
 }
 
@@ -858,7 +858,7 @@ cgraph (symtab_node node)
 static inline struct varpool_node *
 varpool (symtab_node node)
 {
-  gcc_checking_assert (!node || node->symbol.type == SYMTAB_VARIABLE);
+  gcc_checking_assert (!node || node->type == SYMTAB_VARIABLE);
   return (struct varpool_node *)node;
 }
 
@@ -882,33 +882,33 @@ varpool_get_node (const_tree decl)
 static inline const char *
 cgraph_node_asm_name (struct cgraph_node *node)
 {
-  return symtab_node_asm_name ((symtab_node)node);
+  return symtab_node_asm_name (node);
 }
 
 /* Return asm name of varpool node.  */
 static inline const char *
 varpool_node_asm_name(struct varpool_node *node)
 {
-  return symtab_node_asm_name ((symtab_node)node);
+  return symtab_node_asm_name (node);
 }
 
 /* Return name of cgraph node.  */
 static inline const char *
 cgraph_node_name(struct cgraph_node *node)
 {
-  return symtab_node_name ((symtab_node)node);
+  return symtab_node_name (node);
 }
 
 /* Return name of varpool node.  */
 static inline const char *
 varpool_node_name(struct varpool_node *node)
 {
-  return symtab_node_name ((symtab_node)node);
+  return symtab_node_name (node);
 }
 
 /* Walk all symbols.  */
 #define FOR_EACH_SYMBOL(node) \
-   for ((node) = symtab_nodes; (node); (node) = (node)->symbol.next)
+   for ((node) = symtab_nodes; (node); (node) = (node)->next)
 
 
 /* Return first variable.  */
@@ -916,7 +916,7 @@ static inline struct varpool_node *
 varpool_first_variable (void)
 {
   symtab_node node;
-  for (node = symtab_nodes; node; node = node->symbol.next)
+  for (node = symtab_nodes; node; node = node->next)
     if (varpool_node *vnode = dyn_cast <varpool_node> (node))
       return vnode;
   return NULL;
@@ -926,8 +926,8 @@ varpool_first_variable (void)
 static inline struct varpool_node *
 varpool_next_variable (struct varpool_node *node)
 {
-  symtab_node node1 = (symtab_node) node->symbol.next;
-  for (; node1; node1 = node1->symbol.next)
+  symtab_node node1 = node->next;
+  for (; node1; node1 = node1->next)
     if (varpool_node *vnode1 = dyn_cast <varpool_node> (node1))
       return vnode1;
   return NULL;
@@ -943,10 +943,10 @@ static inline struct varpool_node *
 varpool_first_static_initializer (void)
 {
   symtab_node node;
-  for (node = symtab_nodes; node; node = node->symbol.next)
+  for (node = symtab_nodes; node; node = node->next)
     {
       varpool_node *vnode = dyn_cast <varpool_node> (node);
-      if (vnode && DECL_INITIAL (node->symbol.decl))
+      if (vnode && DECL_INITIAL (node->decl))
 	return vnode;
     }
   return NULL;
@@ -956,11 +956,11 @@ varpool_first_static_initializer (void)
 static inline struct varpool_node *
 varpool_next_static_initializer (struct varpool_node *node)
 {
-  symtab_node node1 = (symtab_node) node->symbol.next;
-  for (; node1; node1 = node1->symbol.next)
+  symtab_node node1 = node->next;
+  for (; node1; node1 = node1->next)
     {
       varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
-      if (vnode1 && DECL_INITIAL (node1->symbol.decl))
+      if (vnode1 && DECL_INITIAL (node1->decl))
 	return vnode1;
     }
   return NULL;
@@ -976,10 +976,10 @@ static inline struct varpool_node *
 varpool_first_defined_variable (void)
 {
   symtab_node node;
-  for (node = symtab_nodes; node; node = node->symbol.next)
+  for (node = symtab_nodes; node; node = node->next)
     {
       varpool_node *vnode = dyn_cast <varpool_node> (node);
-      if (vnode && vnode->symbol.definition)
+      if (vnode && vnode->definition)
 	return vnode;
     }
   return NULL;
@@ -989,11 +989,11 @@ varpool_first_defined_variable (void)
 static inline struct varpool_node *
 varpool_next_defined_variable (struct varpool_node *node)
 {
-  symtab_node node1 = (symtab_node) node->symbol.next;
-  for (; node1; node1 = node1->symbol.next)
+  symtab_node node1 = node->next;
+  for (; node1; node1 = node1->next)
     {
       varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
-      if (vnode1 && vnode1->symbol.definition)
+      if (vnode1 && vnode1->definition)
 	return vnode1;
     }
   return NULL;
@@ -1008,10 +1008,10 @@ static inline struct cgraph_node *
 cgraph_first_defined_function (void)
 {
   symtab_node node;
-  for (node = symtab_nodes; node; node = node->symbol.next)
+  for (node = symtab_nodes; node; node = node->next)
     {
       cgraph_node *cn = dyn_cast <cgraph_node> (node);
-      if (cn && cn->symbol.definition)
+      if (cn && cn->definition)
 	return cn;
     }
   return NULL;
@@ -1021,11 +1021,11 @@ cgraph_first_defined_function (void)
 static inline struct cgraph_node *
 cgraph_next_defined_function (struct cgraph_node *node)
 {
-  symtab_node node1 = (symtab_node) node->symbol.next;
-  for (; node1; node1 = node1->symbol.next)
+  symtab_node node1 = node->next;
+  for (; node1; node1 = node1->next)
     {
       cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
-      if (cn1 && cn1->symbol.definition)
+      if (cn1 && cn1->definition)
 	return cn1;
     }
   return NULL;
@@ -1041,7 +1041,7 @@ static inline struct cgraph_node *
 cgraph_first_function (void)
 {
   symtab_node node;
-  for (node = symtab_nodes; node; node = node->symbol.next)
+  for (node = symtab_nodes; node; node = node->next)
     if (cgraph_node *cn = dyn_cast <cgraph_node> (node))
       return cn;
   return NULL;
@@ -1051,8 +1051,8 @@ cgraph_first_function (void)
 static inline struct cgraph_node *
 cgraph_next_function (struct cgraph_node *node)
 {
-  symtab_node node1 = (symtab_node) node->symbol.next;
-  for (; node1; node1 = node1->symbol.next)
+  symtab_node node1 = node->next;
+  for (; node1; node1 = node1->next)
     if (cgraph_node *cn1 = dyn_cast <cgraph_node> (node1))
       return cn1;
   return NULL;
@@ -1071,7 +1071,7 @@ cgraph_next_function (struct cgraph_node *node)
 static inline bool
 cgraph_function_with_gimple_body_p (struct cgraph_node *node)
 {
-  return node->symbol.definition && !node->thunk.thunk_p && !node->symbol.alias;
+  return node->definition && !node->thunk.thunk_p && !node->alias;
 }
 
 /* Return first function with body defined.  */
@@ -1079,7 +1079,7 @@ static inline struct cgraph_node *
 cgraph_first_function_with_gimple_body (void)
 {
   symtab_node node;
-  for (node = symtab_nodes; node; node = node->symbol.next)
+  for (node = symtab_nodes; node; node = node->next)
     {
       cgraph_node *cn = dyn_cast <cgraph_node> (node);
       if (cn && cgraph_function_with_gimple_body_p (cn))
@@ -1092,8 +1092,8 @@ cgraph_first_function_with_gimple_body (void)
 static inline struct cgraph_node *
 cgraph_next_function_with_gimple_body (struct cgraph_node *node)
 {
-  symtab_node node1 = node->symbol.next;
-  for (; node1; node1 = node1->symbol.next)
+  symtab_node node1 = node->next;
+  for (; node1; node1 = node1->next)
     {
       cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
       if (cn1 && cgraph_function_with_gimple_body_p (cn1))
@@ -1245,12 +1245,12 @@ static inline bool
 cgraph_only_called_directly_or_aliased_p (struct cgraph_node *node)
 {
   gcc_assert (!node->global.inlined_to);
-  return (!node->symbol.force_output && !node->symbol.address_taken
-	  && !node->symbol.used_from_other_partition
-	  && !DECL_VIRTUAL_P (node->symbol.decl)
-	  && !DECL_STATIC_CONSTRUCTOR (node->symbol.decl)
-	  && !DECL_STATIC_DESTRUCTOR (node->symbol.decl)
-	  && !node->symbol.externally_visible);
+  return (!node->force_output && !node->address_taken
+	  && !node->used_from_other_partition
+	  && !DECL_VIRTUAL_P (node->decl)
+	  && !DECL_STATIC_CONSTRUCTOR (node->decl)
+	  && !DECL_STATIC_DESTRUCTOR (node->decl)
+	  && !node->externally_visible);
 }
 
 /* Return true when function NODE can be removed from callgraph
@@ -1259,14 +1259,14 @@ cgraph_only_called_directly_or_aliased_p (struct cgraph_node *node)
 static inline bool
 varpool_can_remove_if_no_refs (struct varpool_node *node)
 {
-  if (DECL_EXTERNAL (node->symbol.decl))
+  if (DECL_EXTERNAL (node->decl))
     return true;
-  return (!node->symbol.force_output && !node->symbol.used_from_other_partition
-  	  && ((DECL_COMDAT (node->symbol.decl)
-	       && !node->symbol.forced_by_abi
-	       && !symtab_used_from_object_file_p ((symtab_node) node))
-	      || !node->symbol.externally_visible
-	      || DECL_HAS_VALUE_EXPR_P (node->symbol.decl)));
+  return (!node->force_output && !node->used_from_other_partition
+  	  && ((DECL_COMDAT (node->decl)
+	       && !node->forced_by_abi
+	       && !symtab_used_from_object_file_p (node))
+	      || !node->externally_visible
+	      || DECL_HAS_VALUE_EXPR_P (node->decl)));
 }
 
 /* Return true when all references to VNODE must be visible in ipa_ref_list.
@@ -1277,10 +1277,10 @@ varpool_can_remove_if_no_refs (struct varpool_node *node)
 static inline bool
 varpool_all_refs_explicit_p (struct varpool_node *vnode)
 {
-  return (vnode->symbol.definition
-	  && !vnode->symbol.externally_visible
-	  && !vnode->symbol.used_from_other_partition
-	  && !vnode->symbol.force_output);
+  return (vnode->definition
+	  && !vnode->externally_visible
+	  && !vnode->used_from_other_partition
+	  && !vnode->force_output);
 }
 
 /* Constant pool accessor function.  */
@@ -1295,7 +1295,7 @@ static inline symtab_node
 symtab_alias_target (symtab_node n)
 {
   struct ipa_ref *ref;
-  ipa_ref_list_reference_iterate (&n->symbol.ref_list, 0, ref);
+  ipa_ref_list_reference_iterate (&n->ref_list, 0, ref);
   gcc_checking_assert (ref->use == IPA_REF_ALIAS);
   return ref->referred;
 }
@@ -1303,13 +1303,13 @@ symtab_alias_target (symtab_node n)
 static inline struct cgraph_node *
 cgraph_alias_target (struct cgraph_node *n)
 {
-  return dyn_cast <cgraph_node> (symtab_alias_target ((symtab_node) n));
+  return dyn_cast <cgraph_node> (symtab_alias_target (n));
 }
 
 static inline struct varpool_node *
 varpool_alias_target (struct varpool_node *n)
 {
-  return dyn_cast <varpool_node> (symtab_alias_target ((symtab_node) n));
+  return dyn_cast <varpool_node> (symtab_alias_target (n));
 }
 
 /* Given NODE, walk the alias chain to return the function NODE is alias of.
@@ -1322,7 +1322,7 @@ cgraph_function_or_thunk_node (struct cgraph_node *node,
 {
   struct cgraph_node *n;
 
-  n = dyn_cast <cgraph_node> (symtab_alias_ultimate_target ((symtab_node)node,
+  n = dyn_cast <cgraph_node> (symtab_alias_ultimate_target (node,
 							    availability));
   if (!n && availability)
     *availability = AVAIL_NOT_AVAILABLE;
@@ -1338,7 +1338,7 @@ varpool_variable_node (struct varpool_node *node,
 {
   struct varpool_node *n;
 
-  n = dyn_cast <varpool_node> (symtab_alias_ultimate_target ((symtab_node)node,
+  n = dyn_cast <varpool_node> (symtab_alias_ultimate_target (node,
 							     availability));
   if (!n && availability)
     *availability = AVAIL_NOT_AVAILABLE;
@@ -1351,9 +1351,9 @@ cgraph_edge_recursive_p (struct cgraph_edge *e)
 {
   struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
   if (e->caller->global.inlined_to)
-    return e->caller->global.inlined_to->symbol.decl == callee->symbol.decl;
+    return e->caller->global.inlined_to->decl == callee->decl;
   else
-    return e->caller->symbol.decl == callee->symbol.decl;
+    return e->caller->decl == callee->decl;
 }
 
 /* Return true if the TM_CLONE bit is set for a given FNDECL.  */
@@ -1372,7 +1372,7 @@ decl_is_tm_clone (const_tree fndecl)
 static inline void
 cgraph_mark_force_output_node (struct cgraph_node *node)
 {
-  node->symbol.force_output = 1;
+  node->force_output = 1;
   gcc_checking_assert (!node->global.inlined_to);
 }
 
@@ -1384,7 +1384,7 @@ symtab_real_symbol_p (symtab_node node)
 {
   struct cgraph_node *cnode;
 
-  if (DECL_ABSTRACT (node->symbol.decl))
+  if (DECL_ABSTRACT (node->decl))
     return false;
   if (!is_a <cgraph_node> (node))
     return true;
@@ -1399,10 +1399,10 @@ symtab_real_symbol_p (symtab_node node)
 static inline bool
 symtab_can_be_discarded (symtab_node node)
 {
-  return (DECL_EXTERNAL (node->symbol.decl)
-	  || (DECL_ONE_ONLY (node->symbol.decl)
-	      && node->symbol.resolution != LDPR_PREVAILING_DEF
-	      && node->symbol.resolution != LDPR_PREVAILING_DEF_IRONLY
-	      && node->symbol.resolution != LDPR_PREVAILING_DEF_IRONLY_EXP));
+  return (DECL_EXTERNAL (node->decl)
+	  || (DECL_ONE_ONLY (node->decl)
+	      && node->resolution != LDPR_PREVAILING_DEF
+	      && node->resolution != LDPR_PREVAILING_DEF_IRONLY
+	      && node->resolution != LDPR_PREVAILING_DEF_IRONLY_EXP));
 }
 #endif  /* GCC_CGRAPH_H  */
diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c
index b9c112f..34ce79a 100644
--- a/gcc/cgraphbuild.c
+++ b/gcc/cgraphbuild.c
@@ -76,16 +76,16 @@ record_reference (tree *tp, int *walk_subtrees, void *data)
 	  struct cgraph_node *node = cgraph_get_create_real_symbol_node (decl);
 	  if (!ctx->only_vars)
 	    cgraph_mark_address_taken_node (node);
-	  ipa_record_reference ((symtab_node)ctx->varpool_node,
-				(symtab_node)node,
+	  ipa_record_reference (ctx->varpool_node,
+				node,
 			        IPA_REF_ADDR, NULL);
 	}
 
       if (TREE_CODE (decl) == VAR_DECL)
 	{
 	  struct varpool_node *vnode = varpool_node_for_decl (decl);
-	  ipa_record_reference ((symtab_node)ctx->varpool_node,
-				(symtab_node)vnode,
+	  ipa_record_reference (ctx->varpool_node,
+				vnode,
 				IPA_REF_ADDR, NULL);
 	}
       *walk_subtrees = 0;
@@ -123,8 +123,8 @@ record_type_list (struct cgraph_node *node, tree list)
 	  if (TREE_CODE (type) == VAR_DECL)
 	    {
 	      struct varpool_node *vnode = varpool_node_for_decl (type);
-	      ipa_record_reference ((symtab_node)node,
-				    (symtab_node)vnode,
+	      ipa_record_reference (node,
+				    vnode,
 				    IPA_REF_ADDR, NULL);
 	    }
 	}
@@ -139,12 +139,12 @@ record_eh_tables (struct cgraph_node *node, struct function *fun)
 {
   eh_region i;
 
-  if (DECL_FUNCTION_PERSONALITY (node->symbol.decl))
+  if (DECL_FUNCTION_PERSONALITY (node->decl))
     {
       struct cgraph_node *per_node;
 
-      per_node = cgraph_get_create_real_symbol_node (DECL_FUNCTION_PERSONALITY (node->symbol.decl));
-      ipa_record_reference ((symtab_node)node, (symtab_node)per_node, IPA_REF_ADDR, NULL);
+      per_node = cgraph_get_create_real_symbol_node (DECL_FUNCTION_PERSONALITY (node->decl));
+      ipa_record_reference (node, per_node, IPA_REF_ADDR, NULL);
       cgraph_mark_address_taken_node (per_node);
     }
 
@@ -226,7 +226,7 @@ mark_address (gimple stmt, tree addr, void *data)
       struct cgraph_node *node = cgraph_get_create_real_symbol_node (addr);
       cgraph_mark_address_taken_node (node);
       ipa_record_reference ((symtab_node)data,
-			    (symtab_node)node,
+			    node,
 			    IPA_REF_ADDR, stmt);
     }
   else if (addr && TREE_CODE (addr) == VAR_DECL
@@ -235,7 +235,7 @@ mark_address (gimple stmt, tree addr, void *data)
       struct varpool_node *vnode = varpool_node_for_decl (addr);
 
       ipa_record_reference ((symtab_node)data,
-			    (symtab_node)vnode,
+			    vnode,
 			    IPA_REF_ADDR, stmt);
     }
 
@@ -255,7 +255,7 @@ mark_load (gimple stmt, tree t, void *data)
       struct cgraph_node *node = cgraph_get_create_real_symbol_node (t);
       cgraph_mark_address_taken_node (node);
       ipa_record_reference ((symtab_node)data,
-			    (symtab_node)node,
+			    node,
 			    IPA_REF_ADDR, stmt);
     }
   else if (t && TREE_CODE (t) == VAR_DECL
@@ -264,7 +264,7 @@ mark_load (gimple stmt, tree t, void *data)
       struct varpool_node *vnode = varpool_node_for_decl (t);
 
       ipa_record_reference ((symtab_node)data,
-			    (symtab_node)vnode,
+			    vnode,
 			    IPA_REF_LOAD, stmt);
     }
   return false;
@@ -282,7 +282,7 @@ mark_store (gimple stmt, tree t, void *data)
       struct varpool_node *vnode = varpool_node_for_decl (t);
 
       ipa_record_reference ((symtab_node)data,
-			    (symtab_node)vnode,
+			    vnode,
 			    IPA_REF_STORE, stmt);
      }
   return false;
@@ -339,21 +339,21 @@ build_cgraph_edges (void)
 	      && gimple_omp_parallel_child_fn (stmt))
 	    {
 	      tree fn = gimple_omp_parallel_child_fn (stmt);
-	      ipa_record_reference ((symtab_node)node,
-				    (symtab_node)cgraph_get_create_real_symbol_node (fn),
+	      ipa_record_reference (node,
+				    cgraph_get_create_real_symbol_node (fn),
 				    IPA_REF_ADDR, stmt);
 	    }
 	  if (gimple_code (stmt) == GIMPLE_OMP_TASK)
 	    {
 	      tree fn = gimple_omp_task_child_fn (stmt);
 	      if (fn)
-		ipa_record_reference ((symtab_node)node,
-				      (symtab_node) cgraph_get_create_real_symbol_node (fn),
+		ipa_record_reference (node,
+				      cgraph_get_create_real_symbol_node (fn),
 				      IPA_REF_ADDR, stmt);
 	      fn = gimple_omp_task_copy_fn (stmt);
 	      if (fn)
-		ipa_record_reference ((symtab_node)node,
-				      (symtab_node)cgraph_get_create_real_symbol_node (fn),
+		ipa_record_reference (node,
+				      cgraph_get_create_real_symbol_node (fn),
 				      IPA_REF_ADDR, stmt);
 	    }
 	}
@@ -439,7 +439,7 @@ rebuild_cgraph_edges (void)
   gimple_stmt_iterator gsi;
 
   cgraph_node_remove_callees (node);
-  ipa_remove_all_references (&node->symbol.ref_list);
+  ipa_remove_all_references (&node->ref_list);
 
   node->count = ENTRY_BLOCK_PTR->count;
 
@@ -487,7 +487,7 @@ cgraph_rebuild_references (void)
   int i;
 
   /* Keep speculative references for further cgraph edge expansion.  */
-  for (i = 0; ipa_ref_list_reference_iterate (&node->symbol.ref_list, i, ref);)
+  for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref);)
     if (!ref->speculative)
       ipa_remove_reference (ref);
     else
@@ -549,7 +549,7 @@ remove_cgraph_callee_edges (void)
 {
   struct cgraph_node *node = cgraph_get_node (current_function_decl);
   cgraph_node_remove_callees (node);
-  ipa_remove_all_references (&node->symbol.ref_list);
+  ipa_remove_all_references (&node->ref_list);
   return 0;
 }
 
diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c
index 54b97b9..5599f9e 100644
--- a/gcc/cgraphclones.c
+++ b/gcc/cgraphclones.c
@@ -187,19 +187,19 @@ cgraph_clone_node (struct cgraph_node *n, tree decl, gcov_type count, int freq,
   gcov_type count_scale;
   unsigned i;
 
-  new_node->symbol.decl = decl;
-  symtab_register_node ((symtab_node)new_node);
+  new_node->decl = decl;
+  symtab_register_node (new_node);
   new_node->origin = n->origin;
-  new_node->symbol.lto_file_data = n->symbol.lto_file_data;
+  new_node->lto_file_data = n->lto_file_data;
   if (new_node->origin)
     {
       new_node->next_nested = new_node->origin->nested;
       new_node->origin->nested = new_node;
     }
-  new_node->symbol.analyzed = n->symbol.analyzed;
-  new_node->symbol.definition = n->symbol.definition;
+  new_node->analyzed = n->analyzed;
+  new_node->definition = n->definition;
   new_node->local = n->local;
-  new_node->symbol.externally_visible = false;
+  new_node->externally_visible = false;
   new_node->local.local = true;
   new_node->global = n->global;
   new_node->global.inlined_to = new_inlined_to;
@@ -239,7 +239,7 @@ cgraph_clone_node (struct cgraph_node *n, tree decl, gcov_type count, int freq,
   for (e = n->indirect_calls; e; e = e->next_callee)
     cgraph_clone_edge (e, new_node, e->call_stmt, e->lto_stmt_uid,
 		       count_scale, freq, update_original);
-  ipa_clone_references ((symtab_node)new_node, &n->symbol.ref_list);
+  ipa_clone_references (new_node, &n->ref_list);
 
   new_node->next_sibling_clone = n->clones;
   if (n->clones)
@@ -290,7 +290,7 @@ cgraph_create_virtual_clone (struct cgraph_node *old_node,
 			     bitmap args_to_skip,
 			     const char * suffix)
 {
-  tree old_decl = old_node->symbol.decl;
+  tree old_decl = old_node->decl;
   struct cgraph_node *new_node = NULL;
   tree new_decl;
   size_t len, i;
@@ -336,16 +336,16 @@ cgraph_create_virtual_clone (struct cgraph_node *old_node,
      that is not weak also.
      ??? We cannot use COMDAT linkage because there is no
      ABI support for this.  */
-  DECL_EXTERNAL (new_node->symbol.decl) = 0;
+  DECL_EXTERNAL (new_node->decl) = 0;
   if (DECL_ONE_ONLY (old_decl))
-    DECL_SECTION_NAME (new_node->symbol.decl) = NULL;
-  DECL_COMDAT_GROUP (new_node->symbol.decl) = 0;
-  TREE_PUBLIC (new_node->symbol.decl) = 0;
-  DECL_COMDAT (new_node->symbol.decl) = 0;
-  DECL_WEAK (new_node->symbol.decl) = 0;
-  DECL_VIRTUAL_P (new_node->symbol.decl) = 0;
-  DECL_STATIC_CONSTRUCTOR (new_node->symbol.decl) = 0;
-  DECL_STATIC_DESTRUCTOR (new_node->symbol.decl) = 0;
+    DECL_SECTION_NAME (new_node->decl) = NULL;
+  DECL_COMDAT_GROUP (new_node->decl) = 0;
+  TREE_PUBLIC (new_node->decl) = 0;
+  DECL_COMDAT (new_node->decl) = 0;
+  DECL_WEAK (new_node->decl) = 0;
+  DECL_VIRTUAL_P (new_node->decl) = 0;
+  DECL_STATIC_CONSTRUCTOR (new_node->decl) = 0;
+  DECL_STATIC_DESTRUCTOR (new_node->decl) = 0;
   new_node->clone.tree_map = tree_map;
   new_node->clone.args_to_skip = args_to_skip;
 
@@ -355,9 +355,9 @@ cgraph_create_virtual_clone (struct cgraph_node *old_node,
        && !DECL_WEAK (old_decl)
        && !DECL_COMDAT (old_decl))
       || in_lto_p)
-    new_node->symbol.unique_name = true;
+    new_node->unique_name = true;
   FOR_EACH_VEC_SAFE_ELT (tree_map, i, map)
-    ipa_maybe_record_reference ((symtab_node) new_node, map->new_tree,
+    ipa_maybe_record_reference (new_node, map->new_tree,
 				IPA_REF_ADDR, NULL);
   if (!args_to_skip)
     new_node->clone.combined_args_to_skip = old_node->clone.combined_args_to_skip;
@@ -369,7 +369,7 @@ cgraph_create_virtual_clone (struct cgraph_node *old_node,
       struct cgraph_node *orig_node;
       for (orig_node = old_node; orig_node->clone_of; orig_node = orig_node->clone_of)
         ;
-      for (arg = DECL_ARGUMENTS (orig_node->symbol.decl);
+      for (arg = DECL_ARGUMENTS (orig_node->decl);
 	   arg; arg = DECL_CHAIN (arg), oldi++)
 	{
 	  if (bitmap_bit_p (old_node->clone.combined_args_to_skip, oldi))
@@ -385,7 +385,7 @@ cgraph_create_virtual_clone (struct cgraph_node *old_node,
     }
   else
     new_node->clone.combined_args_to_skip = args_to_skip;
-  new_node->symbol.externally_visible = 0;
+  new_node->externally_visible = 0;
   new_node->local.local = 1;
   new_node->lowered = true;
 
@@ -404,7 +404,7 @@ cgraph_find_replacement_node (struct cgraph_node *node)
 
   for (next_inline_clone = node->clones;
        next_inline_clone
-       && next_inline_clone->symbol.decl != node->symbol.decl;
+       && next_inline_clone->decl != node->decl;
        next_inline_clone = next_inline_clone->next_sibling_clone)
     ;
 
@@ -631,8 +631,8 @@ update_call_expr (struct cgraph_node *new_version)
   /* Update the call expr on the edges to call the new version.  */
   for (e = new_version->callers; e; e = e->next_caller)
     {
-      struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->symbol.decl);
-      gimple_call_set_fndecl (e->call_stmt, new_version->symbol.decl);
+      struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
+      gimple_call_set_fndecl (e->call_stmt, new_version->decl);
       maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
     }
 }
@@ -663,11 +663,11 @@ cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
 
    new_version = cgraph_create_node (new_decl);
 
-   new_version->symbol.analyzed = old_version->symbol.analyzed;
-   new_version->symbol.definition = old_version->symbol.definition;
+   new_version->analyzed = old_version->analyzed;
+   new_version->definition = old_version->definition;
    new_version->local = old_version->local;
-   new_version->symbol.externally_visible = false;
-   new_version->local.local = new_version->symbol.definition;
+   new_version->externally_visible = false;
+   new_version->local.local = new_version->definition;
    new_version->global = old_version->global;
    new_version->rtl = old_version->rtl;
    new_version->count = old_version->count;
@@ -728,7 +728,7 @@ cgraph_function_versioning (struct cgraph_node *old_version_node,
 			    basic_block new_entry_block,
 			    const char *clone_name)
 {
-  tree old_decl = old_version_node->symbol.decl;
+  tree old_decl = old_version_node->decl;
   struct cgraph_node *new_version_node = NULL;
   tree new_decl;
 
@@ -768,9 +768,9 @@ cgraph_function_versioning (struct cgraph_node *old_version_node,
      that is not weak also.
      ??? We cannot use COMDAT linkage because there is no
      ABI support for this.  */
-  symtab_make_decl_local (new_version_node->symbol.decl);
-  DECL_VIRTUAL_P (new_version_node->symbol.decl) = 0;
-  new_version_node->symbol.externally_visible = 0;
+  symtab_make_decl_local (new_version_node->decl);
+  DECL_VIRTUAL_P (new_version_node->decl) = 0;
+  new_version_node->externally_visible = 0;
   new_version_node->local.local = 1;
   new_version_node->lowered = true;
   /* Clones of global symbols or symbols with unique names are unique.  */
@@ -779,7 +779,7 @@ cgraph_function_versioning (struct cgraph_node *old_version_node,
        && !DECL_WEAK (old_decl)
        && !DECL_COMDAT (old_decl))
       || in_lto_p)
-    new_version_node->symbol.unique_name = true;
+    new_version_node->unique_name = true;
 
   /* Update the call_expr on the edges to call the new version node. */
   update_call_expr (new_version_node);
@@ -794,18 +794,18 @@ static void
 cgraph_materialize_clone (struct cgraph_node *node)
 {
   bitmap_obstack_initialize (NULL);
-  node->former_clone_of = node->clone_of->symbol.decl;
+  node->former_clone_of = node->clone_of->decl;
   if (node->clone_of->former_clone_of)
     node->former_clone_of = node->clone_of->former_clone_of;
   /* Copy the OLD_VERSION_NODE function tree to the new version.  */
-  tree_function_versioning (node->clone_of->symbol.decl, node->symbol.decl,
+  tree_function_versioning (node->clone_of->decl, node->decl,
   			    node->clone.tree_map, true,
 			    node->clone.args_to_skip, false,
 			    NULL, NULL);
   if (cgraph_dump_file)
     {
-      dump_function_to_file (node->clone_of->symbol.decl, cgraph_dump_file, dump_flags);
-      dump_function_to_file (node->symbol.decl, cgraph_dump_file, dump_flags);
+      dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
+      dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
     }
 
   /* Function is no longer clone.  */
@@ -817,11 +817,11 @@ cgraph_materialize_clone (struct cgraph_node *node)
     node->clone_of->clones = node->next_sibling_clone;
   node->next_sibling_clone = NULL;
   node->prev_sibling_clone = NULL;
-  if (!node->clone_of->symbol.analyzed && !node->clone_of->clones)
+  if (!node->clone_of->analyzed && !node->clone_of->clones)
     {
       cgraph_release_function_body (node->clone_of);
       cgraph_node_remove_callees (node->clone_of);
-      ipa_remove_all_references (&node->clone_of->symbol.ref_list);
+      ipa_remove_all_references (&node->clone_of->ref_list);
     }
   node->clone_of = NULL;
   bitmap_obstack_release (NULL);
@@ -854,12 +854,12 @@ cgraph_materialize_all_clones (void)
       stabilized = true;
       FOR_EACH_FUNCTION (node)
         {
-	  if (node->clone_of && node->symbol.decl != node->clone_of->symbol.decl
-	      && !gimple_has_body_p (node->symbol.decl))
+	  if (node->clone_of && node->decl != node->clone_of->decl
+	      && !gimple_has_body_p (node->decl))
 	    {
 	      if (!node->clone_of->clone_of)
 		cgraph_get_body (node->clone_of);
-	      if (gimple_has_body_p (node->clone_of->symbol.decl))
+	      if (gimple_has_body_p (node->clone_of->decl))
 	        {
 		  if (cgraph_dump_file)
 		    {
@@ -903,13 +903,13 @@ cgraph_materialize_all_clones (void)
 	}
     }
   FOR_EACH_FUNCTION (node)
-    if (!node->symbol.analyzed && node->callees)
+    if (!node->analyzed && node->callees)
       {
         cgraph_node_remove_callees (node);
-	ipa_remove_all_references (&node->symbol.ref_list);
+	ipa_remove_all_references (&node->ref_list);
       }
     else
-      ipa_clear_stmts_in_references ((symtab_node)node);
+      ipa_clear_stmts_in_references (node);
   if (cgraph_dump_file)
     fprintf (cgraph_dump_file, "Materialization Call site updates done.\n");
 #ifdef ENABLE_CHECKING
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 08e0ff2..5a8909f 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -225,25 +225,25 @@ static GTY (()) tree vtable_entry_type;
 bool
 decide_is_symbol_needed (symtab_node node)
 {
-  tree decl = node->symbol.decl;
+  tree decl = node->decl;
 
   /* Double check that no one output the function into assembly file
      early.  */
   gcc_checking_assert (!DECL_ASSEMBLER_NAME_SET_P (decl)
 	               || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)));
 
-  if (!node->symbol.definition)
+  if (!node->definition)
     return false;
 
   if (DECL_EXTERNAL (decl))
     return false;
 
   /* If the user told us it is used, then it must be so.  */
-  if (node->symbol.force_output)
+  if (node->force_output)
     return true;
 
   /* ABI forced symbols are needed when they are external.  */
-  if (node->symbol.forced_by_abi && TREE_PUBLIC (decl))
+  if (node->forced_by_abi && TREE_PUBLIC (decl))
     return true;
 
  /* Keep constructors, destructors and virtual functions.  */
@@ -269,10 +269,10 @@ static symtab_node first = (symtab_node)(void *)1;
 static void
 enqueue_node (symtab_node node)
 {
-  if (node->symbol.aux)
+  if (node->aux)
     return;
   gcc_checking_assert (first);
-  node->symbol.aux = first;
+  node->aux = first;
   first = node;
 }
 
@@ -296,7 +296,7 @@ cgraph_process_new_functions (void)
   for (csi = csi_start (cgraph_new_nodes); !csi_end_p (csi); csi_next (&csi))
     {
       node = csi_node (csi);
-      fndecl = node->symbol.decl;
+      fndecl = node->decl;
       switch (cgraph_state)
 	{
 	case CGRAPH_STATE_CONSTRUCTION:
@@ -306,7 +306,7 @@ cgraph_process_new_functions (void)
 	  cgraph_finalize_function (fndecl, false);
 	  output = true;
           cgraph_call_function_insertion_hooks (node);
-	  enqueue_node ((symtab_node) node);
+	  enqueue_node (node);
 	  break;
 
 	case CGRAPH_STATE_IPA:
@@ -316,7 +316,7 @@ cgraph_process_new_functions (void)
 	     cgraph but not on this function.  */
 
 	  gimple_register_cfg_hooks ();
-	  if (!node->symbol.analyzed)
+	  if (!node->analyzed)
 	    analyze_function (node);
 	  push_cfun (DECL_STRUCT_FUNCTION (fndecl));
 	  if (cgraph_state == CGRAPH_STATE_IPA_SSA
@@ -372,14 +372,14 @@ cgraph_reset_node (struct cgraph_node *node)
   memset (&node->local, 0, sizeof (node->local));
   memset (&node->global, 0, sizeof (node->global));
   memset (&node->rtl, 0, sizeof (node->rtl));
-  node->symbol.analyzed = false;
-  node->symbol.definition = false;
-  node->symbol.alias = false;
-  node->symbol.weakref = false;
-  node->symbol.cpp_implicit_alias = false;
+  node->analyzed = false;
+  node->definition = false;
+  node->alias = false;
+  node->weakref = false;
+  node->cpp_implicit_alias = false;
 
   cgraph_node_remove_callees (node);
-  ipa_remove_all_references (&node->symbol.ref_list);
+  ipa_remove_all_references (&node->ref_list);
 }
 
 /* Return true when there are references to NODE.  */
@@ -390,7 +390,7 @@ referred_to_p (symtab_node node)
   struct ipa_ref *ref;
 
   /* See if there are any references at all.  */
-  if (ipa_ref_list_referring_iterate (&node->symbol.ref_list, 0, ref))
+  if (ipa_ref_list_referring_iterate (&node->ref_list, 0, ref))
     return true;
   /* For functions check also calls.  */
   cgraph_node *cn = dyn_cast <cgraph_node> (node);
@@ -409,7 +409,7 @@ cgraph_finalize_function (tree decl, bool no_collect)
 {
   struct cgraph_node *node = cgraph_get_create_node (decl);
 
-  if (node->symbol.definition)
+  if (node->definition)
     {
       /* Nested functions should only be defined once.  */
       gcc_assert (!DECL_CONTEXT (decl)
@@ -419,7 +419,7 @@ cgraph_finalize_function (tree decl, bool no_collect)
     }
 
   notice_global_symbol (decl);
-  node->symbol.definition = true;
+  node->definition = true;
   node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
 
   /* With -fkeep-inline-functions we are keeping all inline functions except
@@ -428,7 +428,7 @@ cgraph_finalize_function (tree decl, bool no_collect)
       && DECL_DECLARED_INLINE_P (decl)
       && !DECL_EXTERNAL (decl)
       && !DECL_DISREGARD_INLINE_LIMITS (decl))
-    node->symbol.force_output = 1;
+    node->force_output = 1;
 
   /* When not optimizing, also output the static functions. (see
      PR24561), but don't do so for always_inline functions, functions
@@ -436,13 +436,13 @@ cgraph_finalize_function (tree decl, bool no_collect)
      in the original implementation and it is unclear whether we want
      to change the behavior here.  */
   if ((!optimize
-       && !node->symbol.cpp_implicit_alias
+       && !node->cpp_implicit_alias
        && !DECL_DISREGARD_INLINE_LIMITS (decl)
        && !DECL_DECLARED_INLINE_P (decl)
        && !(DECL_CONTEXT (decl)
 	    && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL))
       && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
-    node->symbol.force_output = 1;
+    node->force_output = 1;
 
   /* If we've not yet emitted decl, tell the debug info about it.  */
   if (!TREE_ASM_WRITTEN (decl))
@@ -456,9 +456,9 @@ cgraph_finalize_function (tree decl, bool no_collect)
     ggc_collect ();
 
   if (cgraph_state == CGRAPH_STATE_CONSTRUCTION
-      && (decide_is_symbol_needed ((symtab_node) node)
-	  || referred_to_p ((symtab_node)node)))
-    enqueue_node ((symtab_node)node);
+      && (decide_is_symbol_needed (node)
+	  || referred_to_p (node)))
+    enqueue_node (node);
 }
 
 /* Add the function FNDECL to the call graph.
@@ -500,8 +500,8 @@ cgraph_add_new_function (tree fndecl, bool lowered)
 	   analyzing and compilation.  */
 	node = cgraph_get_create_node (fndecl);
 	node->local.local = false;
-	node->symbol.definition = true;
-	node->symbol.force_output = true;
+	node->definition = true;
+	node->force_output = true;
 	if (!lowered && cgraph_state == CGRAPH_STATE_EXPANSION)
 	  {
 	    push_cfun (DECL_STRUCT_FUNCTION (fndecl));
@@ -527,7 +527,7 @@ cgraph_add_new_function (tree fndecl, bool lowered)
 	node = cgraph_create_node (fndecl);
 	if (lowered)
 	  node->lowered = true;
-	node->symbol.definition = true;
+	node->definition = true;
 	analyze_function (node);
 	push_cfun (DECL_STRUCT_FUNCTION (fndecl));
 	gimple_register_cfg_hooks ();
@@ -588,13 +588,13 @@ output_asm_statements (void)
 static void
 analyze_function (struct cgraph_node *node)
 {
-  tree decl = node->symbol.decl;
+  tree decl = node->decl;
   location_t saved_loc = input_location;
   input_location = DECL_SOURCE_LOCATION (decl);
 
-  if (node->symbol.alias)
+  if (node->alias)
     symtab_resolve_alias
-       ((symtab_node) node, (symtab_node) cgraph_get_node (node->symbol.alias_target));
+       (node, cgraph_get_node (node->alias_target));
   else if (node->thunk.thunk_p)
     {
       cgraph_create_edge (node, cgraph_get_node (node->thunk.alias),
@@ -620,7 +620,7 @@ analyze_function (struct cgraph_node *node)
     {
       push_cfun (DECL_STRUCT_FUNCTION (decl));
 
-      assign_assembler_name_if_neeeded (node->symbol.decl);
+      assign_assembler_name_if_neeeded (node->decl);
 
       /* Make sure to gimplify bodies only once.  During analyzing a
 	 function we lower it, which will require gimplified nested
@@ -634,7 +634,7 @@ analyze_function (struct cgraph_node *node)
       if (!node->lowered)
 	{
 	  if (node->nested)
-	    lower_nested_functions (node->symbol.decl);
+	    lower_nested_functions (node->decl);
 	  gcc_assert (!node->nested);
 
 	  gimple_register_cfg_hooks ();
@@ -649,7 +649,7 @@ analyze_function (struct cgraph_node *node)
 
       pop_cfun ();
     }
-  node->symbol.analyzed = true;
+  node->analyzed = true;
 
   input_location = saved_loc;
 }
@@ -665,12 +665,12 @@ cgraph_process_same_body_aliases (void)
 {
   symtab_node node;
   FOR_EACH_SYMBOL (node)
-    if (node->symbol.cpp_implicit_alias && !node->symbol.analyzed)
+    if (node->cpp_implicit_alias && !node->analyzed)
       symtab_resolve_alias
         (node,
-	 TREE_CODE (node->symbol.alias_target) == VAR_DECL
-	 ? (symtab_node)varpool_node_for_decl (node->symbol.alias_target)
-	 : (symtab_node)cgraph_get_create_node (node->symbol.alias_target));
+	 TREE_CODE (node->alias_target) == VAR_DECL
+	 ? (symtab_node)varpool_node_for_decl (node->alias_target)
+	 : (symtab_node)cgraph_get_create_node (node->alias_target));
   cpp_implicit_aliases_done = true;
 }
 
@@ -726,20 +726,20 @@ process_function_and_variable_attributes (struct cgraph_node *first,
   for (node = cgraph_first_function (); node != first;
        node = cgraph_next_function (node))
     {
-      tree decl = node->symbol.decl;
+      tree decl = node->decl;
       if (DECL_PRESERVE_P (decl))
 	cgraph_mark_force_output_node (node);
       else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
 	{
-	  if (! TREE_PUBLIC (node->symbol.decl))
-	    warning_at (DECL_SOURCE_LOCATION (node->symbol.decl), OPT_Wattributes,
+	  if (! TREE_PUBLIC (node->decl))
+	    warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
 			"%<externally_visible%>"
 			" attribute have effect only on public objects");
 	}
       if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
-	  && (node->symbol.definition && !node->symbol.alias))
+	  && (node->definition && !node->alias))
 	{
-	  warning_at (DECL_SOURCE_LOCATION (node->symbol.decl), OPT_Wattributes,
+	  warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
 		      "%<weakref%> attribute ignored"
 		      " because function is defined");
 	  DECL_WEAK (decl) = 0;
@@ -759,24 +759,24 @@ process_function_and_variable_attributes (struct cgraph_node *first,
   for (vnode = varpool_first_variable (); vnode != first_var;
        vnode = varpool_next_variable (vnode))
     {
-      tree decl = vnode->symbol.decl;
+      tree decl = vnode->decl;
       if (DECL_EXTERNAL (decl)
 	  && DECL_INITIAL (decl))
 	varpool_finalize_decl (decl);
       if (DECL_PRESERVE_P (decl))
-	vnode->symbol.force_output = true;
+	vnode->force_output = true;
       else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
 	{
-	  if (! TREE_PUBLIC (vnode->symbol.decl))
-	    warning_at (DECL_SOURCE_LOCATION (vnode->symbol.decl), OPT_Wattributes,
+	  if (! TREE_PUBLIC (vnode->decl))
+	    warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
 			"%<externally_visible%>"
 			" attribute have effect only on public objects");
 	}
       if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
-	  && vnode->symbol.definition
+	  && vnode->definition
 	  && DECL_INITIAL (decl))
 	{
-	  warning_at (DECL_SOURCE_LOCATION (vnode->symbol.decl), OPT_Wattributes,
+	  warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
 		      "%<weakref%> attribute ignored"
 		      " because variable is initialized");
 	  DECL_WEAK (decl) = 0;
@@ -798,21 +798,21 @@ varpool_finalize_decl (tree decl)
 
   gcc_assert (TREE_STATIC (decl) || DECL_EXTERNAL (decl));
 
-  if (node->symbol.definition)
+  if (node->definition)
     return;
   notice_global_symbol (decl);
-  node->symbol.definition = true;
+  node->definition = true;
   if (TREE_THIS_VOLATILE (decl) || DECL_PRESERVE_P (decl)
       /* Traditionally we do not eliminate static variables when not
 	 optimizing and when not doing toplevel reoder.  */
-      || (!flag_toplevel_reorder && !DECL_COMDAT (node->symbol.decl)
-	  && !DECL_ARTIFICIAL (node->symbol.decl)))
-    node->symbol.force_output = true;
+      || (!flag_toplevel_reorder && !DECL_COMDAT (node->decl)
+	  && !DECL_ARTIFICIAL (node->decl)))
+    node->force_output = true;
 
   if (cgraph_state == CGRAPH_STATE_CONSTRUCTION
-      && (decide_is_symbol_needed ((symtab_node) node)
-	  || referred_to_p ((symtab_node)node)))
-    enqueue_node ((symtab_node)node);
+      && (decide_is_symbol_needed (node)
+	  || referred_to_p (node)))
+    enqueue_node (node);
   if (cgraph_state >= CGRAPH_STATE_IPA_SSA)
     varpool_analyze_node (node);
   /* Some frontends produce various interface variables after compilation
@@ -849,14 +849,14 @@ walk_polymorphic_call_targets (pointer_set_t *reachable_call_targets,
 	  /* Do not bother to mark virtual methods in anonymous namespace;
 	     either we will find use of virtual table defining it, or it is
 	     unused.  */
-	  if (targets[i]->symbol.definition
+	  if (targets[i]->definition
 	      && TREE_CODE
-		  (TREE_TYPE (targets[i]->symbol.decl))
+		  (TREE_TYPE (targets[i]->decl))
 		   == METHOD_TYPE
 	      && !type_in_anonymous_namespace_p
 		   (method_class_type
-		     (TREE_TYPE (targets[i]->symbol.decl))))
-	  enqueue_node ((symtab_node) targets[i]);
+		     (TREE_TYPE (targets[i]->decl))))
+	  enqueue_node (targets[i]);
 	}
     }
 
@@ -918,7 +918,7 @@ analyze_functions (void)
      C++ FE is confused about the COMDAT groups being right.  */
   if (cpp_implicit_aliases_done)
     FOR_EACH_SYMBOL (node)
-      if (node->symbol.cpp_implicit_alias)
+      if (node->cpp_implicit_alias)
 	  fixup_same_cpp_alias_visibility (node, symtab_alias_target (node));
   if (optimize && flag_devirtualize)
     build_type_inheritance_graph ();
@@ -933,8 +933,8 @@ analyze_functions (void)
 
       /* First identify the trivially needed symbols.  */
       for (node = symtab_nodes;
-	   node != (symtab_node)first_analyzed
-	   && node != (symtab_node)first_analyzed_var; node = node->symbol.next)
+	   node != first_analyzed
+	   && node != first_analyzed_var; node = node->next)
 	{
 	  if (decide_is_symbol_needed (node))
 	    {
@@ -947,8 +947,8 @@ analyze_functions (void)
 	      if (!changed && cgraph_dump_file)
 		fprintf (cgraph_dump_file, "\n");
 	    }
-	  if (node == (symtab_node)first_analyzed
-	      || node == (symtab_node)first_analyzed_var)
+	  if (node == first_analyzed
+	      || node == first_analyzed_var)
 	    break;
 	}
       cgraph_process_new_functions ();
@@ -964,18 +964,18 @@ analyze_functions (void)
 	{
 	  changed = true;
 	  node = first;
-	  first = (symtab_node)first->symbol.aux;
+	  first = (symtab_node)first->aux;
 	  cgraph_node *cnode = dyn_cast <cgraph_node> (node);
-	  if (cnode && cnode->symbol.definition)
+	  if (cnode && cnode->definition)
 	    {
 	      struct cgraph_edge *edge;
-	      tree decl = cnode->symbol.decl;
+	      tree decl = cnode->decl;
 
 	      /* ??? It is possible to create extern inline function
 	      and later using weak alias attribute to kill its body.
 	      See gcc.c-torture/compile/20011119-1.c  */
 	      if (!DECL_STRUCT_FUNCTION (decl)
-		  && !cnode->symbol.alias
+		  && !cnode->alias
 		  && !cnode->thunk.thunk_p
 		  && !cnode->dispatcher_function)
 		{
@@ -984,12 +984,12 @@ analyze_functions (void)
 		  continue;
 		}
 
-	      if (!cnode->symbol.analyzed)
+	      if (!cnode->analyzed)
 		analyze_function (cnode);
 
 	      for (edge = cnode->callees; edge; edge = edge->next_callee)
-		if (edge->callee->symbol.definition)
-		   enqueue_node ((symtab_node)edge->callee);
+		if (edge->callee->definition)
+		   enqueue_node (edge->callee);
 	      if (optimize && flag_devirtualize)
 		{
 		  struct cgraph_edge *next;
@@ -1017,20 +1017,20 @@ analyze_functions (void)
 	  else
 	    {
 	      varpool_node *vnode = dyn_cast <varpool_node> (node);
-	      if (vnode && vnode->symbol.definition && !vnode->symbol.analyzed)
+	      if (vnode && vnode->definition && !vnode->analyzed)
 		varpool_analyze_node (vnode);
 	    }
 
-	  if (node->symbol.same_comdat_group)
+	  if (node->same_comdat_group)
 	    {
 	      symtab_node next;
-	      for (next = node->symbol.same_comdat_group;
+	      for (next = node->same_comdat_group;
 		   next != node;
-		   next = next->symbol.same_comdat_group)
+		   next = next->same_comdat_group)
 		enqueue_node (next);
 	    }
-	  for (i = 0; ipa_ref_list_reference_iterate (&node->symbol.ref_list, i, ref); i++)
-	    if (ref->referred->symbol.definition)
+	  for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
+	    if (ref->referred->definition)
 	      enqueue_node (ref->referred);
           cgraph_process_new_functions ();
 	}
@@ -1049,11 +1049,11 @@ analyze_functions (void)
     fprintf (cgraph_dump_file, "\nRemoving unused symbols:");
 
   for (node = symtab_nodes;
-       node != (symtab_node)first_handled
-       && node != (symtab_node)first_handled_var; node = next)
+       node != first_handled
+       && node != first_handled_var; node = next)
     {
-      next = node->symbol.next;
-      if (!node->symbol.aux && !referred_to_p (node))
+      next = node->next;
+      if (!node->aux && !referred_to_p (node))
 	{
 	  if (cgraph_dump_file)
 	    fprintf (cgraph_dump_file, " %s", symtab_node_name (node));
@@ -1062,22 +1062,22 @@ analyze_functions (void)
 	}
       if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 	{
-	  tree decl = node->symbol.decl;
+	  tree decl = node->decl;
 
-	  if (cnode->symbol.definition && !gimple_has_body_p (decl)
-	      && !cnode->symbol.alias
+	  if (cnode->definition && !gimple_has_body_p (decl)
+	      && !cnode->alias
 	      && !cnode->thunk.thunk_p)
 	    cgraph_reset_node (cnode);
 
-	  gcc_assert (!cnode->symbol.definition || cnode->thunk.thunk_p
-		      || cnode->symbol.alias
+	  gcc_assert (!cnode->definition || cnode->thunk.thunk_p
+		      || cnode->alias
 		      || gimple_has_body_p (decl));
-	  gcc_assert (cnode->symbol.analyzed == cnode->symbol.definition);
+	  gcc_assert (cnode->analyzed == cnode->definition);
 	}
-      node->symbol.aux = NULL;
+      node->aux = NULL;
     }
-  for (;node; node = node->symbol.next)
-    node->symbol.aux = NULL;
+  for (;node; node = node->next)
+    node->aux = NULL;
   first_analyzed = cgraph_first_function ();
   first_analyzed_var = varpool_first_variable ();
   if (cgraph_dump_file)
@@ -1118,9 +1118,9 @@ handle_alias_pairs (void)
 	  symtab_node node = symtab_get_node (p->decl);
 	  if (node)
 	    {
-	      node->symbol.alias_target = p->target;
-	      node->symbol.weakref = true;
-	      node->symbol.alias = true;
+	      node->alias_target = p->target;
+	      node->weakref = true;
+	      node->alias = true;
 	    }
 	  alias_pairs->unordered_remove (i);
 	  continue;
@@ -1130,17 +1130,17 @@ handle_alias_pairs (void)
 	  error ("%q+D aliased to undefined symbol %qE", p->decl, p->target);
 	  symtab_node node = symtab_get_node (p->decl);
 	  if (node)
-	    node->symbol.alias = false;
+	    node->alias = false;
 	  alias_pairs->unordered_remove (i);
 	  continue;
 	}
 
-      if (DECL_EXTERNAL (target_node->symbol.decl)
+      if (DECL_EXTERNAL (target_node->decl)
 	  /* We use local aliases for C++ thunks to force the tailcall
 	     to bind locally.  This is a hack - to keep it working do
 	     the following (which is not strictly correct).  */
-	  && (! TREE_CODE (target_node->symbol.decl) == FUNCTION_DECL
-	      || ! DECL_VIRTUAL_P (target_node->symbol.decl))
+	  && (! TREE_CODE (target_node->decl) == FUNCTION_DECL
+	      || ! DECL_VIRTUAL_P (target_node->decl))
 	  && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
 	{
 	  error ("%q+D aliased to external symbol %qE",
@@ -1151,15 +1151,15 @@ handle_alias_pairs (void)
           && target_node && is_a <cgraph_node> (target_node))
 	{
 	  struct cgraph_node *src_node = cgraph_get_node (p->decl);
-	  if (src_node && src_node->symbol.definition)
+	  if (src_node && src_node->definition)
             cgraph_reset_node (src_node);
-	  cgraph_create_function_alias (p->decl, target_node->symbol.decl);
+	  cgraph_create_function_alias (p->decl, target_node->decl);
 	  alias_pairs->unordered_remove (i);
 	}
       else if (TREE_CODE (p->decl) == VAR_DECL
 	       && target_node && is_a <varpool_node> (target_node))
 	{
-	  varpool_create_variable_alias (p->decl, target_node->symbol.decl);
+	  varpool_create_variable_alias (p->decl, target_node->decl);
 	  alias_pairs->unordered_remove (i);
 	}
       else
@@ -1167,7 +1167,7 @@ handle_alias_pairs (void)
 	  error ("%q+D alias in between function and variable is not supported",
 		 p->decl);
 	  warning (0, "%q+D aliased declaration",
-		   target_node->symbol.decl);
+		   target_node->decl);
 	  alias_pairs->unordered_remove (i);
 	}
     }
@@ -1190,34 +1190,34 @@ mark_functions_to_output (void)
 
   FOR_EACH_FUNCTION (node)
     {
-      tree decl = node->symbol.decl;
+      tree decl = node->decl;
 
-      gcc_assert (!node->process || node->symbol.same_comdat_group);
+      gcc_assert (!node->process || node->same_comdat_group);
       if (node->process)
 	continue;
 
       /* We need to output all local functions that are used and not
 	 always inlined, as well as those that are reachable from
 	 outside the current compilation unit.  */
-      if (node->symbol.analyzed
+      if (node->analyzed
 	  && !node->thunk.thunk_p
-	  && !node->symbol.alias
+	  && !node->alias
 	  && !node->global.inlined_to
 	  && !TREE_ASM_WRITTEN (decl)
 	  && !DECL_EXTERNAL (decl))
 	{
 	  node->process = 1;
-	  if (node->symbol.same_comdat_group)
+	  if (node->same_comdat_group)
 	    {
 	      struct cgraph_node *next;
-	      for (next = cgraph (node->symbol.same_comdat_group);
+	      for (next = cgraph (node->same_comdat_group);
 		   next != node;
-		   next = cgraph (next->symbol.same_comdat_group))
-		if (!next->thunk.thunk_p && !next->symbol.alias)
+		   next = cgraph (next->same_comdat_group))
+		if (!next->thunk.thunk_p && !next->alias)
 		  next->process = 1;
 	    }
 	}
-      else if (node->symbol.same_comdat_group)
+      else if (node->same_comdat_group)
 	{
 #ifdef ENABLE_CHECKING
 	  check_same_comdat_groups = true;
@@ -1232,8 +1232,8 @@ mark_functions_to_output (void)
 	      /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
 		 are inside partition, we can end up not removing the body since we no longer
 		 have analyzed node pointing to it.  */
-	      && !node->symbol.in_other_partition
-	      && !node->symbol.alias
+	      && !node->in_other_partition
+	      && !node->alias
 	      && !node->clones
 	      && !DECL_EXTERNAL (decl))
 	    {
@@ -1243,7 +1243,7 @@ mark_functions_to_output (void)
 #endif
 	  gcc_assert (node->global.inlined_to
 		      || !gimple_has_body_p (decl)
-		      || node->symbol.in_other_partition
+		      || node->in_other_partition
 		      || node->clones
 		      || DECL_ARTIFICIAL (decl)
 		      || DECL_EXTERNAL (decl));
@@ -1254,16 +1254,16 @@ mark_functions_to_output (void)
 #ifdef ENABLE_CHECKING
   if (check_same_comdat_groups)
     FOR_EACH_FUNCTION (node)
-      if (node->symbol.same_comdat_group && !node->process)
+      if (node->same_comdat_group && !node->process)
 	{
-	  tree decl = node->symbol.decl;
+	  tree decl = node->decl;
 	  if (!node->global.inlined_to
 	      && gimple_has_body_p (decl)
 	      /* FIXME: in an ltrans unit when the offline copy is outside a
 		 partition but inline copies are inside a partition, we can
 		 end up not removing the body since we no longer have an
 		 analyzed node pointing to it.  */
-	      && !node->symbol.in_other_partition
+	      && !node->in_other_partition
 	      && !node->clones
 	      && !DECL_EXTERNAL (decl))
 	    {
@@ -1431,8 +1431,8 @@ expand_thunk (struct cgraph_node *node)
   HOST_WIDE_INT fixed_offset = node->thunk.fixed_offset;
   HOST_WIDE_INT virtual_value = node->thunk.virtual_value;
   tree virtual_offset = NULL;
-  tree alias = node->callees->callee->symbol.decl;
-  tree thunk_fndecl = node->symbol.decl;
+  tree alias = node->callees->callee->decl;
+  tree thunk_fndecl = node->decl;
   tree a = DECL_ARGUMENTS (thunk_fndecl);
 
   current_function_decl = thunk_fndecl;
@@ -1475,7 +1475,7 @@ expand_thunk (struct cgraph_node *node)
       set_cfun (NULL);
       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
       node->thunk.thunk_p = false;
-      node->symbol.analyzed = false;
+      node->analyzed = false;
     }
   else
     {
@@ -1647,20 +1647,20 @@ assemble_thunks_and_aliases (struct cgraph_node *node)
       }
     else
       e = e->next_caller;
-  for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list,
+  for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list,
 					     i, ref); i++)
     if (ref->use == IPA_REF_ALIAS)
       {
 	struct cgraph_node *alias = ipa_ref_referring_node (ref);
-        bool saved_written = TREE_ASM_WRITTEN (node->symbol.decl);
+        bool saved_written = TREE_ASM_WRITTEN (node->decl);
 
 	/* Force assemble_alias to really output the alias this time instead
 	   of buffering it in same alias pairs.  */
-	TREE_ASM_WRITTEN (node->symbol.decl) = 1;
-	do_assemble_alias (alias->symbol.decl,
-			   DECL_ASSEMBLER_NAME (node->symbol.decl));
+	TREE_ASM_WRITTEN (node->decl) = 1;
+	do_assemble_alias (alias->decl,
+			   DECL_ASSEMBLER_NAME (node->decl));
 	assemble_thunks_and_aliases (alias);
-	TREE_ASM_WRITTEN (node->symbol.decl) = saved_written;
+	TREE_ASM_WRITTEN (node->decl) = saved_written;
       }
 }
 
@@ -1669,7 +1669,7 @@ assemble_thunks_and_aliases (struct cgraph_node *node)
 static void
 expand_function (struct cgraph_node *node)
 {
-  tree decl = node->symbol.decl;
+  tree decl = node->decl;
   location_t saved_loc;
 
   /* We ought to not compile any inline clones.  */
@@ -1774,7 +1774,7 @@ expand_function (struct cgraph_node *node)
   /* Eliminate all call edges.  This is important so the GIMPLE_CALL no longer
      points to the dead function body.  */
   cgraph_node_remove_callees (node);
-  ipa_remove_all_references (&node->symbol.ref_list);
+  ipa_remove_all_references (&node->ref_list);
 }
 
 
@@ -1862,9 +1862,9 @@ output_in_order (void)
 
   FOR_EACH_DEFINED_FUNCTION (pf)
     {
-      if (pf->process && !pf->thunk.thunk_p && !pf->symbol.alias)
+      if (pf->process && !pf->thunk.thunk_p && !pf->alias)
 	{
-	  i = pf->symbol.order;
+	  i = pf->order;
 	  gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
 	  nodes[i].kind = ORDER_FUNCTION;
 	  nodes[i].u.f = pf;
@@ -1872,9 +1872,9 @@ output_in_order (void)
     }
 
   FOR_EACH_DEFINED_VARIABLE (pv)
-    if (!DECL_EXTERNAL (pv->symbol.decl))
+    if (!DECL_EXTERNAL (pv->decl))
       {
-	i = pv->symbol.order;
+	i = pv->order;
 	gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
 	nodes[i].kind = ORDER_VAR;
 	nodes[i].u.v = pv;
@@ -2007,9 +2007,9 @@ output_weakrefs (void)
 {
   symtab_node node;
   FOR_EACH_SYMBOL (node)
-    if (node->symbol.alias
-        && !TREE_ASM_WRITTEN (node->symbol.decl)
-	&& node->symbol.weakref)
+    if (node->alias
+        && !TREE_ASM_WRITTEN (node->decl)
+	&& node->weakref)
       {
 	tree target;
 
@@ -2018,18 +2018,18 @@ output_weakrefs (void)
 	   alias.
 	   When alias target is defined, we need to fetch it from symtab reference,
 	   otherwise it is pointed to by alias_target.  */
-	if (node->symbol.alias_target)
-	  target = (DECL_P (node->symbol.alias_target)
-		    ? DECL_ASSEMBLER_NAME (node->symbol.alias_target)
-		    : node->symbol.alias_target);
-	else if (node->symbol.analyzed)
-	  target = DECL_ASSEMBLER_NAME (symtab_alias_target (node)->symbol.decl);
+	if (node->alias_target)
+	  target = (DECL_P (node->alias_target)
+		    ? DECL_ASSEMBLER_NAME (node->alias_target)
+		    : node->alias_target);
+	else if (node->analyzed)
+	  target = DECL_ASSEMBLER_NAME (symtab_alias_target (node)->decl);
 	else
 	  {
 	    gcc_unreachable ();
-	    target = get_alias_symbol (node->symbol.decl);
+	    target = get_alias_symbol (node->decl);
 	  }
-        do_assemble_alias (node->symbol.decl, target);
+        do_assemble_alias (node->decl, target);
       }
 }
 
@@ -2130,14 +2130,14 @@ compile (void)
   symtab_node node;
 
   FOR_EACH_SYMBOL (node)
-    if (node->symbol.alias
-	&& lookup_attribute ("weakref", DECL_ATTRIBUTES (node->symbol.decl)))
+    if (node->alias
+	&& lookup_attribute ("weakref", DECL_ATTRIBUTES (node->decl)))
       {
 	IDENTIFIER_TRANSPARENT_ALIAS
-	   (DECL_ASSEMBLER_NAME (node->symbol.decl)) = 1;
-	TREE_CHAIN (DECL_ASSEMBLER_NAME (node->symbol.decl))
-	   = (node->symbol.alias_target ? node->symbol.alias_target
-	      : DECL_ASSEMBLER_NAME (symtab_alias_target (node)->symbol.decl));
+	   (DECL_ASSEMBLER_NAME (node->decl)) = 1;
+	TREE_CHAIN (DECL_ASSEMBLER_NAME (node->decl))
+	   = (node->alias_target ? node->alias_target
+	      : DECL_ASSEMBLER_NAME (symtab_alias_target (node)->decl));
       }
 #endif
 
@@ -2172,7 +2172,7 @@ compile (void)
 
       FOR_EACH_DEFINED_FUNCTION (node)
 	if (node->global.inlined_to
-	    || gimple_has_body_p (node->symbol.decl))
+	    || gimple_has_body_p (node->decl))
 	  {
 	    error_found = true;
 	    dump_cgraph_node (stderr, node);
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index e2fa71a..d8ae29e 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -29898,7 +29898,7 @@ ix86_get_function_versions_dispatcher (void *decl)
   while (default_version_info != NULL)
     {
       if (is_function_default_version
-	    (default_version_info->this_node->symbol.decl))
+	    (default_version_info->this_node->decl))
         break;
       default_version_info = default_version_info->next;
     }
@@ -29928,7 +29928,7 @@ ix86_get_function_versions_dispatcher (void *decl)
       struct cgraph_function_version_info *dispatcher_version_info = NULL;
 
       /* Right now, the dispatching is done via ifunc.  */
-      dispatch_decl = make_dispatcher_decl (default_node->symbol.decl);
+      dispatch_decl = make_dispatcher_decl (default_node->decl);
 
       dispatcher_node = cgraph_get_create_node (dispatch_decl);
       gcc_assert (dispatcher_node != NULL);
@@ -29936,7 +29936,7 @@ ix86_get_function_versions_dispatcher (void *decl)
       dispatcher_version_info
 	= insert_new_cgraph_node_version (dispatcher_node);
       dispatcher_version_info->next = default_version_info;
-      dispatcher_node->symbol.definition = 1;
+      dispatcher_node->definition = 1;
 
       /* Set the dispatcher for all the versions.  */
       it_v = default_version_info;
@@ -29949,7 +29949,7 @@ ix86_get_function_versions_dispatcher (void *decl)
   else
 #endif
     {
-      error_at (DECL_SOURCE_LOCATION (default_node->symbol.decl),
+      error_at (DECL_SOURCE_LOCATION (default_node->decl),
 		"multiversioning needs ifunc which is not supported "
 		"on this target");
     }
@@ -30088,13 +30088,13 @@ ix86_generate_version_dispatcher_body (void *node_p)
     return node_version_info->dispatcher_resolver;
 
   /* The first version in the chain corresponds to the default version.  */
-  default_ver_decl = node_version_info->next->this_node->symbol.decl;
+  default_ver_decl = node_version_info->next->this_node->decl;
 
   /* node is going to be an alias, so remove the finalized bit.  */
-  node->symbol.definition = false;
+  node->definition = false;
 
   resolver_decl = make_resolver_func (default_ver_decl,
-				      node->symbol.decl, &empty_bb);
+				      node->decl, &empty_bb);
 
   node_version_info->dispatcher_resolver = resolver_decl;
 
@@ -30111,10 +30111,10 @@ ix86_generate_version_dispatcher_body (void *node_p)
 	 not.  This happens for methods in derived classes that override
 	 virtual methods in base classes but are not explicitly marked as
 	 virtual.  */
-      if (DECL_VINDEX (versn->symbol.decl))
+      if (DECL_VINDEX (versn->decl))
 	sorry ("Virtual function multiversioning not supported");
 
-      fn_ver_vec.safe_push (versn->symbol.decl);
+      fn_ver_vec.safe_push (versn->decl);
     }
 
   dispatch_function_versions (resolver_decl, &fn_ver_vec, &empty_bb);
diff --git a/gcc/coverage.c b/gcc/coverage.c
index d662e8d..8c5d572 100644
--- a/gcc/coverage.c
+++ b/gcc/coverage.c
@@ -554,12 +554,12 @@ unsigned
 coverage_compute_profile_id (struct cgraph_node *n)
 {
   expanded_location xloc
-    = expand_location (DECL_SOURCE_LOCATION (n->symbol.decl));
+    = expand_location (DECL_SOURCE_LOCATION (n->decl));
   unsigned chksum = xloc.line;
 
   chksum = coverage_checksum_string (chksum, xloc.file);
   chksum = coverage_checksum_string
-    (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->symbol.decl)));
+    (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
   if (first_global_object_name)
     chksum = coverage_checksum_string
       (chksum, first_global_object_name);
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 3ed73b8..4746afe 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -6630,7 +6630,7 @@ mark_versions_used (tree fn)
   it_v = node_v->next;
   while (it_v != NULL)
     {
-      mark_used (it_v->this_node->symbol.decl);
+      mark_used (it_v->this_node->decl);
       it_v = it_v->next;
     }
 }
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index d5d2912..a074d78 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -1710,7 +1710,7 @@ maybe_make_one_only (tree decl)
           struct varpool_node *node = varpool_node_for_decl (decl);
 	  DECL_COMDAT (decl) = 1;
 	  /* Mark it needed so we don't forget to emit it.  */
-          node->symbol.forced_by_abi = true;
+          node->forced_by_abi = true;
 	  TREE_USED (decl) = 1;
 	}
     }
@@ -1808,7 +1808,7 @@ import_export_class (tree ctype)
 static bool
 var_finalized_p (tree var)
 {
-  return varpool_node_for_decl (var)->symbol.definition;
+  return varpool_node_for_decl (var)->definition;
 }
 
 /* DECL is a VAR_DECL or FUNCTION_DECL which, for whatever reason,
@@ -1825,14 +1825,14 @@ mark_needed (tree decl)
 	 functions can be marked reachable, just use the external
 	 definition.  */
       struct cgraph_node *node = cgraph_get_create_node (decl);
-      node->symbol.forced_by_abi = true;
+      node->forced_by_abi = true;
     }
   else if (TREE_CODE (decl) == VAR_DECL)
     {
       struct varpool_node *node = varpool_node_for_decl (decl);
       /* C++ frontend use mark_decl_references to force COMDAT variables
          to be output that might appear dead otherwise.  */
-      node->symbol.forced_by_abi = true;
+      node->forced_by_abi = true;
     }
 }
 
@@ -1942,7 +1942,7 @@ maybe_emit_vtables (tree ctype)
 	{
 	  current = varpool_node_for_decl (vtbl);
 	  if (last)
-	    symtab_add_to_same_comdat_group ((symtab_node) current, (symtab_node) last);
+	    symtab_add_to_same_comdat_group (current, last);
 	  last = current;
 	}
     }
@@ -3707,7 +3707,7 @@ collect_candidates_for_java_method_aliases (void)
 
   FOR_EACH_FUNCTION (node)
     {
-      tree fndecl = node->symbol.decl;
+      tree fndecl = node->decl;
 
       if (DECL_CLASS_SCOPE_P (fndecl)
 	  && TYPE_FOR_JAVA (DECL_CONTEXT (fndecl))
@@ -3740,7 +3740,7 @@ build_java_method_aliases (struct pointer_set_t *candidates)
 
   FOR_EACH_FUNCTION (node)
     {
-      tree fndecl = node->symbol.decl;
+      tree fndecl = node->decl;
 
       if (TREE_ASM_WRITTEN (fndecl)
 	  && pointer_set_contains (candidates, fndecl))
@@ -3921,7 +3921,7 @@ collect_all_refs (const char *source_file)
 static bool
 clear_decl_external (struct cgraph_node *node, void * /*data*/)
 {
-  DECL_EXTERNAL (node->symbol.decl) = 0;
+  DECL_EXTERNAL (node->decl) = 0;
   return false;
 }
 
@@ -4222,7 +4222,7 @@ cp_write_global_declarations (void)
 	      struct cgraph_node *node, *next;
 
 	      node = cgraph_get_node (decl);
-	      if (node->symbol.cpp_implicit_alias)
+	      if (node->cpp_implicit_alias)
 		node = cgraph_alias_target (node);
 
 	      cgraph_for_node_and_aliases (node, clear_decl_external,
@@ -4230,10 +4230,10 @@ cp_write_global_declarations (void)
 	      /* If we mark !DECL_EXTERNAL one of the symbols in some comdat
 		 group, we need to mark all symbols in the same comdat group
 		 that way.  */
-	      if (node->symbol.same_comdat_group)
-		for (next = cgraph (node->symbol.same_comdat_group);
+	      if (node->same_comdat_group)
+		for (next = cgraph (node->same_comdat_group);
 		     next != node;
-		     next = cgraph (next->symbol.same_comdat_group))
+		     next = cgraph (next->same_comdat_group))
 	          cgraph_for_node_and_aliases (next, clear_decl_external,
 					       NULL, true);
 	    }
@@ -4245,7 +4245,7 @@ cp_write_global_declarations (void)
 	  if (!DECL_EXTERNAL (decl)
 	      && decl_needed_p (decl)
 	      && !TREE_ASM_WRITTEN (decl)
-	      && !cgraph_get_node (decl)->symbol.definition)
+	      && !cgraph_get_node (decl)->definition)
 	    {
 	      /* We will output the function; no longer consider it in this
 		 loop.  */
diff --git a/gcc/cp/lambda.c b/gcc/cp/lambda.c
index a53e692..2b43e79 100644
--- a/gcc/cp/lambda.c
+++ b/gcc/cp/lambda.c
@@ -847,8 +847,8 @@ maybe_add_lambda_conv_op (tree type)
     {
       /* Put the thunk in the same comdat group as the call op.  */
       symtab_add_to_same_comdat_group
-	 ((symtab_node) cgraph_get_create_node (statfn),
-          (symtab_node) cgraph_get_create_node (callop));
+	 (cgraph_get_create_node (statfn),
+          cgraph_get_create_node (callop));
     }
   body = begin_function_body ();
   compound_stmt = begin_compound_stmt (0);
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index 4ac533e..1cd2031 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -386,8 +386,8 @@ use_thunk (tree thunk_fndecl, bool emit_p)
 				 this_adjusting, fixed_offset, virtual_value,
 				 virtual_offset, alias);
   if (DECL_ONE_ONLY (function))
-    symtab_add_to_same_comdat_group ((symtab_node) thunk_node,
-				     (symtab_node) funcn);
+    symtab_add_to_same_comdat_group (thunk_node,
+				     funcn);
 
   if (!this_adjusting
       || !targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
diff --git a/gcc/cp/optimize.c b/gcc/cp/optimize.c
index 1b524c3..c4ee848 100644
--- a/gcc/cp/optimize.c
+++ b/gcc/cp/optimize.c
@@ -339,7 +339,7 @@ maybe_clone_body (tree fn)
 	     virtual, it goes into the same comdat group as well.  */
 	  if (comdat_group)
 	    symtab_add_to_same_comdat_group
-	       ((symtab_node) cgraph_get_create_node (clone),
+	       (cgraph_get_create_node (clone),
 	        symtab_get_node (fns[0]));
 	}
       else if (alias)
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 63ec7fa..3ac0348 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -3983,8 +3983,8 @@ cp_fix_function_decl_p (tree decl)
 
       /* Don't fix same_body aliases.  Although they don't have their own
 	 CFG, they share it with what they alias to.  */
-      if (!node || !node->symbol.alias
-	  || !vec_safe_length (node->symbol.ref_list.references))
+      if (!node || !node->alias
+	  || !vec_safe_length (node->ref_list.references))
 	return true;
     }
 
diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index 1cc5d52..db50f09 100644
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -2480,7 +2480,7 @@ dbxout_expand_expr (tree expr)
 	     return NULL, otherwise stabs might reference an undefined
 	     symbol.  */
 	  struct varpool_node *node = varpool_get_node (expr);
-	  if (!node || !node->symbol.definition)
+	  if (!node || !node->definition)
 	    return NULL;
 	}
       /* FALLTHRU */
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index fc1c3f2..1f91aea 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -15024,7 +15024,7 @@ reference_to_unused (tree * tp, int * walk_subtrees,
   else if (TREE_CODE (*tp) == VAR_DECL)
     {
       struct varpool_node *node = varpool_get_node (*tp);
-      if (!node || !node->symbol.definition)
+      if (!node || !node->definition)
 	return *tp;
     }
   else if (TREE_CODE (*tp) == FUNCTION_DECL
@@ -17702,7 +17702,7 @@ premark_types_used_by_global_vars_helper (void **slot,
       /* Ask cgraph if the global variable really is to be emitted.
          If yes, then we'll keep the DIE of ENTRY->TYPE.  */
       struct varpool_node *node = varpool_get_node (entry->var_decl);
-      if (node && node->symbol.definition)
+      if (node && node->definition)
 	{
 	  die->die_perennial_p = 1;
 	  /* Keep the parent DIEs as well.  */
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index e6baabf..e946333 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -67,7 +67,7 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
       || TREE_CODE (from_decl) != VAR_DECL
       || !DECL_EXTERNAL (from_decl)
       || (flag_ltrans
-	  && symtab_get_node (from_decl)->symbol.in_other_partition))
+	  && symtab_get_node (from_decl)->in_other_partition))
     return true;
   /* We are concerned only about static/external vars and functions.  */
   if ((!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
@@ -78,7 +78,7 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
      unit may be in separate DSO and the symbol may be hidden.  */
   if (DECL_VISIBILITY_SPECIFIED (decl)
       && DECL_EXTERNAL (decl)
-      && (!(snode = symtab_get_node (decl)) || !snode->symbol.in_other_partition))
+      && (!(snode = symtab_get_node (decl)) || !snode->in_other_partition))
     return false;
   /* When function is public, we always can introduce new reference.
      Exception are the COMDAT functions where introducing a direct
@@ -109,7 +109,7 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
          The second is important when devirtualization happens during final
          compilation stage when making a new reference no longer makes callee
          to be compiled.  */
-      if (!node || !node->symbol.definition || node->global.inlined_to)
+      if (!node || !node->definition || node->global.inlined_to)
 	{
 	  gcc_checking_assert (!TREE_ASM_WRITTEN (decl));
 	  return false;
@@ -118,7 +118,7 @@ can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
   else if (TREE_CODE (decl) == VAR_DECL)
     {
       vnode = varpool_get_node (decl);
-      if (!vnode || !vnode->symbol.definition)
+      if (!vnode || !vnode->definition)
 	{
 	  gcc_checking_assert (!TREE_ASM_WRITTEN (decl));
 	  return false;
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index 3b3adb3..1e00dce 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -962,7 +962,7 @@ unshare_body (tree fndecl)
 
   if (cgn)
     for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
-      unshare_body (cgn->symbol.decl);
+      unshare_body (cgn->decl);
 }
 
 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
@@ -1005,7 +1005,7 @@ unvisit_body (tree fndecl)
 
   if (cgn)
     for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
-      unvisit_body (cgn->symbol.decl);
+      unvisit_body (cgn->decl);
 }
 
 /* Unconditionally make an unshared copy of EXPR.  This is used when using
diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c
index 78dee15..5453f9b 100644
--- a/gcc/ipa-cp.c
+++ b/gcc/ipa-cp.c
@@ -293,11 +293,11 @@ ipa_lat_is_single_const (struct ipcp_lattice *lat)
 static inline bool
 edge_within_scc (struct cgraph_edge *cs)
 {
-  struct ipa_dfs_info *caller_dfs = (struct ipa_dfs_info *) cs->caller->symbol.aux;
+  struct ipa_dfs_info *caller_dfs = (struct ipa_dfs_info *) cs->caller->aux;
   struct ipa_dfs_info *callee_dfs;
   struct cgraph_node *callee = cgraph_function_node (cs->callee, NULL);
 
-  callee_dfs = (struct ipa_dfs_info *) callee->symbol.aux;
+  callee_dfs = (struct ipa_dfs_info *) callee->aux;
   return (caller_dfs
 	  && callee_dfs
 	  && caller_dfs->scc_no == callee_dfs->scc_no);
@@ -369,7 +369,7 @@ print_lattice (FILE * f, struct ipcp_lattice *lat,
 
 	  fprintf (f, " [from:");
 	  for (s = val->sources; s; s = s->next)
-	    fprintf (f, " %i(%i)", s->cs->caller->symbol.order,
+	    fprintf (f, " %i(%i)", s->cs->caller->order,
 		     s->cs->frequency);
 	  fprintf (f, "]");
 	}
@@ -399,7 +399,7 @@ print_all_lattices (FILE * f, bool dump_sources, bool dump_benefits)
 
       info = IPA_NODE_REF (node);
       fprintf (f, "  Node: %s/%i:\n", cgraph_node_name (node),
-	       node->symbol.order);
+	       node->order);
       count = ipa_get_param_count (info);
       for (i = 0; i < count; i++)
 	{
@@ -440,16 +440,16 @@ determine_versionability (struct cgraph_node *node)
   /* There are a number of generic reasons functions cannot be versioned.  We
      also cannot remove parameters if there are type attributes such as fnspec
      present.  */
-  if (node->symbol.alias || node->thunk.thunk_p)
+  if (node->alias || node->thunk.thunk_p)
     reason = "alias or thunk";
   else if (!node->local.versionable)
     reason = "not a tree_versionable_function";
   else if (cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
     reason = "insufficient body availability";
 
-  if (reason && dump_file && !node->symbol.alias && !node->thunk.thunk_p)
+  if (reason && dump_file && !node->alias && !node->thunk.thunk_p)
     fprintf (dump_file, "Function %s/%i is not versionable, reason: %s.\n",
-	     cgraph_node_name (node), node->symbol.order, reason);
+	     cgraph_node_name (node), node->order, reason);
 
   node->local.versionable = (reason == NULL);
 }
@@ -525,7 +525,7 @@ ipcp_cloning_candidate_p (struct cgraph_node *node)
       return false;
     }
 
-  if (!optimize_function_for_speed_p (DECL_STRUCT_FUNCTION (node->symbol.decl)))
+  if (!optimize_function_for_speed_p (DECL_STRUCT_FUNCTION (node->decl)))
     {
       if (dump_file)
         fprintf (dump_file, "Not considering %s for cloning; "
@@ -727,9 +727,9 @@ initialize_node_lattices (struct cgraph_node *node)
 	    set_all_contains_variable (plats);
 	}
       if (dump_file && (dump_flags & TDF_DETAILS)
-	  && !node->symbol.alias && !node->thunk.thunk_p)
+	  && !node->alias && !node->thunk.thunk_p)
 	fprintf (dump_file, "Marking all lattices of %s/%i as %s\n",
-		 cgraph_node_name (node), node->symbol.order,
+		 cgraph_node_name (node), node->order,
 		 disable ? "BOTTOM" : "VARIABLE");
     }
 
@@ -1422,7 +1422,7 @@ propagate_constants_accross_call (struct cgraph_edge *cs)
   int i, args_count, parms_count;
 
   callee = cgraph_function_node (cs->callee, &availability);
-  if (!callee->symbol.definition)
+  if (!callee->definition)
     return false;
   gcc_checking_assert (cgraph_function_with_gimple_body_p (callee));
   callee_info = IPA_NODE_REF (callee);
@@ -1435,7 +1435,7 @@ propagate_constants_accross_call (struct cgraph_edge *cs)
      parameter.  However, we might need to uncover a thunk from below a series
      of aliases first.  */
   alias_or_thunk = cs->callee;
-  while (alias_or_thunk->symbol.alias)
+  while (alias_or_thunk->alias)
     alias_or_thunk = cgraph_alias_target (alias_or_thunk);
   if (alias_or_thunk->thunk.thunk_p)
     {
@@ -1606,7 +1606,7 @@ devirtualization_time_bonus (struct cgraph_node *node,
       /* Only bare minimum benefit for clearly un-inlineable targets.  */
       res += 1;
       callee = cgraph_get_node (target);
-      if (!callee || !callee->symbol.definition)
+      if (!callee || !callee->definition)
 	continue;
       isummary = inline_summary (callee);
       if (!isummary->inlinable)
@@ -1619,7 +1619,7 @@ devirtualization_time_bonus (struct cgraph_node *node,
       else if (isummary->size <= MAX_INLINE_INSNS_AUTO / 2)
 	res += 15;
       else if (isummary->size <= MAX_INLINE_INSNS_AUTO
-	       || DECL_DECLARED_INLINE_P (callee->symbol.decl))
+	       || DECL_DECLARED_INLINE_P (callee->decl))
 	res += 7;
     }
 
@@ -1649,7 +1649,7 @@ good_cloning_opportunity_p (struct cgraph_node *node, int time_benefit,
 {
   if (time_benefit == 0
       || !flag_ipa_cp_clone
-      || !optimize_function_for_speed_p (DECL_STRUCT_FUNCTION (node->symbol.decl)))
+      || !optimize_function_for_speed_p (DECL_STRUCT_FUNCTION (node->decl)))
     return false;
 
   gcc_assert (size_cost > 0);
@@ -1826,7 +1826,7 @@ estimate_local_effects (struct cgraph_node *node)
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "\nEstimating effects for %s/%i, base_time: %i.\n",
-	     cgraph_node_name (node), node->symbol.order, base_time);
+	     cgraph_node_name (node), node->order, base_time);
 
   always_const = gather_context_independent_values (info, &known_csts,
 						    &known_binfos, &known_aggs,
@@ -2119,14 +2119,14 @@ propagate_constants_topo (struct topo_info *topo)
       if (!cgraph_function_with_gimple_body_p (node))
 	continue;
 
-      node_dfs_info = (struct ipa_dfs_info *) node->symbol.aux;
+      node_dfs_info = (struct ipa_dfs_info *) node->aux;
       /* First, iteratively propagate within the strongly connected component
 	 until all lattices stabilize.  */
       v = node_dfs_info->next_cycle;
       while (v)
 	{
 	  push_node_to_stack (topo, v);
-	  v = ((struct ipa_dfs_info *) v->symbol.aux)->next_cycle;
+	  v = ((struct ipa_dfs_info *) v->aux)->next_cycle;
 	}
 
       v = node;
@@ -2155,7 +2155,7 @@ propagate_constants_topo (struct topo_info *topo)
 	    if (!edge_within_scc (cs))
 	      propagate_constants_accross_call (cs);
 
-	  v = ((struct ipa_dfs_info *) v->symbol.aux)->next_cycle;
+	  v = ((struct ipa_dfs_info *) v->aux)->next_cycle;
 	}
     }
 }
@@ -2235,7 +2235,7 @@ ipcp_propagate_stage (struct topo_info *topo)
 				   ipa_get_param_count (info));
 	initialize_node_lattices (node);
       }
-    if (node->symbol.definition && !node->symbol.alias)
+    if (node->definition && !node->alias)
       overall_size += inline_summary (node)->self_size;
     if (node->count > max_count)
       max_count = node->count;
@@ -2303,8 +2303,8 @@ ipcp_discover_new_direct_edges (struct cgraph_node *node,
 		    fprintf (dump_file, "     controlled uses count of param "
 			     "%i bumped down to %i\n", param_index, c);
 		  if (c == 0
-		      && (to_del = ipa_find_reference ((symtab_node) node,
-						       (symtab_node) cs->callee,
+		      && (to_del = ipa_find_reference (node,
+						       cs->callee,
 						       NULL, 0)))
 		    {
 		      if (dump_file && (dump_flags & TDF_DETAILS))
@@ -2560,7 +2560,7 @@ update_profiling_info (struct cgraph_node *orig_node,
 	fprintf (dump_file, "    Problem: node %s/%i has too low count "
 		 HOST_WIDE_INT_PRINT_DEC " while the sum of incoming "
 		 "counts is " HOST_WIDE_INT_PRINT_DEC "\n",
-		 cgraph_node_name (orig_node), orig_node->symbol.order,
+		 cgraph_node_name (orig_node), orig_node->order,
 		 (HOST_WIDE_INT) orig_node_count,
 		 (HOST_WIDE_INT) (orig_sum + new_sum));
 
@@ -2693,13 +2693,13 @@ create_specialized_node (struct cgraph_node *node,
 					  args_to_skip, "constprop");
   ipa_set_node_agg_value_chain (new_node, aggvals);
   for (av = aggvals; av; av = av->next)
-    ipa_maybe_record_reference ((symtab_node) new_node, av->value,
+    ipa_maybe_record_reference (new_node, av->value,
 				IPA_REF_ADDR, NULL);
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "     the new node is %s/%i.\n",
-	       cgraph_node_name (new_node), new_node->symbol.order);
+	       cgraph_node_name (new_node), new_node->order);
       if (aggvals)
 	ipa_dump_agg_replacement_values (dump_file, aggvals);
     }
@@ -3252,9 +3252,9 @@ perhaps_add_new_callers (struct cgraph_node *node, struct ipcp_value *val)
 		    fprintf (dump_file, " - adding an extra caller %s/%i"
 			     " of %s/%i\n",
 			     xstrdup (cgraph_node_name (cs->caller)),
-			     cs->caller->symbol.order,
+			     cs->caller->order,
 			     xstrdup (cgraph_node_name (val->spec_node)),
-			     val->spec_node->symbol.order);
+			     val->spec_node->order);
 
 		  cgraph_redirect_edge_callee (cs, val->spec_node);
 		  redirected_sum += cs->count;
@@ -3358,7 +3358,7 @@ decide_about_value (struct cgraph_node *node, int index, HOST_WIDE_INT offset,
 
   if (dump_file)
     fprintf (dump_file, "  Creating a specialized node of %s/%i.\n",
-	     cgraph_node_name (node), node->symbol.order);
+	     cgraph_node_name (node), node->order);
 
   callers = gather_edges_for_value (val, caller_count);
   kv = known_csts.copy ();
@@ -3395,7 +3395,7 @@ decide_whether_version_node (struct cgraph_node *node)
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "\nEvaluating opportunities for %s/%i.\n",
-	     cgraph_node_name (node), node->symbol.order);
+	     cgraph_node_name (node), node->order);
 
   gather_context_independent_values (info, &known_csts, &known_binfos,
 				  info->do_clone_for_all_contexts ? &known_aggs
@@ -3439,7 +3439,7 @@ decide_whether_version_node (struct cgraph_node *node)
       if (dump_file)
 	fprintf (dump_file, " - Creating a specialized node of %s/%i "
 		 "for all known contexts.\n", cgraph_node_name (node),
-		 node->symbol.order);
+		 node->order);
 
       callers = collect_callers_of_node (node);
       move_binfos_to_values (known_csts, known_binfos);
@@ -3514,23 +3514,23 @@ static void
 identify_dead_nodes (struct cgraph_node *node)
 {
   struct cgraph_node *v;
-  for (v = node; v ; v = ((struct ipa_dfs_info *) v->symbol.aux)->next_cycle)
+  for (v = node; v ; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
     if (cgraph_will_be_removed_from_program_if_no_direct_calls (v)
 	&& !cgraph_for_node_and_aliases (v,
 					 has_undead_caller_from_outside_scc_p,
 					 NULL, true))
       IPA_NODE_REF (v)->node_dead = 1;
 
-  for (v = node; v ; v = ((struct ipa_dfs_info *) v->symbol.aux)->next_cycle)
+  for (v = node; v ; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
     if (!IPA_NODE_REF (v)->node_dead)
       spread_undeadness (v);
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
-      for (v = node; v ; v = ((struct ipa_dfs_info *) v->symbol.aux)->next_cycle)
+      for (v = node; v ; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
 	if (IPA_NODE_REF (v)->node_dead)
 	  fprintf (dump_file, "  Marking node as dead: %s/%i.\n",
-		   cgraph_node_name (v), v->symbol.order);
+		   cgraph_node_name (v), v->order);
     }
 }
 
@@ -3554,7 +3554,7 @@ ipcp_decision_stage (struct topo_info *topo)
 	{
 	  struct cgraph_node *v;
 	  iterate = false;
-	  for (v = node; v ; v = ((struct ipa_dfs_info *) v->symbol.aux)->next_cycle)
+	  for (v = node; v ; v = ((struct ipa_dfs_info *) v->aux)->next_cycle)
 	    if (cgraph_function_with_gimple_body_p (v)
 		&& ipcp_versionable_function_p (v))
 	      iterate |= decide_whether_version_node (v);
@@ -3627,7 +3627,7 @@ ipcp_generate_summary (void)
   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
       {
 	node->local.versionable
-	  = tree_versionable_function_p (node->symbol.decl);
+	  = tree_versionable_function_p (node->decl);
 	ipa_analyze_node (node);
       }
 }
diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
index 2a50284..314efe2 100644
--- a/gcc/ipa-devirt.c
+++ b/gcc/ipa-devirt.c
@@ -543,9 +543,9 @@ build_type_inheritance_graph (void)
   /* We reconstruct the graph starting of types of all methods seen in the
      the unit.  */
   FOR_EACH_FUNCTION (n)
-    if (DECL_VIRTUAL_P (n->symbol.decl)
-	&& symtab_real_symbol_p ((symtab_node)n))
-      get_odr_type (method_class_type (TREE_TYPE (n->symbol.decl)), true);
+    if (DECL_VIRTUAL_P (n->decl)
+	&& symtab_real_symbol_p (n))
+      get_odr_type (method_class_type (TREE_TYPE (n->decl)), true);
   if (inheritance_dump_file)
     {
       dump_type_inheritance_graph (inheritance_dump_file);
@@ -570,7 +570,7 @@ maybe_record_node (vec <cgraph_node *> &nodes,
       && fcode != BUILT_IN_TRAP
       && !pointer_set_insert (inserted, target)
       && (target_node = cgraph_get_node (target)) != NULL
-      && symtab_real_symbol_p ((symtab_node)target_node))
+      && symtab_real_symbol_p (target_node))
     {
       pointer_set_insert (cached_polymorphic_call_targets,
 			  target_node);
@@ -856,7 +856,7 @@ dump_possible_polymorphic_call_targets (FILE *f,
 	   final ? " (full list)" : " (partial list, may call to other unit)");
   for (i = 0; i < targets.length (); i++)
     fprintf (f, " %s/%i", cgraph_node_name (targets[i]),
-	     targets[i]->symbol.order);
+	     targets[i]->order);
   fprintf (f, "\n");
 }
 
@@ -897,10 +897,10 @@ update_type_inheritance_graph (void)
   /* We reconstruct the graph starting of types of all methods seen in the
      the unit.  */
   FOR_EACH_FUNCTION (n)
-    if (DECL_VIRTUAL_P (n->symbol.decl)
-	&& !n->symbol.definition
-	&& symtab_real_symbol_p ((symtab_node)n))
-      get_odr_type (method_class_type (TREE_TYPE (n->symbol.decl)), true);
+    if (DECL_VIRTUAL_P (n->decl)
+	&& !n->definition
+	&& symtab_real_symbol_p (n))
+      get_odr_type (method_class_type (TREE_TYPE (n->decl)), true);
   timevar_pop (TV_IPA_INHERITANCE);
 }
 
@@ -914,13 +914,13 @@ likely_target_p (struct cgraph_node *n)
 {
   int flags;
   /* cxa_pure_virtual and similar things are not likely.  */
-  if (TREE_CODE (TREE_TYPE (n->symbol.decl)) != METHOD_TYPE)
+  if (TREE_CODE (TREE_TYPE (n->decl)) != METHOD_TYPE)
     return false;
-  flags = flags_from_decl_or_type (n->symbol.decl);
+  flags = flags_from_decl_or_type (n->decl);
   if (flags & ECF_NORETURN)
     return false;
   if (lookup_attribute ("cold",
-			DECL_ATTRIBUTES (n->symbol.decl)))
+			DECL_ATTRIBUTES (n->decl)))
     return false;
   if (n->frequency < NODE_FREQUENCY_NORMAL)
     return false;
@@ -950,7 +950,7 @@ ipa_devirt (void)
       bool update = false;
       if (dump_file && n->indirect_calls)
 	fprintf (dump_file, "\n\nProcesing function %s/%i\n",
-		 cgraph_node_name (n), n->symbol.order);
+		 cgraph_node_name (n), n->order);
       for (e = n->indirect_calls; e; e = e->next_callee)
 	if (e->indirect_info->polymorphic)
 	  {
@@ -975,8 +975,8 @@ ipa_devirt (void)
 		    if (dump_file)
 		      fprintf (dump_file,
 			       "Devirtualizing call in %s/%i to %s/%i\n",
-			       cgraph_node_name (n), n->symbol.order,
-			       cgraph_node_name (targets[0]), targets[0]->symbol.order);
+			       cgraph_node_name (n), n->order,
+			       cgraph_node_name (targets[0]), targets[0]->order);
 		    cgraph_make_edge_direct (e, targets[0]);
 		    ndevirtualized++;
 		    update = true;
@@ -1048,7 +1048,7 @@ ipa_devirt (void)
 		  }
 		continue;
 	      }
-	    if (!likely_target->symbol.definition)
+	    if (!likely_target->definition)
 	      {
 		if (dump_file)
 		  fprintf (dump_file, "Target is not an definition\n");
@@ -1059,7 +1059,7 @@ ipa_devirt (void)
 	       can handle these just well, it is common for programs to
 	       incorrectly with headers defining methods they are linked
 	       with.  */
-	    if (DECL_EXTERNAL (likely_target->symbol.decl))
+	    if (DECL_EXTERNAL (likely_target->decl))
 	      {
 		if (dump_file)
 		  fprintf (dump_file, "Target is external\n");
@@ -1068,7 +1068,7 @@ ipa_devirt (void)
 	      }
 	    if (cgraph_function_body_availability (likely_target)
 		<= AVAIL_OVERWRITABLE
-		&& symtab_can_be_discarded ((symtab_node) likely_target))
+		&& symtab_can_be_discarded (likely_target))
 	      {
 		if (dump_file)
 		  fprintf (dump_file, "Target is overwritable\n");
@@ -1080,11 +1080,11 @@ ipa_devirt (void)
 		if (dump_file)
 		  fprintf (dump_file,
 			   "Speculatively devirtualizing call in %s/%i to %s/%i\n",
-			   cgraph_node_name (n), n->symbol.order,
+			   cgraph_node_name (n), n->order,
 			   cgraph_node_name (likely_target),
-			   likely_target->symbol.order);
-		if (!symtab_can_be_discarded ((symtab_node) likely_target))
-		  likely_target = cgraph (symtab_nonoverwritable_alias ((symtab_node)likely_target));
+			   likely_target->order);
+		if (!symtab_can_be_discarded (likely_target))
+		  likely_target = cgraph (symtab_nonoverwritable_alias (likely_target));
 		nconverted++;
 		update = true;
 		cgraph_turn_edge_to_speculative
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index fb0c838..702daaf 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -1292,7 +1292,7 @@ dump_inline_edge_summary (FILE *f, int indent, struct cgraph_node *node,
       fprintf (f,
 	       "%*s%s/%i %s\n%*s  loop depth:%2i freq:%4i size:%2i"
 	       " time: %2i callee size:%2i stack:%2i",
-	       indent, "", cgraph_node_name (callee), callee->symbol.order,
+	       indent, "", cgraph_node_name (callee), callee->order,
 	       !edge->inline_failed
 	       ? "inlined" : cgraph_inline_failed_string (edge-> inline_failed),
 	       indent, "", es->loop_depth, edge->frequency,
@@ -1352,14 +1352,14 @@ dump_inline_edge_summary (FILE *f, int indent, struct cgraph_node *node,
 void
 dump_inline_summary (FILE *f, struct cgraph_node *node)
 {
-  if (node->symbol.definition)
+  if (node->definition)
     {
       struct inline_summary *s = inline_summary (node);
       size_time_entry *e;
       int i;
       fprintf (f, "Inline summary for %s/%i", cgraph_node_name (node),
-	       node->symbol.order);
-      if (DECL_DISREGARD_INLINE_LIMITS (node->symbol.decl))
+	       node->order);
+      if (DECL_DISREGARD_INLINE_LIMITS (node->decl))
 	fprintf (f, " always_inline");
       if (s->inlinable)
 	fprintf (f, " inlinable");
@@ -1428,7 +1428,7 @@ initialize_inline_failed (struct cgraph_edge *e)
 
   if (e->indirect_unknown_callee)
     e->inline_failed = CIF_INDIRECT_UNKNOWN_CALL;
-  else if (!callee->symbol.definition)
+  else if (!callee->definition)
     e->inline_failed = CIF_BODY_NOT_AVAILABLE;
   else if (callee->local.redefined_extern_inline)
     e->inline_failed = CIF_REDEFINED_EXTERN_INLINE;
@@ -1815,7 +1815,7 @@ compute_bb_predicates (struct cgraph_node *node,
 		       struct ipa_node_params *parms_info,
 		       struct inline_summary *summary)
 {
-  struct function *my_function = DECL_STRUCT_FUNCTION (node->symbol.decl);
+  struct function *my_function = DECL_STRUCT_FUNCTION (node->decl);
   bool done = false;
   basic_block bb;
 
@@ -2271,7 +2271,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
      <0,2>.  */
   basic_block bb;
   gimple_stmt_iterator bsi;
-  struct function *my_function = DECL_STRUCT_FUNCTION (node->symbol.decl);
+  struct function *my_function = DECL_STRUCT_FUNCTION (node->decl);
   int freq;
   struct inline_summary *info = inline_summary (node);
   struct predicate bb_predicate;
@@ -2318,7 +2318,7 @@ estimate_function_body_sizes (struct cgraph_node *node, bool early)
   for (n = 0; n < nblocks; n++)
     {
       bb = BASIC_BLOCK (order[n]);
-      freq = compute_call_stmt_bb_frequency (node->symbol.decl, bb);
+      freq = compute_call_stmt_bb_frequency (node->decl, bb);
 
       /* TODO: Obviously predicates can be propagated down across CFG.  */
       if (parms_info)
@@ -2655,7 +2655,7 @@ compute_inline_parameters (struct cgraph_node *node, bool early)
     }
 
   /* Even is_gimple_min_invariant rely on current_function_decl.  */
-  push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
+  push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 
   /* Estimate the stack size for the function if we're optimizing.  */
   self_stack_size = optimize ? estimated_stack_frame_size (node) : 0;
@@ -2664,10 +2664,10 @@ compute_inline_parameters (struct cgraph_node *node, bool early)
   info->stack_frame_offset = 0;
 
   /* Can this function be inlined at all?  */
-  info->inlinable = tree_inlinable_function_p (node->symbol.decl);
+  info->inlinable = tree_inlinable_function_p (node->decl);
 
   /* Type attributes can use parameter indices to describe them.  */
-  if (TYPE_ATTRIBUTES (TREE_TYPE (node->symbol.decl)))
+  if (TYPE_ATTRIBUTES (TREE_TYPE (node->decl)))
     node->local.can_change_signature = false;
   else
     {
@@ -2679,7 +2679,7 @@ compute_inline_parameters (struct cgraph_node *node, bool early)
 	  /* Functions calling builtin_apply can not change signature.  */
 	  for (e = node->callees; e; e = e->next_callee)
 	    {
-	      tree cdecl = e->callee->symbol.decl;
+	      tree cdecl = e->callee->decl;
 	      if (DECL_BUILT_IN (cdecl)
 		  && DECL_BUILT_IN_CLASS (cdecl) == BUILT_IN_NORMAL
 		  && (DECL_FUNCTION_CODE (cdecl) == BUILT_IN_APPLY_ARGS
@@ -2787,7 +2787,7 @@ estimate_edge_devirt_benefit (struct cgraph_edge *ie,
   gcc_checking_assert (*size >= 0);
 
   callee = cgraph_get_node (target);
-  if (!callee || !callee->symbol.definition)
+  if (!callee || !callee->definition)
     return false;
   isummary = inline_summary (callee);
   return isummary->inlinable;
@@ -2893,7 +2893,7 @@ estimate_node_size_and_time (struct cgraph_node *node,
       bool found = false;
       fprintf (dump_file, "   Estimating body: %s/%i\n"
 	       "   Known to be false: ", cgraph_node_name (node),
-	       node->symbol.order);
+	       node->order);
 
       for (i = predicate_not_inlined_condition;
 	   i < (predicate_first_dynamic_condition
@@ -2944,7 +2944,7 @@ estimate_node_size_and_time (struct cgraph_node *node,
     hints |= INLINE_HINT_array_index;
   if (info->scc_no)
     hints |= INLINE_HINT_in_scc;
-  if (DECL_DECLARED_INLINE_P (node->symbol.decl))
+  if (DECL_DECLARED_INLINE_P (node->decl))
     hints |= INLINE_HINT_declared_inline;
 
   estimate_calls_size_and_time (node, &size, &time, &hints, possible_truths,
@@ -3404,8 +3404,8 @@ simple_edge_hints (struct cgraph_edge *edge)
       && !cgraph_edge_recursive_p (edge))
     hints |= INLINE_HINT_same_scc;
 
-  if (to->symbol.lto_file_data && edge->callee->symbol.lto_file_data
-      && to->symbol.lto_file_data != edge->callee->symbol.lto_file_data)
+  if (to->lto_file_data && edge->callee->lto_file_data
+      && to->lto_file_data != edge->callee->lto_file_data)
     hints |= INLINE_HINT_cross_module;
 
   return hints;
@@ -3623,7 +3623,7 @@ do_estimate_growth (struct cgraph_node *node)
      return zero or negative growths. */
   if (d.self_recursive)
     d.growth = d.growth < info->size ? info->size : d.growth;
-  else if (DECL_EXTERNAL (node->symbol.decl))
+  else if (DECL_EXTERNAL (node->decl))
     ;
   else
     {
@@ -3632,7 +3632,7 @@ do_estimate_growth (struct cgraph_node *node)
       /* COMDAT functions are very often not shared across multiple units
          since they come from various template instantiations.
          Take this into account.  */
-      else if (DECL_COMDAT (node->symbol.decl)
+      else if (DECL_COMDAT (node->decl)
 	       && cgraph_can_remove_if_no_direct_calls_p (node))
 	d.growth -= (info->size
 		     * (100 - PARAM_VALUE (PARAM_COMDAT_SHARING_PROBABILITY))
@@ -3669,11 +3669,11 @@ inline_indirect_intraprocedural_analysis (struct cgraph_node *node)
 static void
 inline_analyze_function (struct cgraph_node *node)
 {
-  push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
+  push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 
   if (dump_file)
     fprintf (dump_file, "\nAnalyzing function: %s/%u\n",
-	     cgraph_node_name (node), node->symbol.order);
+	     cgraph_node_name (node), node->order);
   if (optimize && !node->thunk.thunk_p)
     inline_indirect_intraprocedural_analysis (node);
   compute_inline_parameters (node, false);
@@ -3710,7 +3710,7 @@ inline_generate_summary (void)
   inline_free_summary ();
 
   FOR_EACH_DEFINED_FUNCTION (node)
-    if (!node->symbol.alias)
+    if (!node->alias)
       inline_analyze_function (node);
 }
 
@@ -3944,7 +3944,7 @@ inline_write_summary (void)
     {
       symtab_node snode = lto_symtab_encoder_deref (encoder, i);
       cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
-      if (cnode && cnode->symbol.definition && !cnode->symbol.alias)
+      if (cnode && cnode->definition && !cnode->alias)
 	count++;
     }
   streamer_write_uhwi (ob, count);
@@ -3953,7 +3953,7 @@ inline_write_summary (void)
     {
       symtab_node snode = lto_symtab_encoder_deref (encoder, i);
       cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
-      if (cnode && (node = cnode)->symbol.definition && !node->symbol.alias)
+      if (cnode && (node = cnode)->definition && !node->alias)
 	{
 	  struct inline_summary *info = inline_summary (node);
 	  struct bitpack_d bp;
@@ -3964,7 +3964,7 @@ inline_write_summary (void)
 
 	  streamer_write_uhwi (ob,
 			       lto_symtab_encoder_encode (encoder,
-							  (symtab_node)
+							  
 							  node));
 	  streamer_write_hwi (ob, info->estimated_self_stack_size);
 	  streamer_write_hwi (ob, info->self_size);
diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c
index 2bada90..96d83e5 100644
--- a/gcc/ipa-inline-transform.c
+++ b/gcc/ipa-inline-transform.c
@@ -86,15 +86,15 @@ can_remove_node_now_p_1 (struct cgraph_node *node)
   /* FIXME: When address is taken of DECL_EXTERNAL function we still
      can remove its offline copy, but we would need to keep unanalyzed node in
      the callgraph so references can point to it.  */
-  return (!node->symbol.address_taken
-	  && !ipa_ref_has_aliases_p (&node->symbol.ref_list)
+  return (!node->address_taken
+	  && !ipa_ref_has_aliases_p (&node->ref_list)
 	  && !node->used_as_abstract_origin
 	  && cgraph_can_remove_if_no_direct_calls_p (node)
 	  /* Inlining might enable more devirtualizing, so we want to remove
 	     those only after all devirtualizable virtual calls are processed.
 	     Lacking may edges in callgraph we just preserve them post
 	     inlining.  */
-	  && !DECL_VIRTUAL_P (node->symbol.decl)
+	  && !DECL_VIRTUAL_P (node->decl)
 	  /* During early inlining some unanalyzed cgraph nodes might be in the
 	     callgraph and they might reffer the function in question.  */
 	  && !cgraph_new_nodes);
@@ -113,10 +113,10 @@ can_remove_node_now_p (struct cgraph_node *node, struct cgraph_edge *e)
 
   /* When we see same comdat group, we need to be sure that all
      items can be removed.  */
-  if (!node->symbol.same_comdat_group)
+  if (!node->same_comdat_group)
     return true;
-  for (next = cgraph (node->symbol.same_comdat_group);
-       next != node; next = cgraph (next->symbol.same_comdat_group))
+  for (next = cgraph (node->same_comdat_group);
+       next != node; next = cgraph (next->same_comdat_group))
     if ((next->callers && next->callers != e)
 	|| !can_remove_node_now_p_1 (next))
       return false;
@@ -162,28 +162,28 @@ clone_inlined_nodes (struct cgraph_edge *e, bool duplicate,
 	     For now we keep the ohter functions in the group in program until
 	     cgraph_remove_unreachable_functions gets rid of them.  */
 	  gcc_assert (!e->callee->global.inlined_to);
-          symtab_dissolve_same_comdat_group_list ((symtab_node) e->callee);
-	  if (e->callee->symbol.definition && !DECL_EXTERNAL (e->callee->symbol.decl))
+          symtab_dissolve_same_comdat_group_list (e->callee);
+	  if (e->callee->definition && !DECL_EXTERNAL (e->callee->decl))
 	    {
 	      if (overall_size)
 	        *overall_size -= inline_summary (e->callee)->size;
 	      nfunctions_inlined++;
 	    }
 	  duplicate = false;
-	  e->callee->symbol.externally_visible = false;
+	  e->callee->externally_visible = false;
           update_noncloned_frequencies (e->callee, e->frequency);
 	}
       else
 	{
 	  struct cgraph_node *n;
-	  n = cgraph_clone_node (e->callee, e->callee->symbol.decl,
+	  n = cgraph_clone_node (e->callee, e->callee->decl,
 				 e->count, e->frequency, update_original,
 				 vNULL, true, inlining_into);
 	  cgraph_redirect_edge_callee (e, n);
 	}
     }
   else
-    symtab_dissolve_same_comdat_group_list ((symtab_node) e->callee);
+    symtab_dissolve_same_comdat_group_list (e->callee);
 
   e->callee->global.inlined_to = inlining_into;
 
@@ -235,7 +235,7 @@ inline_call (struct cgraph_edge *e, bool update_original,
   gcc_assert (!callee->global.inlined_to);
 
   e->inline_failed = CIF_OK;
-  DECL_POSSIBLY_INLINED (callee->symbol.decl) = true;
+  DECL_POSSIBLY_INLINED (callee->decl) = true;
 
   to = e->caller;
   if (to->global.inlined_to)
@@ -287,7 +287,7 @@ inline_call (struct cgraph_edge *e, bool update_original,
   /* Account the change of overall unit size; external functions will be
      removed and are thus not accounted.  */
   if (overall_size
-      && !DECL_EXTERNAL (to->symbol.decl))
+      && !DECL_EXTERNAL (to->decl))
     *overall_size += new_size - old_size;
   ncalls_inlined++;
 
@@ -313,13 +313,13 @@ save_inline_function_body (struct cgraph_node *node)
     fprintf (dump_file, "\nSaving body of %s for later reuse\n",
 	     cgraph_node_name (node));
  
-  gcc_assert (node == cgraph_get_node (node->symbol.decl));
+  gcc_assert (node == cgraph_get_node (node->decl));
 
   /* first_clone will be turned into real function.  */
   first_clone = node->clones;
-  first_clone->symbol.decl = copy_node (node->symbol.decl);
-  symtab_insert_node_to_hashtable ((symtab_node) first_clone);
-  gcc_assert (first_clone == cgraph_get_node (first_clone->symbol.decl));
+  first_clone->decl = copy_node (node->decl);
+  symtab_insert_node_to_hashtable (first_clone);
+  gcc_assert (first_clone == cgraph_get_node (first_clone->decl));
 
   /* Now reshape the clone tree, so all other clones descends from
      first_clone.  */
@@ -347,8 +347,8 @@ save_inline_function_body (struct cgraph_node *node)
   if (first_clone->clones)
     for (n = first_clone->clones; n != first_clone;)
       {
-        gcc_assert (n->symbol.decl == node->symbol.decl);
-	n->symbol.decl = first_clone->symbol.decl;
+        gcc_assert (n->decl == node->decl);
+	n->decl = first_clone->decl;
 	if (n->clones)
 	  n = n->clones;
 	else if (n->next_sibling_clone)
@@ -363,16 +363,16 @@ save_inline_function_body (struct cgraph_node *node)
       }
 
   /* Copy the OLD_VERSION_NODE function tree to the new version.  */
-  tree_function_versioning (node->symbol.decl, first_clone->symbol.decl,
+  tree_function_versioning (node->decl, first_clone->decl,
 			    NULL, true, NULL, false,
 			    NULL, NULL);
 
   /* The function will be short lived and removed after we inline all the clones,
      but make it internal so we won't confuse ourself.  */
-  DECL_EXTERNAL (first_clone->symbol.decl) = 0;
-  DECL_COMDAT_GROUP (first_clone->symbol.decl) = NULL_TREE;
-  TREE_PUBLIC (first_clone->symbol.decl) = 0;
-  DECL_COMDAT (first_clone->symbol.decl) = 0;
+  DECL_EXTERNAL (first_clone->decl) = 0;
+  DECL_COMDAT_GROUP (first_clone->decl) = NULL_TREE;
+  TREE_PUBLIC (first_clone->decl) = 0;
+  DECL_COMDAT (first_clone->decl) = 0;
   first_clone->ipa_transforms_to_apply.release ();
 
   /* When doing recursive inlining, the clone may become unnecessary.
@@ -398,7 +398,7 @@ static bool
 preserve_function_body_p (struct cgraph_node *node)
 {
   gcc_assert (cgraph_global_info_ready);
-  gcc_assert (!node->symbol.alias && !node->thunk.thunk_p);
+  gcc_assert (!node->alias && !node->thunk.thunk_p);
 
   /* Look if there is any clone around.  */
   if (node->clones)
@@ -429,7 +429,7 @@ inline_transform (struct cgraph_node *node)
       next = e->next_callee;
       cgraph_redirect_edge_call_stmt_to_callee (e);
     }
-  ipa_remove_all_references (&node->symbol.ref_list);
+  ipa_remove_all_references (&node->ref_list);
 
   timevar_push (TV_INTEGRATION);
   if (node->callees && optimize)
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index 1e22d6e..5f0f9cf 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -220,8 +220,8 @@ report_inline_failed_reason (struct cgraph_edge *e)
   if (dump_file)
     {
       fprintf (dump_file, "  not inlinable: %s/%i -> %s/%i, %s\n",
-	       xstrdup (cgraph_node_name (e->caller)), e->caller->symbol.order,
-	       xstrdup (cgraph_node_name (e->callee)), e->callee->symbol.order,
+	       xstrdup (cgraph_node_name (e->caller)), e->caller->order,
+	       xstrdup (cgraph_node_name (e->callee)), e->callee->order,
 	       cgraph_inline_failed_string (e->inline_failed));
     }
 }
@@ -243,22 +243,22 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
   enum availability avail;
   struct cgraph_node *callee
     = cgraph_function_or_thunk_node (e->callee, &avail);
-  tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (e->caller->symbol.decl);
+  tree caller_tree = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (e->caller->decl);
   tree callee_tree
-    = callee ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee->symbol.decl) : NULL;
-  struct function *caller_cfun = DECL_STRUCT_FUNCTION (e->caller->symbol.decl);
+    = callee ? DECL_FUNCTION_SPECIFIC_OPTIMIZATION (callee->decl) : NULL;
+  struct function *caller_cfun = DECL_STRUCT_FUNCTION (e->caller->decl);
   struct function *callee_cfun
-    = callee ? DECL_STRUCT_FUNCTION (callee->symbol.decl) : NULL;
+    = callee ? DECL_STRUCT_FUNCTION (callee->decl) : NULL;
 
   if (!caller_cfun && e->caller->clone_of)
-    caller_cfun = DECL_STRUCT_FUNCTION (e->caller->clone_of->symbol.decl);
+    caller_cfun = DECL_STRUCT_FUNCTION (e->caller->clone_of->decl);
 
   if (!callee_cfun && callee && callee->clone_of)
-    callee_cfun = DECL_STRUCT_FUNCTION (callee->clone_of->symbol.decl);
+    callee_cfun = DECL_STRUCT_FUNCTION (callee->clone_of->decl);
 
   gcc_assert (e->inline_failed);
 
-  if (!callee || !callee->symbol.definition)
+  if (!callee || !callee->definition)
     {
       e->inline_failed = CIF_BODY_NOT_AVAILABLE;
       inlinable = false;
@@ -279,18 +279,18 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
       inlinable = false;
     }
   /* Don't inline if the functions have different EH personalities.  */
-  else if (DECL_FUNCTION_PERSONALITY (e->caller->symbol.decl)
-	   && DECL_FUNCTION_PERSONALITY (callee->symbol.decl)
-	   && (DECL_FUNCTION_PERSONALITY (e->caller->symbol.decl)
-	       != DECL_FUNCTION_PERSONALITY (callee->symbol.decl)))
+  else if (DECL_FUNCTION_PERSONALITY (e->caller->decl)
+	   && DECL_FUNCTION_PERSONALITY (callee->decl)
+	   && (DECL_FUNCTION_PERSONALITY (e->caller->decl)
+	       != DECL_FUNCTION_PERSONALITY (callee->decl)))
     {
       e->inline_failed = CIF_EH_PERSONALITY;
       inlinable = false;
     }
   /* TM pure functions should not be inlined into non-TM_pure
      functions.  */
-  else if (is_tm_pure (callee->symbol.decl)
-	   && !is_tm_pure (e->caller->symbol.decl))
+  else if (is_tm_pure (callee->decl)
+	   && !is_tm_pure (e->caller->decl))
     {
       e->inline_failed = CIF_UNSPECIFIED;
       inlinable = false;
@@ -306,20 +306,20 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
       inlinable = false;
     }
   /* Check compatibility of target optimization options.  */
-  else if (!targetm.target_option.can_inline_p (e->caller->symbol.decl,
-						callee->symbol.decl))
+  else if (!targetm.target_option.can_inline_p (e->caller->decl,
+						callee->decl))
     {
       e->inline_failed = CIF_TARGET_OPTION_MISMATCH;
       inlinable = false;
     }
   /* Check if caller growth allows the inlining.  */
-  else if (!DECL_DISREGARD_INLINE_LIMITS (callee->symbol.decl)
+  else if (!DECL_DISREGARD_INLINE_LIMITS (callee->decl)
 	   && !disregard_limits
 	   && !lookup_attribute ("flatten",
 				 DECL_ATTRIBUTES
 				   (e->caller->global.inlined_to
-				    ? e->caller->global.inlined_to->symbol.decl
-				    : e->caller->symbol.decl))
+				    ? e->caller->global.inlined_to->decl
+				    : e->caller->decl))
            && !caller_growth_limits (e))
     inlinable = false;
   /* Don't inline a function with a higher optimization level than the
@@ -340,7 +340,7 @@ can_inline_edge_p (struct cgraph_edge *e, bool report,
       if (((caller_opt->x_optimize > callee_opt->x_optimize)
 	   || (caller_opt->x_optimize_size != callee_opt->x_optimize_size))
 	  /* gcc.dg/pr43564.c.  Look at forced inline even in -O0.  */
-	  && !DECL_DISREGARD_INLINE_LIMITS (e->callee->symbol.decl))
+	  && !DECL_DISREGARD_INLINE_LIMITS (e->callee->decl))
 	{
 	  e->inline_failed = CIF_OPTIMIZATION_MISMATCH;
 	  inlinable = false;
@@ -363,7 +363,7 @@ can_early_inline_edge_p (struct cgraph_edge *e)
   /* Early inliner might get called at WPA stage when IPA pass adds new
      function.  In this case we can not really do any of early inlining
      because function bodies are missing.  */
-  if (!gimple_has_body_p (callee->symbol.decl))
+  if (!gimple_has_body_p (callee->decl))
     {
       e->inline_failed = CIF_BODY_NOT_AVAILABLE;
       return false;
@@ -372,8 +372,8 @@ can_early_inline_edge_p (struct cgraph_edge *e)
      (i.e. the callgraph is cyclic and we did not process
      the callee by early inliner, yet).  We don't have CIF code for this
      case; later we will re-do the decision in the real inliner.  */
-  if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (e->caller->symbol.decl))
-      || !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (callee->symbol.decl)))
+  if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (e->caller->decl))
+      || !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (callee->decl)))
     {
       if (dump_file)
 	fprintf (dump_file, "  edge not inlinable: not in SSA form\n");
@@ -394,7 +394,7 @@ num_calls (struct cgraph_node *n)
   int num = 0;
 
   for (e = n->callees; e; e = e->next_callee)
-    if (!is_inexpensive_builtin (e->callee->symbol.decl))
+    if (!is_inexpensive_builtin (e->callee->decl))
       num++;
   return num;
 }
@@ -408,9 +408,9 @@ want_early_inline_function_p (struct cgraph_edge *e)
   bool want_inline = true;
   struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
 
-  if (DECL_DISREGARD_INLINE_LIMITS (callee->symbol.decl))
+  if (DECL_DISREGARD_INLINE_LIMITS (callee->decl))
     ;
-  else if (!DECL_DECLARED_INLINE_P (callee->symbol.decl)
+  else if (!DECL_DECLARED_INLINE_P (callee->decl)
 	   && !flag_inline_small_functions)
     {
       e->inline_failed = CIF_FUNCTION_NOT_INLINE_CANDIDATE;
@@ -431,8 +431,8 @@ want_early_inline_function_p (struct cgraph_edge *e)
 	    fprintf (dump_file, "  will not early inline: %s/%i->%s/%i, "
 		     "call is cold and code would grow by %i\n",
 		     xstrdup (cgraph_node_name (e->caller)),
-		     e->caller->symbol.order,
-		     xstrdup (cgraph_node_name (callee)), callee->symbol.order,
+		     e->caller->order,
+		     xstrdup (cgraph_node_name (callee)), callee->order,
 		     growth);
 	  want_inline = false;
 	}
@@ -442,8 +442,8 @@ want_early_inline_function_p (struct cgraph_edge *e)
 	    fprintf (dump_file, "  will not early inline: %s/%i->%s/%i, "
 		     "growth %i exceeds --param early-inlining-insns\n",
 		     xstrdup (cgraph_node_name (e->caller)),
-		     e->caller->symbol.order,
-		     xstrdup (cgraph_node_name (callee)), callee->symbol.order,
+		     e->caller->order,
+		     xstrdup (cgraph_node_name (callee)), callee->order,
 		     growth);
 	  want_inline = false;
 	}
@@ -455,8 +455,8 @@ want_early_inline_function_p (struct cgraph_edge *e)
 		     "growth %i exceeds --param early-inlining-insns "
 		     "divided by number of calls\n",
 		     xstrdup (cgraph_node_name (e->caller)),
-		     e->caller->symbol.order,
-		     xstrdup (cgraph_node_name (callee)), callee->symbol.order,
+		     e->caller->order,
+		     xstrdup (cgraph_node_name (callee)), callee->order,
 		     growth);
 	  want_inline = false;
 	}
@@ -526,9 +526,9 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report)
   bool want_inline = true;
   struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
 
-  if (DECL_DISREGARD_INLINE_LIMITS (callee->symbol.decl))
+  if (DECL_DISREGARD_INLINE_LIMITS (callee->decl))
     ;
-  else if (!DECL_DECLARED_INLINE_P (callee->symbol.decl)
+  else if (!DECL_DECLARED_INLINE_P (callee->decl)
 	   && !flag_inline_small_functions)
     {
       e->inline_failed = CIF_FUNCTION_NOT_INLINE_CANDIDATE;
@@ -544,7 +544,7 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report)
 	;
       /* Apply MAX_INLINE_INSNS_SINGLE limit.  Do not do so when
 	 hints suggests that inlining given function is very profitable.  */
-      else if (DECL_DECLARED_INLINE_P (callee->symbol.decl)
+      else if (DECL_DECLARED_INLINE_P (callee->decl)
 	       && growth >= MAX_INLINE_INSNS_SINGLE
 	       && !big_speedup
 	       && !(hints & (INLINE_HINT_indirect_call
@@ -587,11 +587,11 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report)
 		  Consequently we ask cgraph_can_remove_if_no_direct_calls_p
 		  instead of
 		  cgraph_will_be_removed_from_program_if_no_direct_calls  */
-	        && !DECL_EXTERNAL (callee->symbol.decl)
+	        && !DECL_EXTERNAL (callee->decl)
 		&& cgraph_can_remove_if_no_direct_calls_p (callee)
 		&& estimate_growth (callee) <= 0)
 	;
-      else if (!DECL_DECLARED_INLINE_P (callee->symbol.decl)
+      else if (!DECL_DECLARED_INLINE_P (callee->decl)
 	       && !flag_inline_functions)
 	{
           e->inline_failed = CIF_NOT_DECLARED_INLINED;
@@ -600,7 +600,7 @@ want_inline_small_function_p (struct cgraph_edge *e, bool report)
       /* Apply MAX_INLINE_INSNS_AUTO limit for functions not declared inline
 	 Upgrade it to MAX_INLINE_INSNS_SINGLE when hints suggests that
 	 inlining given function is very profitable.  */
-      else if (!DECL_DECLARED_INLINE_P (callee->symbol.decl)
+      else if (!DECL_DECLARED_INLINE_P (callee->decl)
 	       && !big_speedup
 	       && growth >= ((hints & (INLINE_HINT_indirect_call
 				       | INLINE_HINT_loop_iterations
@@ -647,7 +647,7 @@ want_inline_self_recursive_call_p (struct cgraph_edge *edge,
   int caller_freq = CGRAPH_FREQ_BASE;
   int max_depth = PARAM_VALUE (PARAM_MAX_INLINE_RECURSIVE_DEPTH_AUTO);
 
-  if (DECL_DECLARED_INLINE_P (edge->caller->symbol.decl))
+  if (DECL_DECLARED_INLINE_P (edge->caller->decl))
     max_depth = PARAM_VALUE (PARAM_MAX_INLINE_RECURSIVE_DEPTH);
 
   if (!cgraph_maybe_hot_edge_p (edge))
@@ -815,8 +815,8 @@ relative_time_benefit (struct inline_summary *callee_info,
 
   /* Inlining into extern inline function is not a win.  */
   if (DECL_EXTERNAL (edge->caller->global.inlined_to
-		     ? edge->caller->global.inlined_to->symbol.decl
-		     : edge->caller->symbol.decl))
+		     ? edge->caller->global.inlined_to->decl
+		     : edge->caller->decl))
     return 1;
 
   /* Watch overflows.  */
@@ -855,7 +855,7 @@ edge_badness (struct cgraph_edge *edge, bool dump)
   struct inline_summary *callee_info = inline_summary (callee);
   inline_hints hints;
 
-  if (DECL_DISREGARD_INLINE_LIMITS (callee->symbol.decl))
+  if (DECL_DISREGARD_INLINE_LIMITS (callee->decl))
     return INT_MIN;
 
   growth = estimate_edge_growth (edge);
@@ -869,9 +869,9 @@ edge_badness (struct cgraph_edge *edge, bool dump)
     {
       fprintf (dump_file, "    Badness calculation for %s/%i -> %s/%i\n",
 	       xstrdup (cgraph_node_name (edge->caller)),
-	       edge->caller->symbol.order,
+	       edge->caller->order,
 	       xstrdup (cgraph_node_name (callee)),
-	       edge->callee->symbol.order);
+	       edge->callee->order);
       fprintf (dump_file, "      size growth %i, time %i ",
 	       growth,
 	       edge_time);
@@ -1034,9 +1034,9 @@ update_edge_key (fibheap_t heap, struct cgraph_edge *edge)
 	      fprintf (dump_file,
 		       "  decreasing badness %s/%i -> %s/%i, %i to %i\n",
 		       xstrdup (cgraph_node_name (edge->caller)),
-		       edge->caller->symbol.order,
+		       edge->caller->order,
 		       xstrdup (cgraph_node_name (edge->callee)),
-		       edge->callee->symbol.order,
+		       edge->callee->order,
 		       (int)n->key,
 		       badness);
 	    }
@@ -1051,9 +1051,9 @@ update_edge_key (fibheap_t heap, struct cgraph_edge *edge)
 	   fprintf (dump_file,
 		    "  enqueuing call %s/%i -> %s/%i, badness %i\n",
 		    xstrdup (cgraph_node_name (edge->caller)),
-		    edge->caller->symbol.order,
+		    edge->caller->order,
 		    xstrdup (cgraph_node_name (edge->callee)),
-		    edge->callee->symbol.order,
+		    edge->callee->order,
 		    badness);
 	 }
       edge->aux = fibheap_insert (heap, badness, edge);
@@ -1084,7 +1084,7 @@ reset_edge_caches (struct cgraph_node *node)
   for (edge = where->callers; edge; edge = edge->next_caller)
     if (edge->inline_failed)
       reset_edge_growth_cache (edge);
-  for (i = 0; ipa_ref_list_referring_iterate (&where->symbol.ref_list,
+  for (i = 0; ipa_ref_list_referring_iterate (&where->ref_list,
 					      i, ref); i++)
     if (ref->use == IPA_REF_ALIAS)
       reset_edge_caches (ipa_ref_referring_node (ref));
@@ -1129,13 +1129,13 @@ update_caller_keys (fibheap_t heap, struct cgraph_node *node,
   int i;
   struct ipa_ref *ref;
 
-  if ((!node->symbol.alias && !inline_summary (node)->inlinable)
+  if ((!node->alias && !inline_summary (node)->inlinable)
       || node->global.inlined_to)
     return;
   if (!bitmap_set_bit (updated_nodes, node->uid))
     return;
 
-  for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list,
+  for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list,
 					      i, ref); i++)
     if (ref->use == IPA_REF_ALIAS)
       {
@@ -1267,7 +1267,7 @@ recursive_inlining (struct cgraph_edge *edge,
   if (node->global.inlined_to)
     node = node->global.inlined_to;
 
-  if (DECL_DECLARED_INLINE_P (node->symbol.decl))
+  if (DECL_DECLARED_INLINE_P (node->decl))
     limit = PARAM_VALUE (PARAM_MAX_INLINE_INSNS_RECURSIVE);
 
   /* Make sure that function is small enough to be considered for inlining.  */
@@ -1316,8 +1316,8 @@ recursive_inlining (struct cgraph_edge *edge,
       depth = 1;
       for (cnode = curr->caller;
 	   cnode->global.inlined_to; cnode = cnode->callers->caller)
-	if (node->symbol.decl
-	    == cgraph_function_or_thunk_node (curr->callee, NULL)->symbol.decl)
+	if (node->decl
+	    == cgraph_function_or_thunk_node (curr->callee, NULL)->decl)
           depth++;
 
       if (!want_inline_self_recursive_call_p (curr, node, false, depth))
@@ -1341,7 +1341,7 @@ recursive_inlining (struct cgraph_edge *edge,
       if (!master_clone)
 	{
 	  /* We need original clone to copy around.  */
-	  master_clone = cgraph_clone_node (node, node->symbol.decl,
+	  master_clone = cgraph_clone_node (node, node->decl,
 					    node->count, CGRAPH_FREQ_BASE,
 					    false, vNULL, true, NULL);
 	  for (e = master_clone->callees; e; e = e->next_callee)
@@ -1453,7 +1453,7 @@ speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining)
      else we propagate is useless.  */
   if (avail >= AVAIL_AVAILABLE)
     {
-      int ecf_flags = flags_from_decl_or_type (target->symbol.decl);
+      int ecf_flags = flags_from_decl_or_type (target->decl);
       if (ecf_flags & ECF_CONST)
         {
           cgraph_speculative_call_info (e, direct, indirect, ref);
@@ -1543,9 +1543,9 @@ inline_small_functions (void)
 	    || node->thunk.thunk_p)
 	  {
 	    struct inline_summary *info = inline_summary (node);
-	    struct ipa_dfs_info *dfs = (struct ipa_dfs_info *) node->symbol.aux;
+	    struct ipa_dfs_info *dfs = (struct ipa_dfs_info *) node->aux;
 
-	    if (!DECL_EXTERNAL (node->symbol.decl))
+	    if (!DECL_EXTERNAL (node->decl))
 	      initial_size += info->size;
 	    info->growth = estimate_growth (node);
 	    if (dfs && dfs->next_cycle)
@@ -1553,7 +1553,7 @@ inline_small_functions (void)
 		struct cgraph_node *n2;
 		int id = dfs->scc_no + 1;
 		for (n2 = node; n2;
-		     n2 = ((struct ipa_dfs_info *) node->symbol.aux)->next_cycle)
+		     n2 = ((struct ipa_dfs_info *) node->aux)->next_cycle)
 		  {
 		    struct inline_summary *info2 = inline_summary (n2);
 		    if (info2->scc_no)
@@ -1591,7 +1591,7 @@ inline_small_functions (void)
 
       if (dump_file)
 	fprintf (dump_file, "Enqueueing calls in %s/%i.\n",
-		 cgraph_node_name (node), node->symbol.order);
+		 cgraph_node_name (node), node->order);
 
       for (edge = node->callees; edge; edge = next)
 	{
@@ -1674,13 +1674,13 @@ inline_small_functions (void)
 	{
 	  fprintf (dump_file,
 		   "\nConsidering %s/%i with %i size\n",
-		   cgraph_node_name (callee), callee->symbol.order,
+		   cgraph_node_name (callee), callee->order,
 		   inline_summary (callee)->size);
 	  fprintf (dump_file,
 		   " to be inlined into %s/%i in %s:%i\n"
 		   " Estimated growth after inlined into all is %+i insns.\n"
 		   " Estimated badness is %i, frequency %.2f.\n",
-		   cgraph_node_name (edge->caller), edge->caller->symbol.order,
+		   cgraph_node_name (edge->caller), edge->caller->order,
 		   flag_wpa ? "unknown"
 		   : gimple_filename ((const_gimple) edge->call_stmt),
 		   flag_wpa ? -1
@@ -1696,7 +1696,7 @@ inline_small_functions (void)
 	}
 
       if (overall_size + growth > max_size
-	  && !DECL_DISREGARD_INLINE_LIMITS (callee->symbol.decl))
+	  && !DECL_DISREGARD_INLINE_LIMITS (callee->decl))
 	{
 	  edge->inline_failed = CIF_INLINE_UNIT_GROWTH_LIMIT;
 	  report_inline_failed_reason (edge);
@@ -1748,7 +1748,7 @@ inline_small_functions (void)
 	  where = edge->caller;
 	  while (where->global.inlined_to)
 	    {
-	      if (where->symbol.decl == callee->symbol.decl)
+	      if (where->decl == callee->decl)
 		outer_node = where, depth++;
 	      where = where->callers->caller;
 	    }
@@ -1757,7 +1757,7 @@ inline_small_functions (void)
 						     true, depth))
 	    {
 	      edge->inline_failed
-		= (DECL_DISREGARD_INLINE_LIMITS (edge->callee->symbol.decl)
+		= (DECL_DISREGARD_INLINE_LIMITS (edge->callee->decl)
 		   ? CIF_RECURSIVE_INLINING : CIF_UNSPECIFIED);
 	      resolve_noninline_speculation (edge_heap, edge);
 	      continue;
@@ -1829,9 +1829,9 @@ flatten_function (struct cgraph_node *node, bool early)
   struct cgraph_edge *e;
 
   /* We shouldn't be called recursively when we are being processed.  */
-  gcc_assert (node->symbol.aux == NULL);
+  gcc_assert (node->aux == NULL);
 
-  node->symbol.aux = (void *) node;
+  node->aux = (void *) node;
 
   for (e = node->callees; e; e = e->next_callee)
     {
@@ -1839,7 +1839,7 @@ flatten_function (struct cgraph_node *node, bool early)
       struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
 
       /* We've hit cycle?  It is time to give up.  */
-      if (callee->symbol.aux)
+      if (callee->aux)
 	{
 	  if (dump_file)
 	    fprintf (dump_file,
@@ -1873,8 +1873,8 @@ flatten_function (struct cgraph_node *node, bool early)
 	  continue;
 	}
 
-      if (gimple_in_ssa_p (DECL_STRUCT_FUNCTION (node->symbol.decl))
-	  != gimple_in_ssa_p (DECL_STRUCT_FUNCTION (callee->symbol.decl)))
+      if (gimple_in_ssa_p (DECL_STRUCT_FUNCTION (node->decl))
+	  != gimple_in_ssa_p (DECL_STRUCT_FUNCTION (callee->decl)))
 	{
 	  if (dump_file)
 	    fprintf (dump_file, "Not inlining: SSA form does not match.\n");
@@ -1890,13 +1890,13 @@ flatten_function (struct cgraph_node *node, bool early)
       orig_callee = callee;
       inline_call (e, true, NULL, NULL, false);
       if (e->callee != orig_callee)
-	orig_callee->symbol.aux = (void *) node;
+	orig_callee->aux = (void *) node;
       flatten_function (e->callee, early);
       if (e->callee != orig_callee)
-	orig_callee->symbol.aux = NULL;
+	orig_callee->aux = NULL;
     }
 
-  node->symbol.aux = NULL;
+  node->aux = NULL;
   if (!node->global.inlined_to)
     inline_update_overall_summary (node);
 }
@@ -1981,7 +1981,7 @@ ipa_inline (void)
   nnodes = ipa_reverse_postorder (order);
 
   FOR_EACH_FUNCTION (node)
-    node->symbol.aux = 0;
+    node->aux = 0;
 
   if (dump_file)
     fprintf (dump_file, "\nFlattening functions:\n");
@@ -1998,7 +1998,7 @@ ipa_inline (void)
 	 try to flatten itself turning it into a self-recursive
 	 function.  */
       if (lookup_attribute ("flatten",
-			    DECL_ATTRIBUTES (node->symbol.decl)) != NULL)
+			    DECL_ATTRIBUTES (node->decl)) != NULL)
 	{
 	  if (dump_file)
 	    fprintf (dump_file,
@@ -2103,7 +2103,7 @@ inline_always_inline_functions (struct cgraph_node *node)
   for (e = node->callees; e; e = e->next_callee)
     {
       struct cgraph_node *callee = cgraph_function_or_thunk_node (e->callee, NULL);
-      if (!DECL_DISREGARD_INLINE_LIMITS (callee->symbol.decl))
+      if (!DECL_DISREGARD_INLINE_LIMITS (callee->decl))
 	continue;
 
       if (cgraph_edge_recursive_p (e))
@@ -2121,7 +2121,7 @@ inline_always_inline_functions (struct cgraph_node *node)
 	     is not inlinable.  This will allow flagging an error later in
 	     expand_call_inline in tree-inline.c.  */
 	  if (lookup_attribute ("always_inline",
-				 DECL_ATTRIBUTES (callee->symbol.decl)) != NULL)
+				 DECL_ATTRIBUTES (callee->decl)) != NULL)
 	    inlined = true;
 	  continue;
 	}
@@ -2156,7 +2156,7 @@ early_inline_small_functions (struct cgraph_node *node)
 	continue;
 
       /* Do not consider functions not declared inline.  */
-      if (!DECL_DECLARED_INLINE_P (callee->symbol.decl)
+      if (!DECL_DECLARED_INLINE_P (callee->decl)
 	  && !flag_inline_small_functions
 	  && !flag_inline_functions)
 	continue;
@@ -2216,7 +2216,7 @@ early_inliner (void)
 #ifdef ENABLE_CHECKING
   verify_cgraph_node (node);
 #endif
-  ipa_remove_all_references (&node->symbol.ref_list);
+  ipa_remove_all_references (&node->ref_list);
 
   /* Even when not optimizing or not inlining inline always-inline
      functions.  */
@@ -2233,10 +2233,10 @@ early_inliner (void)
 	 cycles of edges to be always inlined in the callgraph.
 
 	 We might want to be smarter and just avoid this type of inlining.  */
-      || DECL_DISREGARD_INLINE_LIMITS (node->symbol.decl))
+      || DECL_DISREGARD_INLINE_LIMITS (node->decl))
     ;
   else if (lookup_attribute ("flatten",
-			     DECL_ATTRIBUTES (node->symbol.decl)) != NULL)
+			     DECL_ATTRIBUTES (node->decl)) != NULL)
     {
       /* When the function is marked to be flattened, recursively inline
 	 all calls in it.  */
@@ -2267,9 +2267,9 @@ early_inliner (void)
 		= estimate_num_insns (edge->call_stmt, &eni_size_weights);
 	      es->call_stmt_time
 		= estimate_num_insns (edge->call_stmt, &eni_time_weights);
-	      if (edge->callee->symbol.decl
+	      if (edge->callee->decl
 		  && !gimple_check_call_matching_types (
-		      edge->call_stmt, edge->callee->symbol.decl, false))
+		      edge->call_stmt, edge->callee->decl, false))
 		edge->call_stmt_cannot_inline_p = true;
 	    }
 	  timevar_pop (TV_INTEGRATION);
diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c
index cb42c8f..1c90f41 100644
--- a/gcc/ipa-profile.c
+++ b/gcc/ipa-profile.c
@@ -157,7 +157,7 @@ ipa_profile_generate_summary (void)
 				      10);
   
   FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
-    FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (node->symbol.decl))
+    FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl))
       {
 	int time = 0;
 	int size = 0;
@@ -169,7 +169,7 @@ ipa_profile_generate_summary (void)
 	      {
 		histogram_value h;
 		h = gimple_histogram_value_of_type
-		      (DECL_STRUCT_FUNCTION (node->symbol.decl),
+		      (DECL_STRUCT_FUNCTION (node->decl),
 		       stmt, HIST_TYPE_INDIR_CALL);
 		/* No need to do sanity check: gimple_ic_transform already
 		   takes away bad histograms.  */
@@ -191,7 +191,7 @@ ipa_profile_generate_summary (void)
 			    e->indirect_info->common_target_probability = REG_BR_PROB_BASE;
 			  }
 		      }
-		    gimple_remove_histogram_value (DECL_STRUCT_FUNCTION (node->symbol.decl),
+		    gimple_remove_histogram_value (DECL_STRUCT_FUNCTION (node->decl),
 						    stmt, h);
 		  }
 	      }
@@ -297,7 +297,7 @@ ipa_propagate_frequency_1 (struct cgraph_node *node, void *data)
 	  /* It makes sense to put main() together with the static constructors.
 	     It will be executed for sure, but rest of functions called from
 	     main are definitely not at startup only.  */
-	  if (MAIN_NAME_P (DECL_NAME (edge->caller->symbol.decl)))
+	  if (MAIN_NAME_P (DECL_NAME (edge->caller->decl)))
 	    d->only_called_at_startup = 0;
           d->only_called_at_exit &= edge->caller->only_called_at_exit;
 	}
@@ -343,9 +343,9 @@ ipa_propagate_frequency (struct cgraph_node *node)
   /* We can not propagate anything useful about externally visible functions
      nor about virtuals.  */
   if (!node->local.local
-      || (flag_devirtualize && DECL_VIRTUAL_P (node->symbol.decl)))
+      || (flag_devirtualize && DECL_VIRTUAL_P (node->decl)))
     return false;
-  gcc_assert (node->symbol.analyzed);
+  gcc_assert (node->analyzed);
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "Processing frequency %s\n", cgraph_node_name (node));
 
@@ -500,8 +500,8 @@ ipa_profile (void)
 		    {
 		      fprintf (dump_file, "Indirect call -> direct call from"
 			       " other module %s/%i => %s/%i, prob %3.2f\n",
-			       xstrdup (cgraph_node_name (n)), n->symbol.order,
-			       xstrdup (cgraph_node_name (n2)), n2->symbol.order,
+			       xstrdup (cgraph_node_name (n)), n->order,
+			       xstrdup (cgraph_node_name (n2)), n2->order,
 			       e->indirect_info->common_target_probability
 			       / (float)REG_BR_PROB_BASE);
 		    }
@@ -522,7 +522,7 @@ ipa_profile (void)
 		    }
 		  else if (cgraph_function_body_availability (n2)
 			   <= AVAIL_OVERWRITABLE
-			   && symtab_can_be_discarded ((symtab_node) n2))
+			   && symtab_can_be_discarded (n2))
 		    {
 		      nuseless++;
 		      if (dump_file)
@@ -536,8 +536,8 @@ ipa_profile (void)
 			 control flow goes to this particular implementation
 			 of N2.  Speculate on the local alias to allow inlining.
 		       */
-		      if (!symtab_can_be_discarded ((symtab_node) n2))
-			n2 = cgraph (symtab_nonoverwritable_alias ((symtab_node)n2));
+		      if (!symtab_can_be_discarded (n2))
+			n2 = cgraph (symtab_nonoverwritable_alias (n2));
 		      nconverted++;
 		      cgraph_turn_edge_to_speculative
 			(e, n2,
@@ -582,13 +582,13 @@ ipa_profile (void)
       if (order[i]->local.local && ipa_propagate_frequency (order[i]))
 	{
 	  for (e = order[i]->callees; e; e = e->next_callee)
-	    if (e->callee->local.local && !e->callee->symbol.aux)
+	    if (e->callee->local.local && !e->callee->aux)
 	      {
 	        something_changed = true;
-	        e->callee->symbol.aux = (void *)1;
+	        e->callee->aux = (void *)1;
 	      }
 	}
-      order[i]->symbol.aux = NULL;
+      order[i]->aux = NULL;
     }
 
   while (something_changed)
@@ -596,16 +596,16 @@ ipa_profile (void)
       something_changed = false;
       for (i = order_pos - 1; i >= 0; i--)
 	{
-	  if (order[i]->symbol.aux && ipa_propagate_frequency (order[i]))
+	  if (order[i]->aux && ipa_propagate_frequency (order[i]))
 	    {
 	      for (e = order[i]->callees; e; e = e->next_callee)
-		if (e->callee->local.local && !e->callee->symbol.aux)
+		if (e->callee->local.local && !e->callee->aux)
 		  {
 		    something_changed = true;
-		    e->callee->symbol.aux = (void *)1;
+		    e->callee->aux = (void *)1;
 		  }
 	    }
-	  order[i]->symbol.aux = NULL;
+	  order[i]->aux = NULL;
 	}
     }
   free (order);
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index f9f8e2d..e95f393 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -84,7 +84,7 @@ static alloc_pool ipa_refdesc_pool;
 static bool
 ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node *node)
 {
-  tree fs_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node->symbol.decl);
+  tree fs_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node->decl);
   struct cl_optimization *os;
 
   if (!fs_opts)
@@ -130,7 +130,7 @@ ipa_populate_param_decls (struct cgraph_node *node,
   tree parm;
   int param_num;
 
-  fndecl = node->symbol.decl;
+  fndecl = node->decl;
   gcc_assert (gimple_has_body_p (fndecl));
   fnargs = DECL_ARGUMENTS (fndecl);
   param_num = 0;
@@ -195,7 +195,7 @@ ipa_initialize_node_params (struct cgraph_node *node)
 
   if (!info->descriptors.exists ())
     {
-      ipa_alloc_node_params (node, count_formal_params (node->symbol.decl));
+      ipa_alloc_node_params (node, count_formal_params (node->decl));
       ipa_populate_param_decls (node, info->descriptors);
     }
 }
@@ -310,16 +310,16 @@ ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
   struct cgraph_edge *cs;
 
   fprintf (f, "  Jump functions of caller  %s/%i:\n", cgraph_node_name (node),
-	   node->symbol.order);
+	   node->order);
   for (cs = node->callees; cs; cs = cs->next_callee)
     {
       if (!ipa_edge_args_info_available_for_edge_p (cs))
 	continue;
 
       fprintf (f, "    callsite  %s/%i -> %s/%i : \n",
-	       xstrdup (cgraph_node_name (node)), node->symbol.order,
+	       xstrdup (cgraph_node_name (node)), node->order,
 	       xstrdup (cgraph_node_name (cs->callee)),
-	       cs->callee->symbol.order);
+	       cs->callee->order);
       ipa_print_node_jump_functions_for_edge (f, cs);
     }
 
@@ -1508,7 +1508,7 @@ ipa_get_callee_param_type (struct cgraph_edge *e, int i)
 {
   int n;
   tree type = (e->callee
-	       ? TREE_TYPE (e->callee->symbol.decl)
+	       ? TREE_TYPE (e->callee->decl)
 	       : gimple_call_fntype (e->call_stmt));
   tree t = TYPE_ARG_TYPES (type);
 
@@ -1522,7 +1522,7 @@ ipa_get_callee_param_type (struct cgraph_edge *e, int i)
     return TREE_VALUE (t);
   if (!e->callee)
     return NULL;
-  t = DECL_ARGUMENTS (e->callee->symbol.decl);
+  t = DECL_ARGUMENTS (e->callee->decl);
   for (n = 0; n < i; n++)
     {
       if (!t)
@@ -1640,7 +1640,7 @@ ipa_compute_jump_functions (struct cgraph_node *node,
 								  NULL);
       /* We do not need to bother analyzing calls to unknown
 	 functions unless they may become known during lto/whopr.  */
-      if (!callee->symbol.definition && !flag_lto)
+      if (!callee->definition && !flag_lto)
 	continue;
       ipa_compute_jump_functions_for_edge (parms_ainfo, cs);
     }
@@ -2049,7 +2049,7 @@ static void
 ipa_analyze_params_uses (struct cgraph_node *node,
 			 struct param_analysis_info *parms_ainfo)
 {
-  tree decl = node->symbol.decl;
+  tree decl = node->decl;
   basic_block bb;
   struct function *func;
   gimple_stmt_iterator gsi;
@@ -2079,7 +2079,7 @@ ipa_analyze_params_uses (struct cgraph_node *node,
 	 the flag during modification analysis.  */
       if (is_gimple_reg (parm))
 	{
-	  tree ddef = ssa_default_def (DECL_STRUCT_FUNCTION (node->symbol.decl),
+	  tree ddef = ssa_default_def (DECL_STRUCT_FUNCTION (node->decl),
 				       parm);
 	  if (ddef && !has_zero_uses (ddef))
 	    {
@@ -2158,7 +2158,7 @@ ipa_analyze_node (struct cgraph_node *node)
   ipa_check_create_node_params ();
   ipa_check_create_edge_args ();
   info = IPA_NODE_REF (node);
-  push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
+  push_cfun (DECL_STRUCT_FUNCTION (node->decl));
   ipa_initialize_node_params (node);
 
   param_count = ipa_get_param_count (info);
@@ -2406,7 +2406,7 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
 	  if (dump_file)
 	    fprintf (dump_file, "ipa-prop: Discovered direct call to non-function"
 				" in %s/%i, making it unreachable.\n",
-		     cgraph_node_name (ie->caller), ie->caller->symbol.order);
+		     cgraph_node_name (ie->caller), ie->caller->order);
 	  target = builtin_decl_implicit (BUILT_IN_UNREACHABLE);
 	  callee = cgraph_get_create_node (target);
 	  unreachable = true;
@@ -2433,9 +2433,9 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
 	    fprintf (dump_file, "ipa-prop: Discovered call to a known target "
 		     "(%s/%i -> %s/%i) but can not refer to it. Giving up.\n",
 		     xstrdup (cgraph_node_name (ie->caller)),
-		     ie->caller->symbol.order,
+		     ie->caller->order,
 		     xstrdup (cgraph_node_name (ie->callee)),
-		     ie->callee->symbol.order);
+		     ie->callee->order);
 	  return NULL;
 	}
       callee = cgraph_get_create_real_symbol_node (target);
@@ -2452,9 +2452,9 @@ ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target)
 	       "(%s/%i -> %s/%i), for stmt ",
 	       ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
 	       xstrdup (cgraph_node_name (ie->caller)),
-	       ie->caller->symbol.order,
+	       ie->caller->order,
 	       xstrdup (cgraph_node_name (callee)),
-	       callee->symbol.order);
+	       callee->order);
       if (ie->call_stmt)
 	print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
       else
@@ -2506,7 +2506,7 @@ remove_described_reference (symtab_node symbol, struct ipa_cst_ref_desc *rdesc)
   struct cgraph_edge *origin;
 
   origin = rdesc->cs;
-  to_del = ipa_find_reference ((symtab_node) origin->caller, symbol,
+  to_del = ipa_find_reference (origin->caller, symbol,
 			       origin->call_stmt, origin->lto_stmt_uid);
   if (!to_del)
     return false;
@@ -2515,7 +2515,7 @@ remove_described_reference (symtab_node symbol, struct ipa_cst_ref_desc *rdesc)
   if (dump_file)
     fprintf (dump_file, "ipa-prop: Removed a reference from %s/%i to %s.\n",
 	     xstrdup (cgraph_node_name (origin->caller)),
-	     origin->caller->symbol.order, xstrdup (symtab_node_name (symbol)));
+	     origin->caller->order, xstrdup (symtab_node_name (symbol)));
   return true;
 }
 
@@ -2563,7 +2563,7 @@ try_decrement_rdesc_refcount (struct ipa_jump_func *jfunc)
       && (rdesc = jfunc_rdesc_usable (jfunc))
       && --rdesc->refcount == 0)
     {
-      symtab_node symbol = (symtab_node) cgraph_node_for_jfunc (jfunc);
+      symtab_node symbol = cgraph_node_for_jfunc (jfunc);
       if (!symbol)
 	return false;
 
@@ -2718,7 +2718,7 @@ update_indirect_edges_after_inlining (struct cgraph_edge *cs,
 	    new_direct_edge->call_stmt_cannot_inline_p
 	      = !gimple_check_call_matching_types (
 		  new_direct_edge->call_stmt,
-		  new_direct_edge->callee->symbol.decl, false);
+		  new_direct_edge->callee->decl, false);
 	  if (new_edges)
 	    {
 	      new_edges->safe_push (new_direct_edge);
@@ -2834,15 +2834,15 @@ propagate_controlled_uses (struct cgraph_edge *cs)
 	      if (t && TREE_CODE (t) == ADDR_EXPR
 		  && TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
 		  && (n = cgraph_get_node (TREE_OPERAND (t, 0)))
-		  && (ref = ipa_find_reference ((symtab_node) new_root,
-						(symtab_node) n, NULL, 0)))
+		  && (ref = ipa_find_reference (new_root,
+						n, NULL, 0)))
 		{
 		  if (dump_file)
 		    fprintf (dump_file, "ipa-prop: Removing cloning-created "
 			     "reference from %s/%i to %s/%i.\n",
 			     xstrdup (cgraph_node_name (new_root)),
-			     new_root->symbol.order,
-			     xstrdup (cgraph_node_name (n)), n->symbol.order);
+			     new_root->order,
+			     xstrdup (cgraph_node_name (n)), n->order);
 		  ipa_remove_reference (ref);
 		}
 	    }
@@ -2865,7 +2865,7 @@ propagate_controlled_uses (struct cgraph_edge *cs)
 		{
 		  struct cgraph_node *clone;
 		  bool ok;
-		  ok = remove_described_reference ((symtab_node) n, rdesc);
+		  ok = remove_described_reference (n, rdesc);
 		  gcc_checking_assert (ok);
 
 		  clone = cs->caller;
@@ -2874,8 +2874,8 @@ propagate_controlled_uses (struct cgraph_edge *cs)
 			 && IPA_NODE_REF (clone)->ipcp_orig_node)
 		    {
 		      struct ipa_ref *ref;
-		      ref = ipa_find_reference ((symtab_node) clone,
-						(symtab_node) n, NULL, 0);
+		      ref = ipa_find_reference (clone,
+						n, NULL, 0);
 		      if (ref)
 			{
 			  if (dump_file)
@@ -2883,9 +2883,9 @@ propagate_controlled_uses (struct cgraph_edge *cs)
 				     "cloning-created reference "
 				     "from %s/%i to %s/%i.\n",
 				     xstrdup (cgraph_node_name (clone)),
-				     clone->symbol.order,
+				     clone->order,
 				     xstrdup (cgraph_node_name (n)),
-				     n->symbol.order);
+				     n->order);
 			  ipa_remove_reference (ref);
 			}
 		      clone = clone->callers->caller;
@@ -3071,12 +3071,12 @@ ipa_edge_duplication_hook (struct cgraph_edge *src, struct cgraph_edge *dst,
 	  else if (src->caller == dst->caller)
 	    {
 	      struct ipa_ref *ref;
-	      symtab_node n = (symtab_node) cgraph_node_for_jfunc (src_jf);
+	      symtab_node n = cgraph_node_for_jfunc (src_jf);
 	      gcc_checking_assert (n);
-	      ref = ipa_find_reference ((symtab_node) src->caller, n,
+	      ref = ipa_find_reference (src->caller, n,
 					src->call_stmt, src->lto_stmt_uid);
 	      gcc_checking_assert (ref);
-	      ipa_clone_ref (ref, (symtab_node) dst->caller, ref->stmt);
+	      ipa_clone_ref (ref, dst->caller, ref->stmt);
 
 	      gcc_checking_assert (ipa_refdesc_pool);
 	      struct ipa_cst_ref_desc *dst_rdesc
@@ -3257,11 +3257,11 @@ ipa_print_node_params (FILE *f, struct cgraph_node *node)
   int i, count;
   struct ipa_node_params *info;
 
-  if (!node->symbol.definition)
+  if (!node->definition)
     return;
   info = IPA_NODE_REF (node);
   fprintf (f, "  function  %s/%i parameter descriptors:\n",
-	   cgraph_node_name (node), node->symbol.order);
+	   cgraph_node_name (node), node->order);
   count = ipa_get_param_count (info);
   for (i = 0; i < count; i++)
     {
@@ -3504,8 +3504,8 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gimple stmt,
 
   len = adjustments.length ();
   vargs.create (len);
-  callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->symbol.decl;
-  ipa_remove_stmt_references ((symtab_node) current_node, stmt);
+  callee_decl = !cs ? gimple_call_fndecl (stmt) : cs->callee->decl;
+  ipa_remove_stmt_references (current_node, stmt);
 
   gsi = gsi_for_stmt (stmt);
   prev_gsi = gsi;
@@ -4097,7 +4097,7 @@ ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
   struct bitpack_d bp;
 
   encoder = ob->decl_state->symtab_node_encoder;
-  node_ref = lto_symtab_encoder_encode (encoder, (symtab_node) node);
+  node_ref = lto_symtab_encoder_encode (encoder, node);
   streamer_write_uhwi (ob, node_ref);
 
   streamer_write_uhwi (ob, ipa_get_param_count (info));
@@ -4261,7 +4261,7 @@ ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
       index = streamer_read_uhwi (&ib_main);
       encoder = file_data->symtab_node_encoder;
       node = cgraph (lto_symtab_encoder_deref (encoder, index));
-      gcc_assert (node->symbol.definition);
+      gcc_assert (node->definition);
       ipa_read_node_info (&ib_main, node, data_in);
     }
   lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
@@ -4313,7 +4313,7 @@ write_agg_replacement_chain (struct output_block *ob, struct cgraph_node *node)
 
   aggvals = ipa_get_agg_replacements_for_node (node);
   encoder = ob->decl_state->symtab_node_encoder;
-  node_ref = lto_symtab_encoder_encode (encoder, (symtab_node) node);
+  node_ref = lto_symtab_encoder_encode (encoder, node);
   streamer_write_uhwi (ob, node_ref);
 
   for (av = aggvals; av; av = av->next)
@@ -4437,7 +4437,7 @@ read_replacements_section (struct lto_file_decl_data *file_data,
       index = streamer_read_uhwi (&ib_main);
       encoder = file_data->symtab_node_encoder;
       node = cgraph (lto_symtab_encoder_deref (encoder, index));
-      gcc_assert (node->symbol.definition);
+      gcc_assert (node->definition);
       read_agg_replacement_chain (&ib_main, node, data_in);
     }
   lto_free_section_data (file_data, LTO_section_jump_functions, NULL, data,
@@ -4519,12 +4519,12 @@ ipcp_transform_function (struct cgraph_node *node)
 
   if (dump_file)
     fprintf (dump_file, "Modification phase of node %s/%i\n",
-	     cgraph_node_name (node), node->symbol.order);
+	     cgraph_node_name (node), node->order);
 
   aggval = ipa_get_agg_replacements_for_node (node);
   if (!aggval)
       return 0;
-  param_count = count_formal_params (node->symbol.decl);
+  param_count = count_formal_params (node->decl);
   if (param_count == 0)
     return 0;
   adjust_agg_replacement_values (node, aggval);
diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c
index ed4deae..721272f 100644
--- a/gcc/ipa-pure-const.c
+++ b/gcc/ipa-pure-const.c
@@ -725,7 +725,7 @@ check_stmt (gimple_stmt_iterator *gsip, funct_state local, bool ipa)
 static funct_state
 analyze_function (struct cgraph_node *fn, bool ipa)
 {
-  tree decl = fn->symbol.decl;
+  tree decl = fn->decl;
   funct_state l;
   basic_block this_block;
 
@@ -736,10 +736,10 @@ analyze_function (struct cgraph_node *fn, bool ipa)
   l->looping = false;
   l->can_throw = false;
   state_from_flags (&l->state_previously_known, &l->looping_previously_known,
-		    flags_from_decl_or_type (fn->symbol.decl),
+		    flags_from_decl_or_type (fn->decl),
 		    cgraph_node_cannot_return (fn));
 
-  if (fn->thunk.thunk_p || fn->symbol.alias)
+  if (fn->thunk.thunk_p || fn->alias)
     {
       /* Thunk gets propagated through, so nothing interesting happens.  */
       gcc_assert (ipa);
@@ -952,7 +952,7 @@ pure_const_write_summary (void)
        lsei_next_function_in_partition (&lsei))
     {
       node = lsei_cgraph_node (lsei);
-      if (node->symbol.definition && has_function_state (node))
+      if (node->definition && has_function_state (node))
 	count++;
     }
 
@@ -963,7 +963,7 @@ pure_const_write_summary (void)
        lsei_next_function_in_partition (&lsei))
     {
       node = lsei_cgraph_node (lsei);
-      if (node->symbol.definition && has_function_state (node))
+      if (node->definition && has_function_state (node))
 	{
 	  struct bitpack_d bp;
 	  funct_state fs;
@@ -973,7 +973,7 @@ pure_const_write_summary (void)
 	  fs = get_function_state (node);
 
 	  encoder = ob->decl_state->symtab_node_encoder;
-	  node_ref = lto_symtab_encoder_encode (encoder, (symtab_node)node);
+	  node_ref = lto_symtab_encoder_encode (encoder, node);
 	  streamer_write_uhwi_stream (ob->main_stream, node_ref);
 
 	  /* Note that flags will need to be read in the opposite
@@ -1042,10 +1042,10 @@ pure_const_read_summary (void)
 	      fs->can_throw = bp_unpack_value (&bp, 1);
 	      if (dump_file)
 		{
-		  int flags = flags_from_decl_or_type (node->symbol.decl);
+		  int flags = flags_from_decl_or_type (node->decl);
 		  fprintf (dump_file, "Read info for %s/%i ",
 			   cgraph_node_name (node),
-			   node->symbol.order);
+			   node->order);
 		  if (flags & ECF_CONST)
 		    fprintf (dump_file, " const");
 		  if (flags & ECF_PURE)
@@ -1126,7 +1126,7 @@ propagate_pure_const (void)
       int count = 0;
       node = order[i];
 
-      if (node->symbol.alias)
+      if (node->alias)
 	continue;
 
       if (dump_file && (dump_flags & TDF_DETAILS))
@@ -1145,7 +1145,7 @@ propagate_pure_const (void)
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    fprintf (dump_file, "  Visiting %s/%i state:%s looping %i\n",
 		     cgraph_node_name (w),
-		     w->symbol.order,
+		     w->order,
 		     pure_const_names[w_l->pure_const_state],
 		     w_l->looping);
 
@@ -1192,7 +1192,7 @@ propagate_pure_const (void)
 		  fprintf (dump_file,
 			   "    Call to %s/%i",
 			   cgraph_node_name (e->callee),
-			   e->callee->symbol.order);
+			   e->callee->order);
 		}
 	      if (avail > AVAIL_OVERWRITABLE)
 		{
@@ -1221,11 +1221,11 @@ propagate_pure_const (void)
 		    }
 		}
 	      else if (special_builtin_state (&edge_state, &edge_looping,
-					       y->symbol.decl))
+					       y->decl))
 		;
 	      else
 		state_from_flags (&edge_state, &edge_looping,
-				  flags_from_decl_or_type (y->symbol.decl),
+				  flags_from_decl_or_type (y->decl),
 				  cgraph_edge_cannot_lead_to_return (e));
 
 	      /* Merge the results with what we already know.  */
@@ -1264,7 +1264,7 @@ propagate_pure_const (void)
 	    break;
 
 	  /* And finally all loads and stores.  */
-	  for (i = 0; ipa_ref_list_reference_iterate (&w->symbol.ref_list, i, ref); i++)
+	  for (i = 0; ipa_ref_list_reference_iterate (&w->ref_list, i, ref); i++)
 	    {
 	      enum pure_const_state_e ref_state = IPA_CONST;
 	      bool ref_looping = false;
@@ -1272,7 +1272,7 @@ propagate_pure_const (void)
 		{
 		case IPA_REF_LOAD:
 		  /* readonly reads are safe.  */
-		  if (TREE_READONLY (ipa_ref_varpool_node (ref)->symbol.decl))
+		  if (TREE_READONLY (ipa_ref_varpool_node (ref)->decl))
 		    break;
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    fprintf (dump_file, "    nonreadonly global var read\n");
@@ -1296,7 +1296,7 @@ propagate_pure_const (void)
 	      if (pure_const_state == IPA_NEITHER)
 		break;
 	    }
-	  w_info = (struct ipa_dfs_info *) w->symbol.aux;
+	  w_info = (struct ipa_dfs_info *) w->aux;
 	  w = w_info->next_cycle;
 	}
       if (dump_file && (dump_flags & TDF_DETAILS))
@@ -1331,9 +1331,9 @@ propagate_pure_const (void)
 	  switch (this_state)
 	    {
 	    case IPA_CONST:
-	      if (!TREE_READONLY (w->symbol.decl))
+	      if (!TREE_READONLY (w->decl))
 		{
-		  warn_function_const (w->symbol.decl, !this_looping);
+		  warn_function_const (w->decl, !this_looping);
 		  if (dump_file)
 		    fprintf (dump_file, "Function found to be %sconst: %s\n",
 			     this_looping ? "looping " : "",
@@ -1343,9 +1343,9 @@ propagate_pure_const (void)
 	      break;
 
 	    case IPA_PURE:
-	      if (!DECL_PURE_P (w->symbol.decl))
+	      if (!DECL_PURE_P (w->decl))
 		{
-		  warn_function_pure (w->symbol.decl, !this_looping);
+		  warn_function_pure (w->decl, !this_looping);
 		  if (dump_file)
 		    fprintf (dump_file, "Function found to be %spure: %s\n",
 			     this_looping ? "looping " : "",
@@ -1357,7 +1357,7 @@ propagate_pure_const (void)
 	    default:
 	      break;
 	    }
-	  w_info = (struct ipa_dfs_info *) w->symbol.aux;
+	  w_info = (struct ipa_dfs_info *) w->aux;
 	  w = w_info->next_cycle;
 	}
     }
@@ -1396,7 +1396,7 @@ propagate_nothrow (void)
       bool can_throw = false;
       node = order[i];
 
-      if (node->symbol.alias)
+      if (node->alias)
 	continue;
 
       /* Find the worst state for any node in the cycle.  */
@@ -1424,11 +1424,11 @@ propagate_nothrow (void)
 
 		  if (can_throw)
 		    break;
-		  if (y_l->can_throw && !TREE_NOTHROW (w->symbol.decl)
+		  if (y_l->can_throw && !TREE_NOTHROW (w->decl)
 		      && e->can_throw_external)
 		    can_throw = true;
 		}
-	      else if (e->can_throw_external && !TREE_NOTHROW (y->symbol.decl))
+	      else if (e->can_throw_external && !TREE_NOTHROW (y->decl))
 	        can_throw = true;
 	    }
           for (ie = node->indirect_calls; ie; ie = ie->next_callee)
@@ -1437,7 +1437,7 @@ propagate_nothrow (void)
 		can_throw = true;
 		break;
 	      }
-	  w_info = (struct ipa_dfs_info *) w->symbol.aux;
+	  w_info = (struct ipa_dfs_info *) w->aux;
 	  w = w_info->next_cycle;
 	}
 
@@ -1447,16 +1447,16 @@ propagate_nothrow (void)
       while (w)
 	{
 	  funct_state w_l = get_function_state (w);
-	  if (!can_throw && !TREE_NOTHROW (w->symbol.decl))
+	  if (!can_throw && !TREE_NOTHROW (w->decl))
 	    {
 	      cgraph_set_nothrow_flag (w, true);
 	      if (dump_file)
 		fprintf (dump_file, "Function found to be nothrow: %s\n",
 			 cgraph_node_name (w));
 	    }
-	  else if (can_throw && !TREE_NOTHROW (w->symbol.decl))
+	  else if (can_throw && !TREE_NOTHROW (w->decl))
 	    w_l->can_throw = true;
-	  w_info = (struct ipa_dfs_info *) w->symbol.aux;
+	  w_info = (struct ipa_dfs_info *) w->aux;
 	  w = w_info->next_cycle;
 	}
     }
diff --git a/gcc/ipa-ref-inline.h b/gcc/ipa-ref-inline.h
index bb74f87..4bb43c2 100644
--- a/gcc/ipa-ref-inline.h
+++ b/gcc/ipa-ref-inline.h
@@ -54,7 +54,7 @@ ipa_ref_referring_varpool_node (struct ipa_ref *ref)
 static inline struct ipa_ref_list *
 ipa_ref_referring_ref_list (struct ipa_ref *ref)
 {
-  return &ref->referring->symbol.ref_list;
+  return &ref->referring->ref_list;
 }
 
 /* Return reference list REF is in.  */
@@ -62,7 +62,7 @@ ipa_ref_referring_ref_list (struct ipa_ref *ref)
 static inline struct ipa_ref_list *
 ipa_ref_referred_ref_list (struct ipa_ref *ref)
 {
-  return &ref->referred->symbol.ref_list;
+  return &ref->referred->ref_list;
 }
 
 /* Return first reference in LIST or NULL if empty.  */
diff --git a/gcc/ipa-ref.c b/gcc/ipa-ref.c
index a7c3b40..4f04614e 100644
--- a/gcc/ipa-ref.c
+++ b/gcc/ipa-ref.c
@@ -45,12 +45,12 @@ ipa_record_reference (symtab_node referring_node,
   gcc_checking_assert (!stmt || is_a <cgraph_node> (referring_node));
   gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt);
 
-  list = &referring_node->symbol.ref_list;
+  list = &referring_node->ref_list;
   old_references = vec_safe_address (list->references);
   vec_safe_grow (list->references, vec_safe_length (list->references) + 1);
   ref = &list->references->last ();
 
-  list2 = &referred_node->symbol.ref_list;
+  list2 = &referred_node->ref_list;
   list2->referring.safe_push (ref);
   ref->referred_index = list2->referring.length () - 1;
   ref->referring = referring_node;
@@ -155,7 +155,7 @@ ipa_dump_references (FILE * file, struct ipa_ref_list *list)
     {
       fprintf (file, "%s/%i (%s)",
                symtab_node_asm_name (ref->referred),
-               ref->referred->symbol.order,
+               ref->referred->order,
 	       ipa_ref_use_name [ref->use]);
       if (ref->speculative)
 	fprintf (file, " (speculative)");
@@ -174,7 +174,7 @@ ipa_dump_referring (FILE * file, struct ipa_ref_list *list)
     {
       fprintf (file, "%s/%i (%s)",
                symtab_node_asm_name (ref->referring),
-               ref->referring->symbol.order,
+               ref->referring->order,
 	       ipa_ref_use_name [ref->use]);
       if (ref->speculative)
 	fprintf (file, " (speculative)");
@@ -274,7 +274,7 @@ ipa_find_reference (symtab_node referring_node, symtab_node referred_node,
   struct ipa_ref *r = NULL;
   int i;
 
-  for (i = 0; ipa_ref_list_reference_iterate (&referring_node->symbol.ref_list, i, r); i++)
+  for (i = 0; ipa_ref_list_reference_iterate (&referring_node->ref_list, i, r); i++)
     if (r->referred == referred_node
 	&& !r->speculative
 	&& ((stmt && r->stmt == stmt)
@@ -293,7 +293,7 @@ ipa_remove_stmt_references (symtab_node referring_node, gimple stmt)
   struct ipa_ref *r = NULL;
   int i;
 
-  for (i = 0; ipa_ref_list_reference_iterate (&referring_node->symbol.ref_list, i, r); i++)
+  for (i = 0; ipa_ref_list_reference_iterate (&referring_node->ref_list, i, r); i++)
     if (r->stmt == stmt)
       ipa_remove_reference (r);
 }
@@ -309,7 +309,7 @@ ipa_clear_stmts_in_references (symtab_node referring_node)
   struct ipa_ref *r = NULL;
   int i;
 
-  for (i = 0; ipa_ref_list_reference_iterate (&referring_node->symbol.ref_list, i, r); i++)
+  for (i = 0; ipa_ref_list_reference_iterate (&referring_node->ref_list, i, r); i++)
     if (!r->speculative)
       {
 	r->stmt = NULL;
diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c
index 3742474..9c54921 100644
--- a/gcc/ipa-reference.c
+++ b/gcc/ipa-reference.c
@@ -180,7 +180,7 @@ ipa_reference_get_not_read_global (struct cgraph_node *fn)
     get_reference_optimization_summary (cgraph_function_node (fn, NULL));
   if (info)
     return info->statics_not_read;
-  else if (flags_from_decl_or_type (fn->symbol.decl) & ECF_LEAF)
+  else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF)
     return all_module_statics;
   else
     return NULL;
@@ -198,7 +198,7 @@ ipa_reference_get_not_written_global (struct cgraph_node *fn)
     get_reference_optimization_summary (fn);
   if (info)
     return info->statics_not_written;
-  else if (flags_from_decl_or_type (fn->symbol.decl) & ECF_LEAF)
+  else if (flags_from_decl_or_type (fn->decl) & ECF_LEAF)
     return all_module_statics;
   else
     return NULL;
@@ -367,7 +367,7 @@ propagate_bits (ipa_reference_global_vars_info_t x_global, struct cgraph_node *x
 	continue;
 
       /* Only look into nodes we can propagate something.  */
-      int flags = flags_from_decl_or_type (y->symbol.decl);
+      int flags = flags_from_decl_or_type (y->decl);
       if (avail > AVAIL_OVERWRITABLE
 	  || (avail == AVAIL_OVERWRITABLE && (flags & ECF_LEAF)))
 	{
@@ -462,11 +462,11 @@ analyze_function (struct cgraph_node *fn)
   tree var;
 
   local = init_function_info (fn);
-  for (i = 0; ipa_ref_list_reference_iterate (&fn->symbol.ref_list, i, ref); i++)
+  for (i = 0; ipa_ref_list_reference_iterate (&fn->ref_list, i, ref); i++)
     {
       if (!is_a <varpool_node> (ref->referred))
 	continue;
-      var = ipa_ref_varpool_node (ref)->symbol.decl;
+      var = ipa_ref_varpool_node (ref)->decl;
       if (!is_proper_for_analysis (var))
 	continue;
       switch (ref->use)
@@ -564,7 +564,7 @@ generate_summary (void)
 	  l = &get_reference_vars_info (node)->local;
 	  fprintf (dump_file,
 		   "\nFunction name:%s/%i:",
-		   cgraph_node_asm_name (node), node->symbol.order);
+		   cgraph_node_asm_name (node), node->order);
 	  fprintf (dump_file, "\n  locals read: ");
 	  if (l->statics_read)
 	    EXECUTE_IF_SET_IN_BITMAP (l->statics_read,
@@ -590,7 +590,7 @@ static void
 read_write_all_from_decl (struct cgraph_node *node,
 			  bool &read_all, bool &write_all)
 {
-  tree decl = node->symbol.decl;
+  tree decl = node->decl;
   int flags = flags_from_decl_or_type (decl);
   if ((flags & ECF_LEAF)
       && cgraph_function_body_availability (node) <= AVAIL_OVERWRITABLE)
@@ -603,7 +603,7 @@ read_write_all_from_decl (struct cgraph_node *node,
       read_all = true;
       if (dump_file && (dump_flags & TDF_DETAILS))
          fprintf (dump_file, "   %s/%i -> read all\n",
-		  cgraph_node_asm_name (node), node->symbol.order);
+		  cgraph_node_asm_name (node), node->order);
     }
   else
     {
@@ -613,7 +613,7 @@ read_write_all_from_decl (struct cgraph_node *node,
       write_all = true;
       if (dump_file && (dump_flags & TDF_DETAILS))
          fprintf (dump_file, "   %s/%i -> read all, write all\n",
-		  cgraph_node_asm_name (node), node->symbol.order);
+		  cgraph_node_asm_name (node), node->order);
     }
 }
 
@@ -680,12 +680,12 @@ propagate (void)
 
   /* Now we know what vars are really statics; prune out those that aren't.  */
   FOR_EACH_VARIABLE (vnode)
-    if (vnode->symbol.externally_visible
-	|| TREE_ADDRESSABLE (vnode->symbol.decl)
-	|| TREE_READONLY (vnode->symbol.decl)
-	|| !is_proper_for_analysis (vnode->symbol.decl)
-	|| !vnode->symbol.definition)
-      bitmap_clear_bit (all_module_statics, DECL_UID (vnode->symbol.decl));
+    if (vnode->externally_visible
+	|| TREE_ADDRESSABLE (vnode->decl)
+	|| TREE_READONLY (vnode->decl)
+	|| !is_proper_for_analysis (vnode->decl)
+	|| !vnode->definition)
+      bitmap_clear_bit (all_module_statics, DECL_UID (vnode->decl));
 
   /* Forget info we collected "just for fun" on variables that turned out to be
      non-local.  */
@@ -716,7 +716,7 @@ propagate (void)
       bool write_all = false;
 
       node = order[i];
-      if (node->symbol.alias)
+      if (node->alias)
 	continue;
 
       node_info = get_reference_vars_info (node);
@@ -726,7 +726,7 @@ propagate (void)
 
       if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "Starting cycle with %s/%i\n",
-		  cgraph_node_asm_name (node), node->symbol.order);
+		  cgraph_node_asm_name (node), node->order);
 
       vec<cgraph_node_ptr> cycle_nodes = ipa_get_nodes_in_cycle (node);
 
@@ -735,7 +735,7 @@ propagate (void)
 	{
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    fprintf (dump_file, "  Visiting %s/%i\n",
-		     cgraph_node_asm_name (w), w->symbol.order);
+		     cgraph_node_asm_name (w), w->order);
 	  get_read_write_all_from_node (w, read_all, write_all);
 	  if (read_all && write_all)
 	    break;
@@ -762,7 +762,7 @@ propagate (void)
 	    {
 	      ipa_reference_vars_info_t w_ri = get_reference_vars_info (w);
 	      ipa_reference_local_vars_info_t w_l = &w_ri->local;
-	      int flags = flags_from_decl_or_type (w->symbol.decl);
+	      int flags = flags_from_decl_or_type (w->decl);
 
 	      if (!(flags & ECF_CONST))
 		read_all = union_static_var_sets (node_g->statics_read,
@@ -794,12 +794,12 @@ propagate (void)
 	  struct cgraph_node *w;
 
 	  node = order[i];
-	  if (node->symbol.alias)
+	  if (node->alias)
 	    continue;
 
 	  fprintf (dump_file,
 		   "\nFunction name:%s/%i:",
-		   cgraph_node_asm_name (node), node->symbol.order);
+		   cgraph_node_asm_name (node), node->order);
 
 	  ipa_reference_vars_info_t node_info = get_reference_vars_info (node);
 	  ipa_reference_global_vars_info_t node_g = &node_info->global;
@@ -811,7 +811,7 @@ propagate (void)
 	      ipa_reference_local_vars_info_t w_l = &w_ri->local;
 	      if (w != node)
 		fprintf (dump_file, "\n  next cycle: %s/%i ",
-			 cgraph_node_asm_name (w), w->symbol.order);
+			 cgraph_node_asm_name (w), w->order);
 	      fprintf (dump_file, "\n    locals read: ");
 	      dump_static_vars_set_to_file (dump_file, w_l->statics_read);
 	      fprintf (dump_file, "\n    locals written: ");
@@ -835,9 +835,9 @@ propagate (void)
       ipa_reference_optimization_summary_t opt;
 
       node_info = get_reference_vars_info (node);
-      if (!node->symbol.alias
+      if (!node->alias
 	  && (cgraph_function_body_availability (node) > AVAIL_OVERWRITABLE
-	      || (flags_from_decl_or_type (node->symbol.decl) & ECF_LEAF)))
+	      || (flags_from_decl_or_type (node->decl) & ECF_LEAF)))
 	{
 	  node_g = &node_info->global;
 
@@ -894,7 +894,7 @@ write_node_summary_p (struct cgraph_node *node,
   ipa_reference_optimization_summary_t info;
 
   /* See if we have (non-empty) info.  */
-  if (!node->symbol.definition || node->global.inlined_to)
+  if (!node->definition || node->global.inlined_to)
     return false;
   info = get_reference_optimization_summary (node);
   if (!info || (bitmap_empty_p (info->statics_not_read)
@@ -908,7 +908,7 @@ write_node_summary_p (struct cgraph_node *node,
      In future we might also want to include summaries of functions references
      by initializers of constant variables references in current unit.  */
   if (!reachable_from_this_partition_p (node, encoder)
-      && !referenced_from_this_partition_p (&node->symbol.ref_list, encoder))
+      && !referenced_from_this_partition_p (&node->ref_list, encoder))
     return false;
 
   /* See if the info has non-empty intersections with vars we want to encode.  */
@@ -974,10 +974,10 @@ ipa_reference_write_optimization_summary (void)
       symtab_node snode = lto_symtab_encoder_deref (encoder, i);
       varpool_node *vnode = dyn_cast <varpool_node> (snode);
       if (vnode
-	  && bitmap_bit_p (all_module_statics, DECL_UID (vnode->symbol.decl))
-	  && referenced_from_this_partition_p (&vnode->symbol.ref_list, encoder))
+	  && bitmap_bit_p (all_module_statics, DECL_UID (vnode->decl))
+	  && referenced_from_this_partition_p (&vnode->ref_list, encoder))
 	{
-	  tree decl = vnode->symbol.decl;
+	  tree decl = vnode->decl;
 	  bitmap_set_bit (ltrans_statics, DECL_UID (decl));
 	  splay_tree_insert (reference_vars_to_consider,
 			     DECL_UID (decl), (splay_tree_value)decl);
@@ -1089,7 +1089,7 @@ ipa_reference_read_optimization_summary (void)
 	      if (dump_file)
 		fprintf (dump_file,
 			 "\nFunction name:%s/%i:\n  static not read:",
-			 cgraph_node_asm_name (node), node->symbol.order);
+			 cgraph_node_asm_name (node), node->order);
 
 	      /* Set the statics not read.  */
 	      v_count = streamer_read_hwi (ib);
diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c
index 5df14ec..2bd45fb 100644
--- a/gcc/ipa-split.c
+++ b/gcc/ipa-split.c
@@ -1217,20 +1217,20 @@ split_function (struct split_point *split_point)
   /* For usual cloning it is enough to clear builtin only when signature
      changes.  For partial inlining we however can not expect the part
      of builtin implementation to have same semantic as the whole.  */
-  if (DECL_BUILT_IN (node->symbol.decl))
+  if (DECL_BUILT_IN (node->decl))
     {
-      DECL_BUILT_IN_CLASS (node->symbol.decl) = NOT_BUILT_IN;
-      DECL_FUNCTION_CODE (node->symbol.decl) = (enum built_in_function) 0;
+      DECL_BUILT_IN_CLASS (node->decl) = NOT_BUILT_IN;
+      DECL_FUNCTION_CODE (node->decl) = (enum built_in_function) 0;
     }
   /* If the original function is declared inline, there is no point in issuing
      a warning for the non-inlinable part.  */
-  DECL_NO_INLINE_WARNING_P (node->symbol.decl) = 1;
+  DECL_NO_INLINE_WARNING_P (node->decl) = 1;
   cgraph_node_remove_callees (cur_node);
-  ipa_remove_all_references (&cur_node->symbol.ref_list);
+  ipa_remove_all_references (&cur_node->ref_list);
   if (!split_part_return_p)
-    TREE_THIS_VOLATILE (node->symbol.decl) = 1;
+    TREE_THIS_VOLATILE (node->decl) = 1;
   if (dump_file)
-    dump_function_to_file (node->symbol.decl, dump_file, dump_flags);
+    dump_function_to_file (node->decl, dump_file, dump_flags);
 
   /* Create the basic block we place call into.  It is the entry basic block
      split after last label.  */
@@ -1255,7 +1255,7 @@ split_function (struct split_point *split_point)
 					false, GSI_CONTINUE_LINKING);
 	args_to_pass[i] = arg;
       }
-  call = gimple_build_call_vec (node->symbol.decl, args_to_pass);
+  call = gimple_build_call_vec (node->decl, args_to_pass);
   gimple_set_block (call, DECL_INITIAL (current_function_decl));
   args_to_pass.release ();
 
@@ -1282,7 +1282,7 @@ split_function (struct split_point *split_point)
 	    continue;
 
 	  if (debug_args == NULL)
-	    debug_args = decl_debug_args_insert (node->symbol.decl);
+	    debug_args = decl_debug_args_insert (node->decl);
 	  ddecl = make_node (DEBUG_EXPR_DECL);
 	  DECL_ARTIFICIAL (ddecl) = 1;
 	  TREE_TYPE (ddecl) = TREE_TYPE (parm);
@@ -1308,8 +1308,8 @@ split_function (struct split_point *split_point)
       gimple_stmt_iterator cgsi;
       gimple def_temp;
 
-      push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
-      var = BLOCK_VARS (DECL_INITIAL (node->symbol.decl));
+      push_cfun (DECL_STRUCT_FUNCTION (node->decl));
+      var = BLOCK_VARS (DECL_INITIAL (node->decl));
       i = vec_safe_length (*debug_args);
       cgsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR));
       do
@@ -1509,7 +1509,7 @@ execute_split_functions (void)
 	fprintf (dump_file, "Not splitting: not inlinable.\n");
       return 0;
     }
-  if (DECL_DISREGARD_INLINE_LIMITS (node->symbol.decl))
+  if (DECL_DISREGARD_INLINE_LIMITS (node->decl))
     {
       if (dump_file)
 	fprintf (dump_file, "Not splitting: disregarding inline limits.\n");
@@ -1543,8 +1543,8 @@ execute_split_functions (void)
   if ((!node->callers
        /* Local functions called once will be completely inlined most of time.  */
        || (!node->callers->next_caller && node->local.local))
-      && !node->symbol.address_taken
-      && (!flag_lto || !node->symbol.externally_visible))
+      && !node->address_taken
+      && (!flag_lto || !node->externally_visible))
     {
       if (dump_file)
 	fprintf (dump_file, "Not splitting: not called directly "
diff --git a/gcc/ipa-utils.c b/gcc/ipa-utils.c
index e2e1690..2a366cf 100644
--- a/gcc/ipa-utils.c
+++ b/gcc/ipa-utils.c
@@ -86,7 +86,7 @@ searchc (struct searchc_env* env, struct cgraph_node *v,
 	 bool (*ignore_edge) (struct cgraph_edge *))
 {
   struct cgraph_edge *edge;
-  struct ipa_dfs_info *v_info = (struct ipa_dfs_info *) v->symbol.aux;
+  struct ipa_dfs_info *v_info = (struct ipa_dfs_info *) v->aux;
 
   /* mark node as old */
   v_info->new_node = false;
@@ -107,11 +107,11 @@ searchc (struct searchc_env* env, struct cgraph_node *v,
       if (!w || (ignore_edge && ignore_edge (edge)))
         continue;
 
-      if (w->symbol.aux
+      if (w->aux
 	  && (avail > AVAIL_OVERWRITABLE
 	      || (env->allow_overwritable && avail == AVAIL_OVERWRITABLE)))
 	{
-	  w_info = (struct ipa_dfs_info *) w->symbol.aux;
+	  w_info = (struct ipa_dfs_info *) w->aux;
 	  if (w_info->new_node)
 	    {
 	      searchc (env, w, ignore_edge);
@@ -136,7 +136,7 @@ searchc (struct searchc_env* env, struct cgraph_node *v,
       struct ipa_dfs_info *x_info;
       do {
 	x = env->stack[--(env->stack_size)];
-	x_info = (struct ipa_dfs_info *) x->symbol.aux;
+	x_info = (struct ipa_dfs_info *) x->aux;
 	x_info->on_stack = false;
 	x_info->scc_no = v_info->dfn_number;
 
@@ -190,20 +190,20 @@ ipa_reduced_postorder (struct cgraph_node **order,
 	      && (avail == AVAIL_OVERWRITABLE)))
 	{
 	  /* Reuse the info if it is already there.  */
-	  struct ipa_dfs_info *info = (struct ipa_dfs_info *) node->symbol.aux;
+	  struct ipa_dfs_info *info = (struct ipa_dfs_info *) node->aux;
 	  if (!info)
 	    info = XCNEW (struct ipa_dfs_info);
 	  info->new_node = true;
 	  info->on_stack = false;
 	  info->next_cycle = NULL;
-	  node->symbol.aux = info;
+	  node->aux = info;
 
 	  splay_tree_insert (env.nodes_marked_new,
 			     (splay_tree_key)node->uid,
 			     (splay_tree_value)node);
 	}
       else
-	node->symbol.aux = NULL;
+	node->aux = NULL;
     }
   result = splay_tree_min (env.nodes_marked_new);
   while (result)
@@ -228,10 +228,10 @@ ipa_free_postorder_info (void)
   FOR_EACH_DEFINED_FUNCTION (node)
     {
       /* Get rid of the aux information.  */
-      if (node->symbol.aux)
+      if (node->aux)
 	{
-	  free (node->symbol.aux);
-	  node->symbol.aux = NULL;
+	  free (node->aux);
+	  node->aux = NULL;
 	}
     }
 }
@@ -247,7 +247,7 @@ ipa_get_nodes_in_cycle (struct cgraph_node *node)
   while (node)
     {
       v.safe_push (node);
-      node_dfs_info = (struct ipa_dfs_info *) node->symbol.aux;
+      node_dfs_info = (struct ipa_dfs_info *) node->aux;
       node = node_dfs_info->next_cycle;
     }
   return v;
@@ -282,21 +282,21 @@ ipa_reverse_postorder (struct cgraph_node **order)
      to be output and put them into order as well, so we get dependencies
      right through inline functions.  */
   FOR_EACH_FUNCTION (node)
-    node->symbol.aux = NULL;
+    node->aux = NULL;
   for (pass = 0; pass < 2; pass++)
     FOR_EACH_FUNCTION (node)
-      if (!node->symbol.aux
+      if (!node->aux
 	  && (pass
-	      || (!node->symbol.address_taken
+	      || (!node->address_taken
 		  && !node->global.inlined_to
-		  && !node->symbol.alias && !node->thunk.thunk_p
+		  && !node->alias && !node->thunk.thunk_p
 		  && !cgraph_only_called_directly_p (node))))
 	{
 	  stack_size = 0;
           stack[stack_size].node = node;
 	  stack[stack_size].edge = node->callers;
 	  stack[stack_size].ref = 0;
-	  node->symbol.aux = (void *)(size_t)1;
+	  node->aux = (void *)(size_t)1;
 	  while (stack_size >= 0)
 	    {
 	      while (true)
@@ -310,12 +310,12 @@ ipa_reverse_postorder (struct cgraph_node **order)
 		      /* Break possible cycles involving always-inline
 			 functions by ignoring edges from always-inline
 			 functions to non-always-inline functions.  */
-		      if (DECL_DISREGARD_INLINE_LIMITS (edge->caller->symbol.decl)
+		      if (DECL_DISREGARD_INLINE_LIMITS (edge->caller->decl)
 			  && !DECL_DISREGARD_INLINE_LIMITS
-			    (cgraph_function_node (edge->callee, NULL)->symbol.decl))
+			    (cgraph_function_node (edge->callee, NULL)->decl))
 			node2 = NULL;
 		    }
-		  for (;ipa_ref_list_referring_iterate (&stack[stack_size].node->symbol.ref_list,
+		  for (;ipa_ref_list_referring_iterate (&stack[stack_size].node->ref_list,
 						       stack[stack_size].ref,
 						       ref) && !node2;
 		       stack[stack_size].ref++)
@@ -325,12 +325,12 @@ ipa_reverse_postorder (struct cgraph_node **order)
 		    }
 		  if (!node2)
 		    break;
-		  if (!node2->symbol.aux)
+		  if (!node2->aux)
 		    {
 		      stack[++stack_size].node = node2;
 		      stack[stack_size].edge = node2->callers;
 		      stack[stack_size].ref = 0;
-		      node2->symbol.aux = (void *)(size_t)1;
+		      node2->aux = (void *)(size_t)1;
 		    }
 		}
 	      order[order_pos++] = stack[stack_size--].node;
@@ -338,7 +338,7 @@ ipa_reverse_postorder (struct cgraph_node **order)
 	}
   free (stack);
   FOR_EACH_FUNCTION (node)
-    node->symbol.aux = NULL;
+    node->aux = NULL;
   return order_pos;
 }
 
@@ -467,7 +467,7 @@ dump_cgraph_node_set (FILE *f, cgraph_node_set set)
   for (iter = csi_start (set); !csi_end_p (iter); csi_next (&iter))
     {
       struct cgraph_node *node = csi_node (iter);
-      fprintf (f, " %s/%i", cgraph_node_name (node), node->symbol.order);
+      fprintf (f, " %s/%i", cgraph_node_name (node), node->order);
     }
   fprintf (f, "\n");
 }
@@ -629,12 +629,12 @@ void
 ipa_merge_profiles (struct cgraph_node *dst,
 		    struct cgraph_node *src)
 {
-  tree oldsrcdecl = src->symbol.decl;
+  tree oldsrcdecl = src->decl;
   struct function *srccfun, *dstcfun;
   bool match = true;
 
-  if (!src->symbol.definition
-      || !dst->symbol.definition)
+  if (!src->definition
+      || !dst->definition)
     return;
   if (src->frequency < dst->frequency)
     src->frequency = dst->frequency;
@@ -643,8 +643,8 @@ ipa_merge_profiles (struct cgraph_node *dst,
   if (cgraph_dump_file)
     {
       fprintf (cgraph_dump_file, "Merging profiles of %s/%i to %s/%i\n",
-	       xstrdup (cgraph_node_name (src)), src->symbol.order,
-	       xstrdup (cgraph_node_name (dst)), dst->symbol.order);
+	       xstrdup (cgraph_node_name (src)), src->order,
+	       xstrdup (cgraph_node_name (dst)), dst->order);
     }
   dst->count += src->count;
 
@@ -652,7 +652,7 @@ ipa_merge_profiles (struct cgraph_node *dst,
      If declaration is merged, we need to duplicate it to be able
      to load body that is being replaced.  This makes symbol table
      temporarily inconsistent.  */
-  if (src->symbol.decl == dst->symbol.decl)
+  if (src->decl == dst->decl)
     {
       void **slot;
       struct lto_in_decl_state temp;
@@ -660,32 +660,32 @@ ipa_merge_profiles (struct cgraph_node *dst,
 
       /* We are going to move the decl, we want to remove its file decl data.
 	 and link these with the new decl. */
-      temp.fn_decl = src->symbol.decl;
-      slot = htab_find_slot (src->symbol.lto_file_data->function_decl_states,
+      temp.fn_decl = src->decl;
+      slot = htab_find_slot (src->lto_file_data->function_decl_states,
 			     &temp, NO_INSERT);
       state = (lto_in_decl_state *)*slot;
-      htab_clear_slot (src->symbol.lto_file_data->function_decl_states, slot);
+      htab_clear_slot (src->lto_file_data->function_decl_states, slot);
       gcc_assert (state);
 
       /* Duplicate the decl and be sure it does not link into body of DST.  */
-      src->symbol.decl = copy_node (src->symbol.decl);
-      DECL_STRUCT_FUNCTION (src->symbol.decl) = NULL;
-      DECL_ARGUMENTS (src->symbol.decl) = NULL;
-      DECL_INITIAL (src->symbol.decl) = NULL;
-      DECL_RESULT (src->symbol.decl) = NULL;
+      src->decl = copy_node (src->decl);
+      DECL_STRUCT_FUNCTION (src->decl) = NULL;
+      DECL_ARGUMENTS (src->decl) = NULL;
+      DECL_INITIAL (src->decl) = NULL;
+      DECL_RESULT (src->decl) = NULL;
 
       /* Associate the decl state with new declaration, so LTO streamer
  	 can look it up.  */
-      state->fn_decl = src->symbol.decl;
-      slot = htab_find_slot (src->symbol.lto_file_data->function_decl_states,
+      state->fn_decl = src->decl;
+      slot = htab_find_slot (src->lto_file_data->function_decl_states,
 			     state, INSERT);
       gcc_assert (!*slot);
       *slot = state;
     }
   cgraph_get_body (src);
   cgraph_get_body (dst);
-  srccfun = DECL_STRUCT_FUNCTION (src->symbol.decl);
-  dstcfun = DECL_STRUCT_FUNCTION (dst->symbol.decl);
+  srccfun = DECL_STRUCT_FUNCTION (src->decl);
+  dstcfun = DECL_STRUCT_FUNCTION (dst->decl);
   if (n_basic_blocks_for_function (srccfun)
       != n_basic_blocks_for_function (dstcfun))
     {
@@ -773,7 +773,7 @@ ipa_merge_profiles (struct cgraph_node *dst,
 	  gcc_assert (!e->speculative);
 	  e->count = gimple_bb (e->call_stmt)->count;
 	  e->frequency = compute_call_stmt_bb_frequency
-			     (dst->symbol.decl,
+			     (dst->decl,
 			      gimple_bb (e->call_stmt));
 	}
       for (e = dst->indirect_calls; e; e = e->next_callee)
@@ -781,14 +781,14 @@ ipa_merge_profiles (struct cgraph_node *dst,
 	  gcc_assert (!e->speculative);
 	  e->count = gimple_bb (e->call_stmt)->count;
 	  e->frequency = compute_call_stmt_bb_frequency
-			     (dst->symbol.decl,
+			     (dst->decl,
 			      gimple_bb (e->call_stmt));
 	}
       cgraph_release_function_body (src);
       inline_update_overall_summary (dst);
     }
   /* TODO: if there is no match, we can scale up.  */
-  src->symbol.decl = oldsrcdecl;
+  src->decl = oldsrcdecl;
 }
 
 /* Return true if call to DEST is known to be self-recusive call withing FUNC.   */
@@ -799,6 +799,6 @@ recursive_call_p (tree func, tree dest)
   struct cgraph_node *dest_node = cgraph_get_create_node (dest);
   struct cgraph_node *cnode = cgraph_get_create_node (func);
 
-  return symtab_semantically_equivalent_p ((symtab_node)dest_node,
-					   (symtab_node)cnode);
+  return symtab_semantically_equivalent_p (dest_node,
+					   cnode);
 }
diff --git a/gcc/ipa.c b/gcc/ipa.c
index 37b6629..408c690 100644
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -42,12 +42,12 @@ cgraph_non_local_node_p_1 (struct cgraph_node *node, void *data ATTRIBUTE_UNUSED
 {
    /* FIXME: Aliases can be local, but i386 gets thunks wrong then.  */
    return !(cgraph_only_called_directly_or_aliased_p (node)
-	    && !ipa_ref_has_aliases_p (&node->symbol.ref_list)
-	    && node->symbol.definition
-	    && !DECL_EXTERNAL (node->symbol.decl)
-	    && !node->symbol.externally_visible
-	    && !node->symbol.used_from_other_partition
-	    && !node->symbol.in_other_partition);
+	    && !ipa_ref_has_aliases_p (&node->ref_list)
+	    && node->definition
+	    && !DECL_EXTERNAL (node->decl)
+	    && !node->externally_visible
+	    && !node->used_from_other_partition
+	    && !node->in_other_partition);
 }
 
 /* Return true when function can be marked local.  */
@@ -75,7 +75,7 @@ has_addr_references_p (struct cgraph_node *node,
   int i;
   struct ipa_ref *ref;
 
-  for (i = 0; ipa_ref_list_referring_iterate (&node->symbol.ref_list,
+  for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list,
 					      i, ref); i++)
     if (ref->use == IPA_REF_ADDR)
       return true;
@@ -110,13 +110,13 @@ enqueue_node (symtab_node node, symtab_node *first,
 	      struct pointer_set_t *reachable)
 {
   /* Node is still in queue; do nothing.  */
-  if (node->symbol.aux && node->symbol.aux != (void *) 2)
+  if (node->aux && node->aux != (void *) 2)
     return;
   /* Node was already processed as unreachable, re-enqueue
      only if it became reachable now.  */
-  if (node->symbol.aux == (void *)2 && !pointer_set_contains (reachable, node))
+  if (node->aux == (void *)2 && !pointer_set_contains (reachable, node))
     return;
-  node->symbol.aux = *first;
+  node->aux = *first;
   *first = node;
 }
 
@@ -134,18 +134,18 @@ process_references (struct ipa_ref_list *list,
     {
       symtab_node node = ref->referred;
 
-      if (node->symbol.definition && !node->symbol.in_other_partition
-	  && ((!DECL_EXTERNAL (node->symbol.decl) || node->symbol.alias)
+      if (node->definition && !node->in_other_partition
+	  && ((!DECL_EXTERNAL (node->decl) || node->alias)
 	      || (before_inlining_p
 		  /* We use variable constructors during late complation for
 		     constant folding.  Keep references alive so partitioning
 		     knows about potential references.  */
-		  || (TREE_CODE (node->symbol.decl) == VAR_DECL
+		  || (TREE_CODE (node->decl) == VAR_DECL
 		      && flag_wpa
-		      && ctor_for_folding (node->symbol.decl)
+		      && ctor_for_folding (node->decl)
 		         != error_mark_node))))
 	pointer_set_insert (reachable, node);
-      enqueue_node ((symtab_node) node, first, reachable);
+      enqueue_node (node, first, reachable);
     }
 }
 
@@ -224,9 +224,9 @@ symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
     fprintf (file, "\nReclaiming functions:");
 #ifdef ENABLE_CHECKING
   FOR_EACH_FUNCTION (node)
-    gcc_assert (!node->symbol.aux);
+    gcc_assert (!node->aux);
   FOR_EACH_VARIABLE (vnode)
-    gcc_assert (!vnode->symbol.aux);
+    gcc_assert (!vnode->aux);
 #endif
   /* Mark functions whose bodies are obviously needed.
      This is mostly when they can be referenced externally.  Inline clones
@@ -235,29 +235,29 @@ symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
   FOR_EACH_FUNCTION (node)
     {
       node->used_as_abstract_origin = false;
-      if (node->symbol.definition
+      if (node->definition
 	  && !node->global.inlined_to
-	  && !node->symbol.in_other_partition
+	  && !node->in_other_partition
 	  && (!cgraph_can_remove_if_no_direct_calls_and_refs_p (node)
 	      /* Keep around virtual functions for possible devirtualization.  */
 	      || (before_inlining_p
-		  && DECL_VIRTUAL_P (node->symbol.decl))))
+		  && DECL_VIRTUAL_P (node->decl))))
 	{
 	  gcc_assert (!node->global.inlined_to);
 	  pointer_set_insert (reachable, node);
-	  enqueue_node ((symtab_node)node, &first, reachable);
+	  enqueue_node (node, &first, reachable);
 	}
       else
-	gcc_assert (!node->symbol.aux);
+	gcc_assert (!node->aux);
      }
 
   /* Mark variables that are obviously needed.  */
   FOR_EACH_DEFINED_VARIABLE (vnode)
     if (!varpool_can_remove_if_no_refs (vnode)
-	&& !vnode->symbol.in_other_partition)
+	&& !vnode->in_other_partition)
       {
 	pointer_set_insert (reachable, vnode);
-	enqueue_node ((symtab_node)vnode, &first, reachable);
+	enqueue_node (vnode, &first, reachable);
       }
 
   /* Perform reachability analysis.  */
@@ -266,34 +266,34 @@ symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
       bool in_boundary_p = !pointer_set_contains (reachable, first);
       symtab_node node = first;
 
-      first = (symtab_node)first->symbol.aux;
+      first = (symtab_node)first->aux;
 
       /* If we are processing symbol in boundary, mark its AUX pointer for
 	 possible later re-processing in enqueue_node.  */
       if (in_boundary_p)
-	node->symbol.aux = (void *)2;
+	node->aux = (void *)2;
       else
 	{
-	  if (DECL_ABSTRACT_ORIGIN (node->symbol.decl))
+	  if (DECL_ABSTRACT_ORIGIN (node->decl))
 	    {
 	      struct cgraph_node *origin_node
-	      = cgraph_get_create_real_symbol_node (DECL_ABSTRACT_ORIGIN (node->symbol.decl));
+	      = cgraph_get_create_real_symbol_node (DECL_ABSTRACT_ORIGIN (node->decl));
 	      origin_node->used_as_abstract_origin = true;
-	      enqueue_node ((symtab_node) origin_node, &first, reachable);
+	      enqueue_node (origin_node, &first, reachable);
 	    }
 	  /* If any symbol in a comdat group is reachable, force
 	     all other in the same comdat group to be also reachable.  */
-	  if (node->symbol.same_comdat_group)
+	  if (node->same_comdat_group)
 	    {
 	      symtab_node next;
-	      for (next = node->symbol.same_comdat_group;
+	      for (next = node->same_comdat_group;
 		   next != node;
-		   next = next->symbol.same_comdat_group)
+		   next = next->same_comdat_group)
 		if (!pointer_set_insert (reachable, next))
-		  enqueue_node ((symtab_node) next, &first, reachable);
+		  enqueue_node (next, &first, reachable);
 	    }
 	  /* Mark references as reachable.  */
-	  process_references (&node->symbol.ref_list, &first,
+	  process_references (&node->ref_list, &first,
 			      before_inlining_p, reachable);
 	}
 
@@ -306,31 +306,31 @@ symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
 	      struct cgraph_edge *e;
 	      for (e = cnode->callees; e; e = e->next_callee)
 		{
-		  if (e->callee->symbol.definition
-		      && !e->callee->symbol.in_other_partition
+		  if (e->callee->definition
+		      && !e->callee->in_other_partition
 		      && (!e->inline_failed
-			  || !DECL_EXTERNAL (e->callee->symbol.decl)
-			  || e->callee->symbol.alias
+			  || !DECL_EXTERNAL (e->callee->decl)
+			  || e->callee->alias
 			  || before_inlining_p))
 		    pointer_set_insert (reachable, e->callee);
-		  enqueue_node ((symtab_node) e->callee, &first, reachable);
+		  enqueue_node (e->callee, &first, reachable);
 		}
 
 	      /* When inline clone exists, mark body to be preserved so when removing
 		 offline copy of the function we don't kill it.  */
 	      if (cnode->global.inlined_to)
-	        pointer_set_insert (body_needed_for_clonning, cnode->symbol.decl);
+	        pointer_set_insert (body_needed_for_clonning, cnode->decl);
 
 	      /* For non-inline clones, force their origins to the boundary and ensure
 		 that body is not removed.  */
 	      while (cnode->clone_of)
 		{
-		  bool noninline = cnode->clone_of->symbol.decl != cnode->symbol.decl;
+		  bool noninline = cnode->clone_of->decl != cnode->decl;
 		  cnode = cnode->clone_of