Patchwork [v2,5/6] Automated renaming of symtab types

login
register
mail settings
Submitter David Malcolm
Date Sept. 9, 2013, 7:32 p.m.
Message ID <1378755140-5555-6-git-send-email-dmalcolm@redhat.com>
Download mbox | patch
Permalink /patch/273660/
State New
Headers show

Comments

David Malcolm - Sept. 9, 2013, 7:32 p.m.
gcc/

	Patch autogenerated by rename_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 714e57b66b08fb29f47826fbb642707bdfa19520

	* cgraph.c (cgraph_get_body): Rename symtab_node_base to symtab_node.
	(cgraph_edge_remove_callee): Likewise.
	(cgraph_node_for_asm): Likewise.
	* cgraph.h (gt_ggc_mx): Likewise.
	(gt_pch_nx): Likewise.
	(GTY): Likewise.
	(is_a_helper <cgraph_node>::test): Likewise.
	(way): Likewise.
	(is_a_helper <varpool_node>::test): Likewise.
	(cgraph_turn_edge_to_speculative): Likewise.
	(cgraph): Likewise.
	(varpool_first_variable): Likewise.
	(varpool_next_variable): Likewise.
	(varpool_first_static_initializer): Likewise.
	(varpool_next_static_initializer): Likewise.
	(varpool_first_defined_variable): Likewise.
	(varpool_next_defined_variable): Likewise.
	(cgraph_first_defined_function): Likewise.
	(cgraph_next_defined_function): Likewise.
	(cgraph_first_function): Likewise.
	(cgraph_next_function): Likewise.
	(cgraph_first_function_with_gimple_body): Likewise.
	(cgraph_next_function_with_gimple_body): Likewise.
	(varpool_all_refs_explicit_p): Likewise.
	(cgraph_mark_force_output_node): Likewise.
	(symtab_real_symbol_p): Likewise.
	* cgraphbuild.c (mark_address): Likewise.
	(mark_load): Likewise.
	(mark_store): Likewise.
	* cgraphunit.c (decide_is_symbol_needed): Likewise.
	(cgraph_reset_node): Likewise.
	(cgraph_process_same_body_aliases): Likewise.
	(analyze_functions): Likewise.
	(handle_alias_pairs): Likewise.
	(output_weakrefs): Likewise.
	(compile): Likewise.
	* gimple-fold.c (can_refer_decl_in_current_unit_p): Likewise.
	* ipa-inline-analysis.c (inline_write_summary): Likewise.
	* ipa-prop.c (ipa_find_agg_cst_for_param): Likewise.
	(try_decrement_rdesc_refcount): Likewise.
	(ipa_edge_duplication_hook): Likewise.
	* ipa-ref.c (ipa_record_reference): Likewise.
	(ipa_maybe_record_reference): Likewise.
	(ipa_dump_referring): Likewise.
	(ipa_clone_ref): Likewise.
	(ipa_clone_references): Likewise.
	(ipa_ref_has_aliases_p): Likewise.
	(ipa_find_reference): Likewise.
	(ipa_remove_stmt_references): Likewise.
	* ipa-ref.h (or): Likewise.
	(GTY): Likewise.
	(ipa_record_reference): Likewise.
	(ipa_maybe_record_reference): Likewise.
	(ipa_clone_references): Likewise.
	(ipa_clone_referring): Likewise.
	(ipa_clone_ref): Likewise.
	(ipa_find_reference): Likewise.
	(ipa_remove_stmt_references): Likewise.
	(ipa_clear_stmts_in_references): Likewise.
	* ipa-reference.c (ipa_reference_write_optimization_summary):
	Likewise.
	* ipa.c (update_inlined_to_pointer): Likewise.
	(enqueue_node): Likewise.
	(process_references): Likewise.
	(symtab_remove_unreachable_nodes): Likewise.
	(ipa_discover_readonly_nonaddressable_vars): Likewise.
	(address_taken_from_non_vtable_p): Likewise.
	(comdat_can_be_unshared_p_1): Likewise.
	(comdat_can_be_unshared_p): Likewise.
	(varpool_externally_visible_p): Likewise.
	(function_and_variable_visibility): Likewise.
	* is-a.h (varpool_analyze_node): Likewise.
	(or): Likewise.
	* lto-cgraph.c (input_cgraph_opt_summary): Likewise.
	(lto_symtab_encoder_delete): Likewise.
	(lto_symtab_encoder_encode): Likewise.
	(lto_set_symtab_encoder_encode_initializer): Likewise.
	(lto_symtab_encoder_in_partition_p): Likewise.
	(output_refs): Likewise.
	(compute_ltrans_boundary): Likewise.
	(output_symtab): Likewise.
	(get_alias_symbol): Likewise.
	(input_node): Likewise.
	(input_varpool_node): Likewise.
	(input_ref): Likewise.
	(input_edge): Likewise.
	(input_cgraph_1): Likewise.
	(input_refs): Likewise.
	(input_symtab): Likewise.
	(output_cgraph_opt_summary): Likewise.
	(input_node_opt_summary): Likewise.
	(input_cgraph_opt_section): Likewise.
	* lto-section-in.c (lto_free_function_in_decl_state): Likewise.
	* lto-streamer-out.c (lto_output): Likewise.
	(write_symbol): Likewise.
	(produce_symtab): Likewise.
	* lto-streamer.h (LTO_INIT_INPUT_BLOCK_PTR): Likewise.
	(lto_destroy_simple_input_block): Likewise.
	(lto_symtab_encoder_size): Likewise.
	(lsei_next): Likewise.
	(lsei_varpool_node): Likewise.
	* symtab.c (hash_node): Likewise.
	(eq_node): Likewise.
	(hash_node_by_assembler_name): Likewise.
	(GTY): Likewise.
	(eq_assembler_name): Likewise.
	(insert_to_assembler_name_hash): Likewise.
	(unlink_from_assembler_name_hash): Likewise.
	(symtab_prevail_in_asm_name_hash): Likewise.
	(symtab_register_node): Likewise.
	(symtab_insert_node_to_hashtable): Likewise.
	(symtab_unregister_node): Likewise.
	(symtab_get_node): Likewise.
	(symtab_initialize_asm_name_hash): Likewise.
	(symtab_node_for_asm): Likewise.
	(change_decl_assembler_name): Likewise.
	(symtab_add_to_same_comdat_group): Likewise.
	(symtab_dissolve_same_comdat_group_list): Likewise.
	(symtab_node_asm_name): Likewise.
	(symtab_node_name): Likewise.
	(dump_symtab_base): Likewise.
	(dump_symtab): Likewise.
	(debug_symtab): Likewise.
	(verify_symtab_base): Likewise.
	(verify_symtab): Likewise.
	(resolution_used_from_other_file_p): Likewise.
	(symtab_make_decl_local): Likewise.
	(symtab_node_availability): Likewise.
	(symtab_alias_ultimate_target): Likewise.
	(fixup_same_cpp_alias_visibility): Likewise.
	(symtab_resolve_alias): Likewise.
	(symtab_for_node_and_aliases): Likewise.
	(symtab_nonoverwritable_alias_1): Likewise.
	(symtab_nonoverwritable_alias): Likewise.
	(symtab_semantically_equivalent_p): Likewise.
	* value-prof.c (init_node_map): Likewise.
	* varasm.c (find_decl): Likewise.
	* varpool.c (varpool_node_for_asm): Likewise.
	(varpool_remove_unreferenced_decls): Likewise.

gcc/c-family/

	Patch autogenerated by rename_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 714e57b66b08fb29f47826fbb642707bdfa19520

	* c-pragma.c (maybe_apply_pending_pragma_weaks): Rename
	symtab_node_base to symtab_node.

gcc/lto/

	Patch autogenerated by rename_symtab.py from
	https://github.com/davidmalcolm/gcc-refactoring-scripts
	revision 714e57b66b08fb29f47826fbb642707bdfa19520

	* lto-partition.c (get_symbol_class): Rename symtab_node_base to
	symtab_node.
	(free_ltrans_partitions): Likewise.
	(symbol_partitioned_p): Likewise.
	(add_references_to_partition): Likewise.
	(add_symbol_to_partition_1): Likewise.
	(contained_in_symbol): Likewise.
	(add_symbol_to_partition): Likewise.
	(undo_partition): Likewise.
	(lto_1_to_1_map): Likewise.
	(lto_max_map): Likewise.
	(lto_balanced_map): Likewise.
	(privatize_symbol_name): Likewise.
	(promote_symbol): Likewise.
	(may_need_named_section_p): Likewise.
	(rename_statics): Likewise.
	(lto_promote_cross_file_statics): Likewise.
	(lto_promote_statics_nonwpa): Likewise.
	* lto-symtab.c (lto_varpool_replace_node): Likewise.
	(lto_symtab_merge): Likewise.
	(lto_symtab_resolve_replaceable_p): Likewise.
	(lto_symtab_symbol_p): Likewise.
	(lto_symtab_resolve_can_prevail_p): Likewise.
	(lto_symtab_resolve_symbols): Likewise.
	(lto_symtab_merge_decls_2): Likewise.
	(lto_symtab_merge_decls_1): Likewise.
	(lto_symtab_merge_decls): Likewise.
	(lto_symtab_merge_symbols_1): Likewise.
	(lto_symtab_merge_symbols): Likewise.
	(lto_symtab_prevailing_decl): Likewise.
	* lto.c (lto_wpa_write_files): Likewise.
	(read_cgraph_and_symbols): Likewise.
	(do_whole_program_analysis): Likewise.
---
 gcc/c-family/c-pragma.c   |   2 +-
 gcc/cgraph.c              |  22 ++++----
 gcc/cgraph.h              | 116 +++++++++++++++++++-------------------
 gcc/cgraphbuild.c         |  10 ++--
 gcc/cgraphunit.c          |  34 +++++------
 gcc/gimple-fold.c         |   2 +-
 gcc/ipa-inline-analysis.c |   4 +-
 gcc/ipa-prop.c            |   6 +-
 gcc/ipa-ref.c             |  20 +++----
 gcc/ipa-ref.h             |  24 ++++----
 gcc/ipa-reference.c       |   6 +-
 gcc/ipa.c                 |  28 +++++-----
 gcc/is-a.h                |   6 +-
 gcc/lto-cgraph.c          |  50 ++++++++---------
 gcc/lto-section-in.c      |   2 +-
 gcc/lto-streamer-out.c    |   8 +--
 gcc/lto-streamer.h        |  18 +++---
 gcc/lto/lto-partition.c   |  42 +++++++-------
 gcc/lto/lto-symtab.c      |  44 +++++++--------
 gcc/lto/lto.c             |   8 +--
 gcc/symtab.c              | 140 +++++++++++++++++++++++-----------------------
 gcc/value-prof.c          |   4 +-
 gcc/varasm.c              |   2 +-
 gcc/varpool.c             |   4 +-
 24 files changed, 301 insertions(+), 301 deletions(-)
Jan Hubicka - Sept. 10, 2013, 1:38 p.m.
> gcc/
> 
> 	Patch autogenerated by rename_symtab.py from
> 	https://github.com/davidmalcolm/gcc-refactoring-scripts
> 	revision 714e57b66b08fb29f47826fbb642707bdfa19520

OK,
thanks!
Honza

Patch

diff --git a/gcc/c-family/c-pragma.c b/gcc/c-family/c-pragma.c
index 409fcb1..8adb4ee 100644
--- a/gcc/c-family/c-pragma.c
+++ b/gcc/c-family/c-pragma.c
@@ -307,7 +307,7 @@  maybe_apply_pending_pragma_weaks (void)
   tree alias_id, id, decl;
   int i;
   pending_weak *pe;
-  symtab_node target;
+  symtab_node *target;
 
   if (!pending_weaks)
     return;
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 84f617f..bb2626d 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -61,7 +61,7 @@  static inline void cgraph_edge_remove_caller (struct cgraph_edge *e);
 static inline void cgraph_edge_remove_callee (struct cgraph_edge *e);
 
 /* Queue of cgraph nodes scheduled to be lowered.  */
-symtab_node x_cgraph_nodes_queue;
+symtab_node *x_cgraph_nodes_queue;
 #define cgraph_nodes_queue ((struct cgraph_node *)x_cgraph_nodes_queue)
 
 /* Number of nodes in existence.  */
@@ -644,7 +644,7 @@  struct cgraph_node *
 cgraph_node_for_asm (tree asmname)
 {
   /* We do not want to look at inline clones.  */
-  for (symtab_node node = symtab_node_for_asm (asmname);
+  for (symtab_node *node = symtab_node_for_asm (asmname);
        node;
        node = node->next_sharing_asm_name)
     {
@@ -2994,12 +2994,12 @@  cgraph_get_body (struct cgraph_node *node)
   return true;
 }
 
-/* GTY((user)) hooks for symtab_node_base (and its subclasses).
+/* GTY((user)) hooks for symtab_node (and its subclasses).
    We could use virtual functions for this, but given the presence of the
    "type" field and the trivial size of the class hierarchy, switches are
    perhaps simpler and faster.  */
 
-void gt_ggc_mx (symtab_node_base *x)
+void gt_ggc_mx (symtab_node *x)
 {
   /* Hand-written equivalent of the chain_next/chain_prev machinery, to
      avoid deep call-stacks.
@@ -3009,13 +3009,13 @@  void gt_ggc_mx (symtab_node_base *x)
      Note that x (on entry) itself has already been marked by the
      gtype-desc.c code, so we first try its successor.
   */
-  symtab_node_base * xlimit = x ? x->next : NULL;
+  symtab_node * xlimit = x ? x->next : NULL;
   while (ggc_test_and_set_mark (xlimit))
    xlimit = xlimit->next;
   if (x != xlimit)
     for (;;)
       {
-        symtab_node_base * const xprev = x->previous;
+        symtab_node * const xprev = x->previous;
         if (xprev == NULL) break;
         x = xprev;
         (void) ggc_test_and_set_mark (xprev);
@@ -3065,15 +3065,15 @@  void gt_ggc_mx (symtab_node_base *x)
     }
 }
 
-void gt_pch_nx (symtab_node_base *x)
+void gt_pch_nx (symtab_node *x)
 {
-  symtab_node_base * xlimit = x ? x->next : NULL;
+  symtab_node * xlimit = x ? x->next : NULL;
   while (gt_pch_note_object (xlimit, xlimit, gt_pch_p_16symtab_node_base))
    xlimit = xlimit->next;
   if (x != xlimit)
     for (;;)
       {
-        symtab_node_base * const xprev = x->previous;
+        symtab_node * const xprev = x->previous;
         if (xprev == NULL) break;
         x = xprev;
         (void) gt_pch_note_object (xprev, xprev,
@@ -3124,7 +3124,7 @@  void gt_pch_nx (symtab_node_base *x)
     }
 }
 
-void gt_pch_nx (symtab_node_base *p, gt_pointer_operator op, void *cookie)
+void gt_pch_nx (symtab_node *p, gt_pointer_operator op, void *cookie)
 {
   /* Code common to all symtab nodes. */
   op (&(p->decl), cookie);
@@ -3192,7 +3192,7 @@  void gt_pch_nx (symtab_node_base *p, gt_pointer_operator op, void *cookie)
    within cgraph_node.  */
 static GTY(()) htab_t GTY((param_is (struct cgraph_edge))) dummy_call_site_hash;
 
-/* Similarly for this field of symtab_node_base:
+/* Similarly for this field of symtab_node:
      struct ipa_ref_list ref_list;
  */
 static GTY((deletable)) struct ipa_ref_list *dummy_ipa_ref_list;
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 6e825846..b1f9f84 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -40,7 +40,7 @@  enum symtab_type
 
 /* Base of all entries in the symbol table.
    The symtab_node is inherited by cgraph and varpol nodes.  */
-class GTY((user)) symtab_node_base
+class GTY((user)) symtab_node
 {
 public:
   /* Type of the symbol.  */
@@ -112,8 +112,8 @@  public:
   tree decl;
 
   /* Linked list of symbol table entries starting with symtab_nodes.  */
-  symtab_node next;
-  symtab_node previous;
+  symtab_node *next;
+  symtab_node *previous;
 
   /* Linked list of symbols with the same asm name.  There may be multiple
      entries for single symbol name during LTO, because symbols are renamed
@@ -124,11 +124,11 @@  public:
 
      There are also several long standing bugs where frontends and builtin
      code produce duplicated decls.  */
-  symtab_node next_sharing_asm_name;
-  symtab_node previous_sharing_asm_name;
+  symtab_node *next_sharing_asm_name;
+  symtab_node *previous_sharing_asm_name;
 
   /* Circular list of nodes in the same comdat group if non-NULL.  */
-  symtab_node same_comdat_group;
+  symtab_node *same_comdat_group;
 
   /* Vectors of referring and referenced entities.  */
   struct ipa_ref_list ref_list;
@@ -150,9 +150,9 @@  public:
    They are called the first time that the given object is visited
    within a GC/PCH traversal.
 */
-extern void gt_ggc_mx (symtab_node_base *p);
-extern void gt_pch_nx (symtab_node_base *p);
-extern void gt_pch_nx (symtab_node_base *p, gt_pointer_operator op, void *cookie);
+extern void gt_ggc_mx (symtab_node *p);
+extern void gt_pch_nx (symtab_node *p);
+extern void gt_pch_nx (symtab_node *p, gt_pointer_operator op, void *cookie);
 
 enum availability
 {
@@ -263,7 +263,7 @@  struct GTY(()) cgraph_clone_info
 /* The cgraph data structure.
    Each function decl has assigned cgraph_node listing callees and callers.  */
 
-struct GTY((user)) cgraph_node : public symtab_node_base {
+struct GTY((user)) cgraph_node : public symtab_node {
 public:
   struct cgraph_edge *callees;
   struct cgraph_edge *callers;
@@ -523,7 +523,7 @@  typedef struct cgraph_edge *cgraph_edge_p;
 /* The varpool data structure.
    Each static variable decl has assigned varpool_node.  */
 
-class GTY((user)) varpool_node : public symtab_node_base {
+class GTY((user)) varpool_node : public symtab_node {
 public:
   /* Set when variable is scheduled to be assembled.  */
   unsigned output : 1;
@@ -545,7 +545,7 @@  struct GTY(()) asm_node {
 template <>
 template <>
 inline bool
-is_a_helper <cgraph_node>::test (symtab_node_base *p)
+is_a_helper <cgraph_node>::test (symtab_node *p)
 {
   return p->type == SYMTAB_FUNCTION;
 }
@@ -555,12 +555,12 @@  is_a_helper <cgraph_node>::test (symtab_node_base *p)
 template <>
 template <>
 inline bool
-is_a_helper <varpool_node>::test (symtab_node_base *p)
+is_a_helper <varpool_node>::test (symtab_node *p)
 {
   return p->type == SYMTAB_VARIABLE;
 }
 
-extern GTY(()) symtab_node symtab_nodes;
+extern GTY(()) symtab_node *symtab_nodes;
 extern GTY(()) int cgraph_n_nodes;
 extern GTY(()) int cgraph_max_uid;
 extern GTY(()) int cgraph_edge_max_uid;
@@ -591,37 +591,37 @@  extern GTY(()) int symtab_order;
 extern bool cpp_implicit_aliases_done;
 
 /* In symtab.c  */
-void symtab_register_node (symtab_node);
-void symtab_unregister_node (symtab_node);
-void symtab_remove_node (symtab_node);
-symtab_node symtab_get_node (const_tree);
-symtab_node symtab_node_for_asm (const_tree asmname);
-const char * symtab_node_asm_name (symtab_node);
-const char * symtab_node_name (symtab_node);
-void symtab_insert_node_to_hashtable (symtab_node);
-void symtab_add_to_same_comdat_group (symtab_node, symtab_node);
-void symtab_dissolve_same_comdat_group_list (symtab_node node);
+void symtab_register_node (symtab_node *);
+void symtab_unregister_node (symtab_node *);
+void symtab_remove_node (symtab_node *);
+symtab_node *symtab_get_node (const_tree);
+symtab_node *symtab_node_for_asm (const_tree asmname);
+const char * symtab_node_asm_name (symtab_node *);
+const char * symtab_node_name (symtab_node *);
+void symtab_insert_node_to_hashtable (symtab_node *);
+void symtab_add_to_same_comdat_group (symtab_node *, symtab_node *);
+void symtab_dissolve_same_comdat_group_list (symtab_node *node);
 void dump_symtab (FILE *);
 void debug_symtab (void);
-void dump_symtab_node (FILE *, symtab_node);
-void debug_symtab_node (symtab_node);
-void dump_symtab_base (FILE *, symtab_node);
+void dump_symtab_node (FILE *, symtab_node *);
+void debug_symtab_node (symtab_node *);
+void dump_symtab_base (FILE *, symtab_node *);
 void verify_symtab (void);
-void verify_symtab_node (symtab_node);
-bool verify_symtab_base (symtab_node);
-bool symtab_used_from_object_file_p (symtab_node);
+void verify_symtab_node (symtab_node *);
+bool verify_symtab_base (symtab_node *);
+bool symtab_used_from_object_file_p (symtab_node *);
 void symtab_make_decl_local (tree);
-symtab_node symtab_alias_ultimate_target (symtab_node,
+symtab_node *symtab_alias_ultimate_target (symtab_node *,
 					  enum availability *avail = NULL);
-bool symtab_resolve_alias (symtab_node node, symtab_node target);
-void fixup_same_cpp_alias_visibility (symtab_node node, symtab_node target);
-bool symtab_for_node_and_aliases (symtab_node,
-				  bool (*) (symtab_node, void *),
+bool symtab_resolve_alias (symtab_node *node, symtab_node *target);
+void fixup_same_cpp_alias_visibility (symtab_node *node, symtab_node *target);
+bool symtab_for_node_and_aliases (symtab_node *,
+				  bool (*) (symtab_node *, void *),
 				  void *,
 				  bool);
-symtab_node symtab_nonoverwritable_alias (symtab_node);
-enum availability symtab_node_availability (symtab_node);
-bool symtab_semantically_equivalent_p (symtab_node, symtab_node);
+symtab_node *symtab_nonoverwritable_alias (symtab_node *);
+enum availability symtab_node_availability (symtab_node *);
+bool symtab_semantically_equivalent_p (symtab_node *, symtab_node *);
 
 /* In cgraph.c  */
 void dump_cgraph (FILE *);
@@ -738,7 +738,7 @@  void compile (void);
 void init_cgraph (void);
 bool cgraph_process_new_functions (void);
 void cgraph_process_same_body_aliases (void);
-void fixup_same_cpp_alias_visibility (symtab_node, symtab_node target, tree);
+void fixup_same_cpp_alias_visibility (symtab_node *, symtab_node *target, tree);
 /*  Initialize datastructures so DECL is a function in lowered gimple form.
     IN_SSA is true if the gimple is in SSA.  */
 basic_block init_lowered_empty_function (tree, bool);
@@ -842,13 +842,13 @@  bool varpool_for_node_and_aliases (struct varpool_node *,
 			           void *, bool);
 void varpool_add_new_variable (tree);
 void symtab_initialize_asm_name_hash (void);
-void symtab_prevail_in_asm_name_hash (symtab_node node);
+void symtab_prevail_in_asm_name_hash (symtab_node *node);
 void varpool_remove_initializer (struct varpool_node *);
 
 
 /* Return callgraph node for given symbol and check it is a function. */
 static inline struct cgraph_node *
-cgraph (symtab_node node)
+cgraph (symtab_node *node)
 {
   gcc_checking_assert (!node || node->type == SYMTAB_FUNCTION);
   return (struct cgraph_node *)node;
@@ -856,7 +856,7 @@  cgraph (symtab_node node)
 
 /* Return varpool node for given symbol and check it is a variable.  */
 static inline struct varpool_node *
-varpool (symtab_node node)
+varpool (symtab_node *node)
 {
   gcc_checking_assert (!node || node->type == SYMTAB_VARIABLE);
   return (struct varpool_node *)node;
@@ -915,7 +915,7 @@  varpool_node_name(struct varpool_node *node)
 static inline struct varpool_node *
 varpool_first_variable (void)
 {
-  symtab_node node;
+  symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     if (varpool_node *vnode = dyn_cast <varpool_node> (node))
       return vnode;
@@ -926,7 +926,7 @@  varpool_first_variable (void)
 static inline struct varpool_node *
 varpool_next_variable (struct varpool_node *node)
 {
-  symtab_node node1 = node->next;
+  symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     if (varpool_node *vnode1 = dyn_cast <varpool_node> (node1))
       return vnode1;
@@ -942,7 +942,7 @@  varpool_next_variable (struct varpool_node *node)
 static inline struct varpool_node *
 varpool_first_static_initializer (void)
 {
-  symtab_node node;
+  symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     {
       varpool_node *vnode = dyn_cast <varpool_node> (node);
@@ -956,7 +956,7 @@  varpool_first_static_initializer (void)
 static inline struct varpool_node *
 varpool_next_static_initializer (struct varpool_node *node)
 {
-  symtab_node node1 = node->next;
+  symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     {
       varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
@@ -975,7 +975,7 @@  varpool_next_static_initializer (struct varpool_node *node)
 static inline struct varpool_node *
 varpool_first_defined_variable (void)
 {
-  symtab_node node;
+  symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     {
       varpool_node *vnode = dyn_cast <varpool_node> (node);
@@ -989,7 +989,7 @@  varpool_first_defined_variable (void)
 static inline struct varpool_node *
 varpool_next_defined_variable (struct varpool_node *node)
 {
-  symtab_node node1 = node->next;
+  symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     {
       varpool_node *vnode1 = dyn_cast <varpool_node> (node1);
@@ -1007,7 +1007,7 @@  varpool_next_defined_variable (struct varpool_node *node)
 static inline struct cgraph_node *
 cgraph_first_defined_function (void)
 {
-  symtab_node node;
+  symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     {
       cgraph_node *cn = dyn_cast <cgraph_node> (node);
@@ -1021,7 +1021,7 @@  cgraph_first_defined_function (void)
 static inline struct cgraph_node *
 cgraph_next_defined_function (struct cgraph_node *node)
 {
-  symtab_node node1 = node->next;
+  symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     {
       cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
@@ -1040,7 +1040,7 @@  cgraph_next_defined_function (struct cgraph_node *node)
 static inline struct cgraph_node *
 cgraph_first_function (void)
 {
-  symtab_node node;
+  symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     if (cgraph_node *cn = dyn_cast <cgraph_node> (node))
       return cn;
@@ -1051,7 +1051,7 @@  cgraph_first_function (void)
 static inline struct cgraph_node *
 cgraph_next_function (struct cgraph_node *node)
 {
-  symtab_node node1 = node->next;
+  symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     if (cgraph_node *cn1 = dyn_cast <cgraph_node> (node1))
       return cn1;
@@ -1078,7 +1078,7 @@  cgraph_function_with_gimple_body_p (struct cgraph_node *node)
 static inline struct cgraph_node *
 cgraph_first_function_with_gimple_body (void)
 {
-  symtab_node node;
+  symtab_node *node;
   for (node = symtab_nodes; node; node = node->next)
     {
       cgraph_node *cn = dyn_cast <cgraph_node> (node);
@@ -1092,7 +1092,7 @@  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->next;
+  symtab_node *node1 = node->next;
   for (; node1; node1 = node1->next)
     {
       cgraph_node *cn1 = dyn_cast <cgraph_node> (node1);
@@ -1291,8 +1291,8 @@  htab_t constant_pool_htab (void);
 
 /* Return node that alias N is aliasing.  */
 
-static inline symtab_node
-symtab_alias_target (symtab_node n)
+static inline symtab_node *
+symtab_alias_target (symtab_node *n)
 {
   struct ipa_ref *ref;
   ipa_ref_list_reference_iterate (&n->ref_list, 0, ref);
@@ -1380,7 +1380,7 @@  cgraph_mark_force_output_node (struct cgraph_node *node)
    or abstract function kept for debug info purposes only.  */
 
 static inline bool
-symtab_real_symbol_p (symtab_node node)
+symtab_real_symbol_p (symtab_node *node)
 {
   struct cgraph_node *cnode;
 
@@ -1397,7 +1397,7 @@  symtab_real_symbol_p (symtab_node node)
 /* Return true if NODE can be discarded by linker from the binary.  */
 
 static inline bool
-symtab_can_be_discarded (symtab_node node)
+symtab_can_be_discarded (symtab_node *node)
 {
   return (DECL_EXTERNAL (node->decl)
 	  || (DECL_ONE_ONLY (node->decl)
diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c
index 34ce79a..c47edbd 100644
--- a/gcc/cgraphbuild.c
+++ b/gcc/cgraphbuild.c
@@ -225,7 +225,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,
+      ipa_record_reference ((symtab_node *)data,
 			    node,
 			    IPA_REF_ADDR, stmt);
     }
@@ -234,7 +234,7 @@  mark_address (gimple stmt, tree addr, void *data)
     {
       struct varpool_node *vnode = varpool_node_for_decl (addr);
 
-      ipa_record_reference ((symtab_node)data,
+      ipa_record_reference ((symtab_node *)data,
 			    vnode,
 			    IPA_REF_ADDR, stmt);
     }
@@ -254,7 +254,7 @@  mark_load (gimple stmt, tree t, void *data)
 	 directly manipulated in the code.  Pretend that it's an address.  */
       struct cgraph_node *node = cgraph_get_create_real_symbol_node (t);
       cgraph_mark_address_taken_node (node);
-      ipa_record_reference ((symtab_node)data,
+      ipa_record_reference ((symtab_node *)data,
 			    node,
 			    IPA_REF_ADDR, stmt);
     }
@@ -263,7 +263,7 @@  mark_load (gimple stmt, tree t, void *data)
     {
       struct varpool_node *vnode = varpool_node_for_decl (t);
 
-      ipa_record_reference ((symtab_node)data,
+      ipa_record_reference ((symtab_node *)data,
 			    vnode,
 			    IPA_REF_LOAD, stmt);
     }
@@ -281,7 +281,7 @@  mark_store (gimple stmt, tree t, void *data)
     {
       struct varpool_node *vnode = varpool_node_for_decl (t);
 
-      ipa_record_reference ((symtab_node)data,
+      ipa_record_reference ((symtab_node *)data,
 			    vnode,
 			    IPA_REF_STORE, stmt);
      }
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index 351291b..ceab448 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -223,7 +223,7 @@  static GTY (()) tree vtable_entry_type;
    either outside this translation unit, something magic in the system
    configury */
 bool
-decide_is_symbol_needed (symtab_node node)
+decide_is_symbol_needed (symtab_node *node)
 {
   tree decl = node->decl;
 
@@ -261,13 +261,13 @@  decide_is_symbol_needed (symtab_node node)
 
 /* Head of the queue of nodes to be processed while building callgraph */
 
-static symtab_node first = (symtab_node)(void *)1;
+static symtab_node *first = (symtab_node *)(void *)1;
 
 /* Add NODE to queue starting at FIRST. 
    The queue is linked via AUX pointers and terminated by pointer to 1.  */
 
 static void
-enqueue_node (symtab_node node)
+enqueue_node (symtab_node *node)
 {
   if (node->aux)
     return;
@@ -385,7 +385,7 @@  cgraph_reset_node (struct cgraph_node *node)
 /* Return true when there are references to NODE.  */
 
 static bool
-referred_to_p (symtab_node node)
+referred_to_p (symtab_node *node)
 {
   struct ipa_ref *ref;
 
@@ -663,14 +663,14 @@  analyze_function (struct cgraph_node *node)
 void
 cgraph_process_same_body_aliases (void)
 {
-  symtab_node node;
+  symtab_node *node;
   FOR_EACH_SYMBOL (node)
     if (node->cpp_implicit_alias && !node->analyzed)
       symtab_resolve_alias
         (node,
 	 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));
+	 ? (symtab_node *)varpool_node_for_decl (node->alias_target)
+	 : (symtab_node *)cgraph_get_create_node (node->alias_target));
   cpp_implicit_aliases_done = true;
 }
 
@@ -906,8 +906,8 @@  analyze_functions (void)
   struct varpool_node *first_handled_var = first_analyzed_var;
   struct pointer_set_t *reachable_call_targets = pointer_set_create ();
 
-  symtab_node node;
-  symtab_node next;
+  symtab_node *node;
+  symtab_node *next;
   int i;
   struct ipa_ref *ref;
   bool changed = true;
@@ -961,11 +961,11 @@  analyze_functions (void)
 
       /* Lower representation, build callgraph edges and references for all trivially
          needed symbols and all symbols referred by them.  */
-      while (first != (symtab_node)(void *)1)
+      while (first != (symtab_node *)(void *)1)
 	{
 	  changed = true;
 	  node = first;
-	  first = (symtab_node)first->aux;
+	  first = (symtab_node *)first->aux;
 	  cgraph_node *cnode = dyn_cast <cgraph_node> (node);
 	  if (cnode && cnode->definition)
 	    {
@@ -1024,7 +1024,7 @@  analyze_functions (void)
 
 	  if (node->same_comdat_group)
 	    {
-	      symtab_node next;
+	      symtab_node *next;
 	      for (next = node->same_comdat_group;
 		   next != node;
 		   next = next->same_comdat_group)
@@ -1108,7 +1108,7 @@  handle_alias_pairs (void)
   
   for (i = 0; alias_pairs && alias_pairs->iterate (i, &p);)
     {
-      symtab_node target_node = symtab_node_for_asm (p->target);
+      symtab_node *target_node = symtab_node_for_asm (p->target);
 
       /* Weakrefs with target not defined in current unit are easy to handle:
 	 they behave just as external variables except we need to note the
@@ -1116,7 +1116,7 @@  handle_alias_pairs (void)
       if (!target_node
 	  && lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)) != NULL)
 	{
-	  symtab_node node = symtab_get_node (p->decl);
+	  symtab_node *node = symtab_get_node (p->decl);
 	  if (node)
 	    {
 	      node->alias_target = p->target;
@@ -1129,7 +1129,7 @@  handle_alias_pairs (void)
       else if (!target_node)
 	{
 	  error ("%q+D aliased to undefined symbol %qE", p->decl, p->target);
-	  symtab_node node = symtab_get_node (p->decl);
+	  symtab_node *node = symtab_get_node (p->decl);
 	  if (node)
 	    node->alias = false;
 	  alias_pairs->unordered_remove (i);
@@ -2006,7 +2006,7 @@  get_alias_symbol (tree decl)
 static void
 output_weakrefs (void)
 {
-  symtab_node node;
+  symtab_node *node;
   FOR_EACH_SYMBOL (node)
     if (node->alias
         && !TREE_ASM_WRITTEN (node->decl)
@@ -2128,7 +2128,7 @@  compile (void)
      level by physically rewritting the IL.  At the moment we can only redirect
      calls, so we need infrastructure for renaming references as well.  */
 #ifndef ASM_OUTPUT_WEAKREF
-  symtab_node node;
+  symtab_node *node;
 
   FOR_EACH_SYMBOL (node)
     if (node->alias
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index e946333..9486fcd 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -58,7 +58,7 @@  can_refer_decl_in_current_unit_p (tree decl, tree from_decl)
 {
   struct varpool_node *vnode;
   struct cgraph_node *node;
-  symtab_node snode;
+  symtab_node *snode;
 
   /* We will later output the initializer, so we can refer to it.
      So we are concerned only when DECL comes from initializer of
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index 702daaf..c6511d6 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -3942,7 +3942,7 @@  inline_write_summary (void)
 
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
-      symtab_node snode = lto_symtab_encoder_deref (encoder, i);
+      symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
       cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
       if (cnode && cnode->definition && !cnode->alias)
 	count++;
@@ -3951,7 +3951,7 @@  inline_write_summary (void)
 
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
-      symtab_node snode = lto_symtab_encoder_deref (encoder, i);
+      symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
       cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
       if (cnode && (node = cnode)->definition && !node->alias)
 	{
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c
index e95f393..9bc2ef8 100644
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -2500,7 +2500,7 @@  ipa_find_agg_cst_for_param (struct ipa_agg_jump_function *agg,
    successfully found and removed.  */
 
 static bool
-remove_described_reference (symtab_node symbol, struct ipa_cst_ref_desc *rdesc)
+remove_described_reference (symtab_node *symbol, struct ipa_cst_ref_desc *rdesc)
 {
   struct ipa_ref *to_del;
   struct cgraph_edge *origin;
@@ -2563,7 +2563,7 @@  try_decrement_rdesc_refcount (struct ipa_jump_func *jfunc)
       && (rdesc = jfunc_rdesc_usable (jfunc))
       && --rdesc->refcount == 0)
     {
-      symtab_node symbol = cgraph_node_for_jfunc (jfunc);
+      symtab_node *symbol = cgraph_node_for_jfunc (jfunc);
       if (!symbol)
 	return false;
 
@@ -3071,7 +3071,7 @@  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 = cgraph_node_for_jfunc (src_jf);
+	      symtab_node *n = cgraph_node_for_jfunc (src_jf);
 	      gcc_checking_assert (n);
 	      ref = ipa_find_reference (src->caller, n,
 					src->call_stmt, src->lto_stmt_uid);
diff --git a/gcc/ipa-ref.c b/gcc/ipa-ref.c
index 4f04614e..04ce909 100644
--- a/gcc/ipa-ref.c
+++ b/gcc/ipa-ref.c
@@ -34,8 +34,8 @@  static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
    of the use and STMT the statement (if it exists).  */
 
 struct ipa_ref *
-ipa_record_reference (symtab_node referring_node,
-		      symtab_node referred_node,
+ipa_record_reference (symtab_node *referring_node,
+		      symtab_node *referred_node,
 		      enum ipa_ref_use use_type, gimple stmt)
 {
   struct ipa_ref *ref, *ref2;
@@ -76,7 +76,7 @@  ipa_record_reference (symtab_node referring_node,
    reference or NULL if none was created.  */
 
 struct ipa_ref *
-ipa_maybe_record_reference (symtab_node referring_node, tree val,
+ipa_maybe_record_reference (symtab_node *referring_node, tree val,
 			    enum ipa_ref_use use_type, gimple stmt)
 {
   STRIP_NOPS (val);
@@ -86,7 +86,7 @@  ipa_maybe_record_reference (symtab_node referring_node, tree val,
   if (val && (TREE_CODE (val) == FUNCTION_DECL
 	       || TREE_CODE (val) == VAR_DECL))
     {
-      symtab_node referred = symtab_get_node (val);
+      symtab_node *referred = symtab_get_node (val);
       gcc_checking_assert (referred);
       return ipa_record_reference (referring_node, referred,
 				   use_type, stmt);
@@ -186,7 +186,7 @@  ipa_dump_referring (FILE * file, struct ipa_ref_list *list)
 
 struct ipa_ref *
 ipa_clone_ref (struct ipa_ref *ref,
-	       symtab_node dest_node,
+	       symtab_node *dest_node,
 	       gimple stmt)
 {
   bool speculative = ref->speculative;
@@ -204,7 +204,7 @@  ipa_clone_ref (struct ipa_ref *ref,
 /* Clone all references from SRC to DEST_NODE or DEST_VARPOOL_NODE.  */
 
 void
-ipa_clone_references (symtab_node dest_node,
+ipa_clone_references (symtab_node *dest_node,
 		      struct ipa_ref_list *src)
 {
   struct ipa_ref *ref, *ref2;
@@ -225,7 +225,7 @@  ipa_clone_references (symtab_node dest_node,
 /* Clone all referring from SRC to DEST_NODE or DEST_VARPOOL_NODE.  */
 
 void
-ipa_clone_referring (symtab_node dest_node,
+ipa_clone_referring (symtab_node *dest_node,
 		    struct ipa_ref_list *src)
 {
   struct ipa_ref *ref, *ref2;
@@ -268,7 +268,7 @@  ipa_ref_has_aliases_p (struct ipa_ref_list *ref_list)
    and associated with statement STMT.  */
 
 struct ipa_ref *
-ipa_find_reference (symtab_node referring_node, symtab_node referred_node,
+ipa_find_reference (symtab_node *referring_node, symtab_node *referred_node,
 		    gimple stmt, unsigned int lto_stmt_uid)
 {
   struct ipa_ref *r = NULL;
@@ -288,7 +288,7 @@  ipa_find_reference (symtab_node referring_node, symtab_node referred_node,
    STMT.  */
 
 void
-ipa_remove_stmt_references (symtab_node referring_node, gimple stmt)
+ipa_remove_stmt_references (symtab_node *referring_node, gimple stmt)
 {
   struct ipa_ref *r = NULL;
   int i;
@@ -304,7 +304,7 @@  ipa_remove_stmt_references (symtab_node referring_node, gimple stmt)
    with callgraph edges associated with them.  */
 
 void
-ipa_clear_stmts_in_references (symtab_node referring_node)
+ipa_clear_stmts_in_references (symtab_node *referring_node)
 {
   struct ipa_ref *r = NULL;
   int i;
diff --git a/gcc/ipa-ref.h b/gcc/ipa-ref.h
index d5ea7ee..9f392b4 100644
--- a/gcc/ipa-ref.h
+++ b/gcc/ipa-ref.h
@@ -20,7 +20,7 @@  along with GCC; see the file COPYING3.  If not see
 
 struct cgraph_node;
 struct varpool_node;
-class symtab_node_base;
+class symtab_node;
 
 
 /* How the reference is done.  */
@@ -35,8 +35,8 @@  enum GTY(()) ipa_ref_use
 /* Record of reference in callgraph or varpool.  */
 struct GTY(()) ipa_ref
 {
-  symtab_node referring;
-  symtab_node referred;
+  symtab_node *referring;
+  symtab_node *referred;
   gimple stmt;
   unsigned int lto_stmt_uid;
   unsigned int referred_index;
@@ -58,10 +58,10 @@  struct GTY(()) ipa_ref_list
   vec<ipa_ref_ptr>  GTY((skip)) referring;
 };
 
-struct ipa_ref * ipa_record_reference (symtab_node,
-				       symtab_node,
+struct ipa_ref * ipa_record_reference (symtab_node *,
+				       symtab_node *,
 				       enum ipa_ref_use, gimple);
-struct ipa_ref * ipa_maybe_record_reference (symtab_node, tree,
+struct ipa_ref * ipa_maybe_record_reference (symtab_node *, tree,
 					     enum ipa_ref_use, gimple);
 
 void ipa_remove_reference (struct ipa_ref *);
@@ -69,11 +69,11 @@  void ipa_remove_all_references (struct ipa_ref_list *);
 void ipa_remove_all_referring (struct ipa_ref_list *);
 void ipa_dump_references (FILE *, struct ipa_ref_list *);
 void ipa_dump_referring (FILE *, struct ipa_ref_list *);
-void ipa_clone_references (symtab_node, struct ipa_ref_list *);
-void ipa_clone_referring (symtab_node, struct ipa_ref_list *);
-struct ipa_ref * ipa_clone_ref (struct ipa_ref *, symtab_node, gimple);
+void ipa_clone_references (symtab_node *, struct ipa_ref_list *);
+void ipa_clone_referring (symtab_node *, struct ipa_ref_list *);
+struct ipa_ref * ipa_clone_ref (struct ipa_ref *, symtab_node *, gimple);
 bool ipa_ref_cannot_lead_to_return (struct ipa_ref *);
 bool ipa_ref_has_aliases_p (struct ipa_ref_list *);
-struct ipa_ref * ipa_find_reference (symtab_node, symtab_node, gimple, unsigned int);
-void ipa_remove_stmt_references (symtab_node, gimple);
-void ipa_clear_stmts_in_references (symtab_node);
+struct ipa_ref * ipa_find_reference (symtab_node *, symtab_node *, gimple, unsigned int);
+void ipa_remove_stmt_references (symtab_node *, gimple);
+void ipa_clear_stmts_in_references (symtab_node *);
diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c
index 9c54921..587f70b 100644
--- a/gcc/ipa-reference.c
+++ b/gcc/ipa-reference.c
@@ -971,7 +971,7 @@  ipa_reference_write_optimization_summary (void)
   /* See what variables we are interested in.  */
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
-      symtab_node snode = lto_symtab_encoder_deref (encoder, i);
+      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->decl))
@@ -989,7 +989,7 @@  ipa_reference_write_optimization_summary (void)
   if (ltrans_statics_bitcount)
     for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
       {
-	symtab_node snode = lto_symtab_encoder_deref (encoder, i);
+	symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
 	cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
 	if (cnode && write_node_summary_p (cnode, encoder, ltrans_statics))
 	  count++;
@@ -1004,7 +1004,7 @@  ipa_reference_write_optimization_summary (void)
   if (ltrans_statics_bitcount)
     for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
       {
-	symtab_node snode = lto_symtab_encoder_deref (encoder, i);
+	symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
 	cgraph_node *cnode = dyn_cast <cgraph_node> (snode);
 	if (cnode && write_node_summary_p (cnode, encoder, ltrans_statics))
 	  {
diff --git a/gcc/ipa.c b/gcc/ipa.c
index 408c690..80f5f9d 100644
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -106,7 +106,7 @@  update_inlined_to_pointer (struct cgraph_node *node, struct cgraph_node *inlined
    reachable.  */
 
 static void
-enqueue_node (symtab_node node, symtab_node *first,
+enqueue_node (symtab_node *node, symtab_node **first,
 	      struct pointer_set_t *reachable)
 {
   /* Node is still in queue; do nothing.  */
@@ -124,7 +124,7 @@  enqueue_node (symtab_node node, symtab_node *first,
 
 static void
 process_references (struct ipa_ref_list *list,
-		    symtab_node *first,
+		    symtab_node **first,
 		    bool before_inlining_p,
 		    struct pointer_set_t *reachable)
 {
@@ -132,7 +132,7 @@  process_references (struct ipa_ref_list *list,
   struct ipa_ref *ref;
   for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
     {
-      symtab_node node = ref->referred;
+      symtab_node *node = ref->referred;
 
       if (node->definition && !node->in_other_partition
 	  && ((!DECL_EXTERNAL (node->decl) || node->alias)
@@ -208,7 +208,7 @@  process_references (struct ipa_ref_list *list,
 bool
 symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
 {
-  symtab_node first = (symtab_node) (void *) 1;
+  symtab_node *first = (symtab_node *) (void *) 1;
   struct cgraph_node *node, *next;
   struct varpool_node *vnode, *vnext;
   bool changed = false;
@@ -261,12 +261,12 @@  symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
       }
 
   /* Perform reachability analysis.  */
-  while (first != (symtab_node) (void *) 1)
+  while (first != (symtab_node *) (void *) 1)
     {
       bool in_boundary_p = !pointer_set_contains (reachable, first);
-      symtab_node node = first;
+      symtab_node *node = first;
 
-      first = (symtab_node)first->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.  */
@@ -285,7 +285,7 @@  symtab_remove_unreachable_nodes (bool before_inlining_p, FILE *file)
 	     all other in the same comdat group to be also reachable.  */
 	  if (node->same_comdat_group)
 	    {
-	      symtab_node next;
+	      symtab_node *next;
 	      for (next = node->same_comdat_group;
 		   next != node;
 		   next = next->same_comdat_group)
@@ -547,7 +547,7 @@  ipa_discover_readonly_nonaddressable_vars (void)
 
 /* Return true when there is a reference to node and it is not vtable.  */
 static bool
-address_taken_from_non_vtable_p (symtab_node node)
+address_taken_from_non_vtable_p (symtab_node *node)
 {
   int i;
   struct ipa_ref *ref;
@@ -568,7 +568,7 @@  address_taken_from_non_vtable_p (symtab_node node)
 /* A helper for comdat_can_be_unshared_p.  */
 
 static bool
-comdat_can_be_unshared_p_1 (symtab_node node)
+comdat_can_be_unshared_p_1 (symtab_node *node)
 {
   /* When address is taken, we don't know if equality comparison won't
      break eventually. Exception are virutal functions, C++
@@ -611,13 +611,13 @@  comdat_can_be_unshared_p_1 (symtab_node node)
    but in C++ there is no way to compare their addresses for equality.  */
 
 static bool
-comdat_can_be_unshared_p (symtab_node node)
+comdat_can_be_unshared_p (symtab_node *node)
 {
   if (!comdat_can_be_unshared_p_1 (node))
     return false;
   if (node->same_comdat_group)
     {
-      symtab_node next;
+      symtab_node *next;
 
       /* If more than one function is in the same COMDAT group, it must
          be shared even if just one function in the comdat group has
@@ -766,7 +766,7 @@  varpool_externally_visible_p (struct varpool_node *vnode)
  */
 
 bool
-can_replace_by_local_alias (symtab_node node)
+can_replace_by_local_alias (symtab_node *node)
 {
   return (symtab_node_availability (node) > AVAIL_OVERWRITABLE
 	  && !symtab_can_be_discarded (node));
@@ -826,7 +826,7 @@  function_and_variable_visibility (bool whole_program)
       if (node->same_comdat_group && DECL_EXTERNAL (node->decl))
 	{
 #ifdef ENABLE_CHECKING
-	  symtab_node n;
+	  symtab_node *n;
 
 	  for (n = node->same_comdat_group;
 	       n != node;
diff --git a/gcc/is-a.h b/gcc/is-a.h
index 15540e4..c47d10f 100644
--- a/gcc/is-a.h
+++ b/gcc/is-a.h
@@ -31,7 +31,7 @@  bool is_a <TYPE> (pointer)
 
     Tests whether the pointer actually points to a more derived TYPE.
 
-    Suppose you have a symtab_node_base *ptr, AKA symtab_node ptr.  You can test
+    Suppose you have a symtab_node *ptr, AKA symtab_node *ptr.  You can test
     whether it points to a 'derived' cgraph_node as follows.
 
       if (is_a <cgraph_node> (ptr))
@@ -110,7 +110,7 @@  example,
   template <>
   template <>
   inline bool
-  is_a_helper <cgraph_node>::test (symtab_node_base *p)
+  is_a_helper <cgraph_node>::test (symtab_node *p)
   {
     return p->type == SYMTAB_FUNCTION;
   }
@@ -122,7 +122,7 @@  when needed may result in a crash.  For example,
   template <>
   template <>
   inline bool
-  is_a_helper <cgraph_node>::cast (symtab_node_base *p)
+  is_a_helper <cgraph_node>::cast (symtab_node *p)
   {
     return &p->x_function;
   }
diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index 80e041a..e84c7d0 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -51,7 +51,7 @@  along with GCC; see the file COPYING3.  If not see
 #include "pass_manager.h"
 
 static void output_cgraph_opt_summary (void);
-static void input_cgraph_opt_summary (vec<symtab_node>  nodes);
+static void input_cgraph_opt_summary (vec<symtab_node *>  nodes);
 
 /* Number of LDPR values known to GCC.  */
 #define LDPR_NUM_KNOWN (LDPR_PREVAILING_DEF_IRONLY_EXP + 1)
@@ -110,7 +110,7 @@  lto_symtab_encoder_delete (lto_symtab_encoder_t encoder)
 
 int
 lto_symtab_encoder_encode (lto_symtab_encoder_t encoder,
-			   symtab_node node)
+			   symtab_node *node)
 {
   int ref;
   void **slot;
@@ -144,7 +144,7 @@  lto_symtab_encoder_encode (lto_symtab_encoder_t encoder,
 
 bool
 lto_symtab_encoder_delete_node (lto_symtab_encoder_t encoder,
-			        symtab_node node)
+			        symtab_node *node)
 {
   void **slot, **last_slot;
   int index;
@@ -223,7 +223,7 @@  lto_set_symtab_encoder_encode_initializer (lto_symtab_encoder_t encoder,
 
 bool
 lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t encoder,
-				   symtab_node node)
+				   symtab_node *node)
 {
   int index = lto_symtab_encoder_lookup (encoder, node);
   if (index == LCC_NOT_FOUND)
@@ -235,7 +235,7 @@  lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t encoder,
 
 void
 lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t encoder,
-				     symtab_node node)
+				     symtab_node *node)
 {
   int index = lto_symtab_encoder_encode (encoder, node);
   encoder->nodes[index].in_partition = true;
@@ -702,7 +702,7 @@  output_refs (lto_symtab_encoder_t encoder)
   for (lsei = lsei_start_in_partition (encoder); !lsei_end_p (lsei);
        lsei_next_in_partition (&lsei))
     {
-      symtab_node node = lsei_node (lsei);
+      symtab_node *node = lsei_node (lsei);
 
       count = ipa_ref_list_nreferences (&node->ref_list);
       if (count)
@@ -808,7 +808,7 @@  compute_ltrans_boundary (lto_symtab_encoder_t in_encoder)
      pickle those too.  */
   for (i = 0; i < lto_symtab_encoder_size (encoder); i++)
     {
-      symtab_node node = lto_symtab_encoder_deref (encoder, i);
+      symtab_node *node = lto_symtab_encoder_deref (encoder, i);
       if (varpool_node *vnode = dyn_cast <varpool_node> (node))
 	{
 	  if (!lto_symtab_encoder_encode_initializer_p (encoder,
@@ -872,7 +872,7 @@  output_symtab (void)
   n_nodes = lto_symtab_encoder_size (encoder);
   for (i = 0; i < n_nodes; i++)
     {
-      symtab_node node = lto_symtab_encoder_deref (encoder, i);
+      symtab_node *node = lto_symtab_encoder_deref (encoder, i);
       if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
         lto_output_node (ob, cnode, encoder);
       else
@@ -978,7 +978,7 @@  static struct cgraph_node *
 input_node (struct lto_file_decl_data *file_data,
 	    struct lto_input_block *ib,
 	    enum LTO_symtab_tags tag,
-	    vec<symtab_node> nodes)
+	    vec<symtab_node *> nodes)
 {
   gcc::pass_manager *passes = g->get_passes ();
   tree fn_decl;
@@ -1051,7 +1051,7 @@  input_node (struct lto_file_decl_data *file_data,
   node->global.inlined_to = (cgraph_node_ptr) (intptr_t) ref;
 
   /* Store a reference for now, and fix up later to be a pointer.  */
-  node->same_comdat_group = (symtab_node) (intptr_t) ref2;
+  node->same_comdat_group = (symtab_node *) (intptr_t) ref2;
 
   if (node->thunk.thunk_p)
     {
@@ -1120,7 +1120,7 @@  input_varpool_node (struct lto_file_decl_data *file_data,
     node->alias_target = get_alias_symbol (node->decl);
   ref = streamer_read_hwi (ib);
   /* Store a reference for now, and fix up later to be a pointer.  */
-  node->same_comdat_group = (symtab_node) (intptr_t) ref;
+  node->same_comdat_group = (symtab_node *) (intptr_t) ref;
   node->resolution = streamer_read_enum (ib, ld_plugin_symbol_resolution,
 					        LDPR_NUM_KNOWN);
 
@@ -1132,10 +1132,10 @@  input_varpool_node (struct lto_file_decl_data *file_data,
 
 static void
 input_ref (struct lto_input_block *ib,
-	   symtab_node referring_node,
-	   vec<symtab_node> nodes)
+	   symtab_node *referring_node,
+	   vec<symtab_node *> nodes)
 {
-  symtab_node node = NULL;
+  symtab_node *node = NULL;
   struct bitpack_d bp;
   enum ipa_ref_use use;
   bool speculative;
@@ -1157,7 +1157,7 @@  input_ref (struct lto_input_block *ib,
    indirect_unknown_callee set).  */
 
 static void
-input_edge (struct lto_input_block *ib, vec<symtab_node> nodes,
+input_edge (struct lto_input_block *ib, vec<symtab_node *> nodes,
 	    bool indirect)
 {
   struct cgraph_node *caller, *callee;
@@ -1224,13 +1224,13 @@  input_edge (struct lto_input_block *ib, vec<symtab_node> nodes,
 
 /* Read a cgraph from IB using the info in FILE_DATA.  */
 
-static vec<symtab_node> 
+static vec<symtab_node *> 
 input_cgraph_1 (struct lto_file_decl_data *file_data,
 		struct lto_input_block *ib)
 {
   enum LTO_symtab_tags tag;
-  vec<symtab_node> nodes = vNULL;
-  symtab_node node;
+  vec<symtab_node *> nodes = vNULL;
+  symtab_node *node;
   unsigned i;
 
   tag = streamer_read_enum (ib, LTO_symtab_tags, LTO_symtab_last_tag);
@@ -1302,13 +1302,13 @@  input_cgraph_1 (struct lto_file_decl_data *file_data,
 
 static void
 input_refs (struct lto_input_block *ib,
-	    vec<symtab_node> nodes)
+	    vec<symtab_node *> nodes)
 {
   int count;
   int idx;
   while (true)
     {
-      symtab_node node;
+      symtab_node *node;
       count = streamer_read_uhwi (ib);
       if (!count)
 	break;
@@ -1512,7 +1512,7 @@  input_symtab (void)
       const char *data;
       size_t len;
       struct lto_input_block *ib;
-      vec<symtab_node> nodes;
+      vec<symtab_node *> nodes;
 
       ib = lto_create_simple_input_block (file_data, LTO_section_symtab_nodes,
 					  &data, &len);
@@ -1642,7 +1642,7 @@  output_cgraph_opt_summary (void)
   n_nodes = lto_symtab_encoder_size (encoder);
   for (i = 0; i < n_nodes; i++)
     {
-      symtab_node node = lto_symtab_encoder_deref (encoder, i);
+      symtab_node *node = lto_symtab_encoder_deref (encoder, i);
       cgraph_node *cnode = dyn_cast <cgraph_node> (node);
       if (cnode && output_cgraph_opt_summary_p (cnode))
 	count++;
@@ -1650,7 +1650,7 @@  output_cgraph_opt_summary (void)
   streamer_write_uhwi (ob, count);
   for (i = 0; i < n_nodes; i++)
     {
-      symtab_node node = lto_symtab_encoder_deref (encoder, i);
+      symtab_node *node = lto_symtab_encoder_deref (encoder, i);
       cgraph_node *cnode = dyn_cast <cgraph_node> (node);
       if (cnode && output_cgraph_opt_summary_p (cnode))
 	{
@@ -1723,7 +1723,7 @@  input_node_opt_summary (struct cgraph_node *node,
 static void
 input_cgraph_opt_section (struct lto_file_decl_data *file_data,
 			  const char *data, size_t len,
-			  vec<symtab_node> nodes)
+			  vec<symtab_node *> nodes)
 {
   const struct lto_function_header *header =
     (const struct lto_function_header *) data;
@@ -1757,7 +1757,7 @@  input_cgraph_opt_section (struct lto_file_decl_data *file_data,
 /* Input optimization summary of cgraph.  */
 
 static void
-input_cgraph_opt_summary (vec<symtab_node> nodes)
+input_cgraph_opt_summary (vec<symtab_node *> nodes)
 {
   struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
   struct lto_file_decl_data *file_data;
diff --git a/gcc/lto-section-in.c b/gcc/lto-section-in.c
index ead0c41..c6a418f 100644
--- a/gcc/lto-section-in.c
+++ b/gcc/lto-section-in.c
@@ -429,7 +429,7 @@  lto_free_function_in_decl_state (struct lto_in_decl_state *state)
    release trees needed by the NODE's body.  */
 
 void
-lto_free_function_in_decl_state_for_node (symtab_node node)
+lto_free_function_in_decl_state_for_node (symtab_node *node)
 {
   struct lto_in_decl_state temp;
   void **slot;
diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
index ae725d5..45b98ef 100644
--- a/gcc/lto-streamer-out.c
+++ b/gcc/lto-streamer-out.c
@@ -1981,7 +1981,7 @@  lto_output (void)
   /* Process only the functions with bodies.  */
   for (i = 0; i < n_nodes; i++)
     {
-      symtab_node snode = lto_symtab_encoder_deref (encoder, i);
+      symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
       cgraph_node *node = dyn_cast <cgraph_node> (snode);
       if (node
 	  && lto_symtab_encoder_encode_body_p (encoder, node)
@@ -2290,7 +2290,7 @@  write_symbol (struct streamer_tree_cache_d *cache,
 /* Return true if NODE should appear in the plugin symbol table.  */
 
 bool
-output_symbol_p (symtab_node node)
+output_symbol_p (symtab_node *node)
 {
   struct cgraph_node *cnode;
   if (!symtab_real_symbol_p (node))
@@ -2352,7 +2352,7 @@  produce_symtab (struct output_block *ob)
   for (lsei = lsei_start (encoder);
        !lsei_end_p (lsei); lsei_next (&lsei))
     {
-      symtab_node node = lsei_node (lsei);
+      symtab_node *node = lsei_node (lsei);
 
       if (!output_symbol_p (node) || DECL_EXTERNAL (node->decl))
 	continue;
@@ -2361,7 +2361,7 @@  produce_symtab (struct output_block *ob)
   for (lsei = lsei_start (encoder);
        !lsei_end_p (lsei); lsei_next (&lsei))
     {
-      symtab_node node = lsei_node (lsei);
+      symtab_node *node = lsei_node (lsei);
 
       if (!output_symbol_p (node) || !DECL_EXTERNAL (node->decl))
 	continue;
diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h
index 13a9593..28245c9 100644
--- a/gcc/lto-streamer.h
+++ b/gcc/lto-streamer.h
@@ -432,7 +432,7 @@  struct lto_stats_d
 /* Entry of LTO symtab encoder.  */
 typedef struct
 {
-  symtab_node node;
+  symtab_node *node;
   /* Is the node in this partition (i.e. ltrans of this partition will
      be responsible for outputting it)? */
   unsigned int in_partition:1;
@@ -775,7 +775,7 @@  extern int lto_eq_in_decl_state (const void *, const void *);
 extern struct lto_in_decl_state *lto_get_function_in_decl_state (
 				      struct lto_file_decl_data *, tree);
 extern void lto_free_function_in_decl_state (struct lto_in_decl_state *);
-extern void lto_free_function_in_decl_state_for_node (symtab_node);
+extern void lto_free_function_in_decl_state_for_node (symtab_node *);
 extern void lto_section_overrun (struct lto_input_block *) ATTRIBUTE_NORETURN;
 extern void lto_value_range_error (const char *,
 				   HOST_WIDE_INT, HOST_WIDE_INT,
@@ -874,15 +874,15 @@  void lto_output_location (struct output_block *, struct bitpack_d *, location_t)
 
 /* In lto-cgraph.c  */
 lto_symtab_encoder_t lto_symtab_encoder_new (bool);
-int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node);
+int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node *);
 void lto_symtab_encoder_delete (lto_symtab_encoder_t);
-bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t, symtab_node);
+bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t, symtab_node *);
 bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t,
 				       struct cgraph_node *);
 bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t,
-					symtab_node);
+					symtab_node *);
 void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t,
-					  symtab_node);
+					  symtab_node *);
 
 bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t,
 					      struct varpool_node *);
@@ -1045,7 +1045,7 @@  lto_symtab_encoder_size (lto_symtab_encoder_t encoder)
 
 static inline int
 lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder,
-			   symtab_node node)
+			   symtab_node *node)
 {
   void **slot = pointer_map_contains (encoder->map, node);
   return (slot && *slot ? (size_t) *(slot) - 1 : LCC_NOT_FOUND);
@@ -1066,7 +1066,7 @@  lsei_next (lto_symtab_encoder_iterator *lsei)
 }
 
 /* Return the node pointed to by LSI.  */
-static inline symtab_node
+static inline symtab_node *
 lsei_node (lto_symtab_encoder_iterator lsei)
 {
   return lsei.encoder->nodes[lsei.index].node;
@@ -1088,7 +1088,7 @@  lsei_varpool_node (lto_symtab_encoder_iterator lsei)
 
 /* Return the cgraph node corresponding to REF using ENCODER.  */
 
-static inline symtab_node
+static inline symtab_node *
 lto_symtab_encoder_deref (lto_symtab_encoder_t encoder, int ref)
 {
   if (ref == LCC_NOT_FOUND)
diff --git a/gcc/lto/lto-partition.c b/gcc/lto/lto-partition.c
index e2a237a..98218f7 100644
--- a/gcc/lto/lto-partition.c
+++ b/gcc/lto/lto-partition.c
@@ -46,12 +46,12 @@  enum symbol_class
 
 vec<ltrans_partition> ltrans_partitions;
 
-static void add_symbol_to_partition (ltrans_partition part, symtab_node node);
+static void add_symbol_to_partition (ltrans_partition part, symtab_node *node);
 
 /* Classify symbol NODE.  */
 
 enum symbol_class
-get_symbol_class (symtab_node node)
+get_symbol_class (symtab_node *node)
 {
   /* Inline clones are always duplicated.
      This include external delcarations.   */
@@ -130,14 +130,14 @@  free_ltrans_partitions (void)
 /* Return true if symbol is already in some partition.  */
 
 static inline bool
-symbol_partitioned_p (symtab_node node)
+symbol_partitioned_p (symtab_node *node)
 {
   return node->aux;
 }
 
 /* Add references into the partition.  */
 static void
-add_references_to_partition (ltrans_partition part, symtab_node node)
+add_references_to_partition (ltrans_partition part, symtab_node *node)
 {
   int i;
   struct ipa_ref *ref;
@@ -164,12 +164,12 @@  add_references_to_partition (ltrans_partition part, symtab_node node)
    of adding NODE to PART.  */
 
 static bool
-add_symbol_to_partition_1 (ltrans_partition part, symtab_node node)
+add_symbol_to_partition_1 (ltrans_partition part, symtab_node *node)
 {
   enum symbol_class c = get_symbol_class (node);
   int i;
   struct ipa_ref *ref;
-  symtab_node node1;
+  symtab_node *node1;
 
   /* If NODE is already there, we have nothing to do.  */
   if (lto_symtab_encoder_in_partition_p (part->encoder, node))
@@ -240,8 +240,8 @@  add_symbol_to_partition_1 (ltrans_partition part, symtab_node node)
    internal label, thunk, alias or so), return the outer symbol. 
    When add_symbol_to_partition_1 is called on the outer symbol it must
    eventually add NODE, too.  */
-static symtab_node
-contained_in_symbol (symtab_node node)
+static symtab_node *
+contained_in_symbol (symtab_node *node)
 {
   /* Weakrefs are never contained in anything.  */
   if (node->weakref)
@@ -262,9 +262,9 @@  contained_in_symbol (symtab_node node)
    of other symbol definition, add the other symbol, too.  */
 
 static void
-add_symbol_to_partition (ltrans_partition part, symtab_node node)
+add_symbol_to_partition (ltrans_partition part, symtab_node *node)
 {
-  symtab_node node1;
+  symtab_node *node1;
 
   /* Verify that we do not try to duplicate something that can not be.  */
   gcc_checking_assert (get_symbol_class (node) == SYMBOL_DUPLICATE
@@ -293,7 +293,7 @@  undo_partition (ltrans_partition partition, unsigned int n_nodes)
 {
   while (lto_symtab_encoder_size (partition->encoder) > (int)n_nodes)
     {
-      symtab_node node = lto_symtab_encoder_deref (partition->encoder,
+      symtab_node *node = lto_symtab_encoder_deref (partition->encoder,
 						   n_nodes);
 
       /* After UNDO we no longer know what was visited.  */
@@ -314,7 +314,7 @@  undo_partition (ltrans_partition partition, unsigned int n_nodes)
 void
 lto_1_to_1_map (void)
 {
-  symtab_node node;
+  symtab_node *node;
   struct lto_file_decl_data *file_data;
   struct pointer_map_t *pmap;
   ltrans_partition partition;
@@ -371,7 +371,7 @@  lto_1_to_1_map (void)
 void
 lto_max_map (void)
 {
-  symtab_node node;
+  symtab_node *node;
   ltrans_partition partition;
   int npartitions = 0;
 
@@ -544,7 +544,7 @@  lto_balanced_map (void)
 	  struct ipa_ref_list *refs;
 	  int j;
 	  struct ipa_ref *ref;
-	  symtab_node snode = lto_symtab_encoder_deref (partition->encoder,
+	  symtab_node *snode = lto_symtab_encoder_deref (partition->encoder,
 							last_visited_node);
 
 	  if (cgraph_node *node = dyn_cast <cgraph_node> (snode))
@@ -762,7 +762,7 @@  lto_balanced_map (void)
 */
 
 static bool
-privatize_symbol_name (symtab_node node)
+privatize_symbol_name (symtab_node *node)
 {
   tree decl = node->decl;
   const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
@@ -805,7 +805,7 @@  privatize_symbol_name (symtab_node node)
 /* Promote variable VNODE to be static.  */
 
 static void
-promote_symbol (symtab_node node)
+promote_symbol (symtab_node *node)
 {
   /* We already promoted ... */
   if (DECL_VISIBILITY (node->decl) == VISIBILITY_HIDDEN
@@ -831,7 +831,7 @@  promote_symbol (symtab_node node)
    FIXME: we should really not use named sections for inline clones and master clones.  */
 
 static bool
-may_need_named_section_p (lto_symtab_encoder_t encoder, symtab_node node)
+may_need_named_section_p (lto_symtab_encoder_t encoder, symtab_node *node)
 {
   struct cgraph_node *cnode = dyn_cast <cgraph_node> (node);
   if (!cnode)
@@ -851,10 +851,10 @@  may_need_named_section_p (lto_symtab_encoder_t encoder, symtab_node node)
    asm statemnets referring to them by symbol name.  */
 
 static void
-rename_statics (lto_symtab_encoder_t encoder, symtab_node node)
+rename_statics (lto_symtab_encoder_t encoder, symtab_node *node)
 {
   tree decl = node->decl;
-  symtab_node s;
+  symtab_node *s;
   tree name = DECL_ASSEMBLER_NAME (decl);
 
   /* See if this is static symbol. */
@@ -934,7 +934,7 @@  lto_promote_cross_file_statics (void)
       for (lsei = lsei_start (encoder); !lsei_end_p (lsei);
 	   lsei_next (&lsei))
         {
-          symtab_node node = lsei_node (lsei);
+          symtab_node *node = lsei_node (lsei);
 
 	  /* If symbol is static, rename it if its assembler name clash with
 	     anything else in this unit.  */
@@ -960,7 +960,7 @@  lto_promote_cross_file_statics (void)
 void
 lto_promote_statics_nonwpa (void)
 {
-  symtab_node node;
+  symtab_node *node;
   FOR_EACH_SYMBOL (node)
     rename_statics (NULL, node);
 }
diff --git a/gcc/lto/lto-symtab.c b/gcc/lto/lto-symtab.c
index ec42a93..ced6cf9 100644
--- a/gcc/lto/lto-symtab.c
+++ b/gcc/lto/lto-symtab.c
@@ -113,7 +113,7 @@  lto_varpool_replace_node (struct varpool_node *vnode,
    should be emitted.  */
 
 static bool
-lto_symtab_merge (symtab_node prevailing, symtab_node entry)
+lto_symtab_merge (symtab_node *prevailing, symtab_node *entry)
 {
   tree prevailing_decl = prevailing->decl;
   tree decl = entry->decl;
@@ -216,7 +216,7 @@  lto_symtab_merge (symtab_node prevailing, symtab_node entry)
    entry.  */
 
 static bool
-lto_symtab_resolve_replaceable_p (symtab_node e)
+lto_symtab_resolve_replaceable_p (symtab_node *e)
 {
   if (DECL_EXTERNAL (e->decl)
       || DECL_COMDAT (e->decl)
@@ -236,7 +236,7 @@  lto_symtab_resolve_replaceable_p (symtab_node e)
    handle renaming of static later in partitioning).  */
 
 static bool
-lto_symtab_symbol_p (symtab_node e)
+lto_symtab_symbol_p (symtab_node *e)
 {
   if (!TREE_PUBLIC (e->decl) && !DECL_EXTERNAL (e->decl))
     return false;
@@ -246,7 +246,7 @@  lto_symtab_symbol_p (symtab_node e)
 /* Return true if the symtab entry E can be the prevailing one.  */
 
 static bool
-lto_symtab_resolve_can_prevail_p (symtab_node e)
+lto_symtab_resolve_can_prevail_p (symtab_node *e)
 {
   if (!lto_symtab_symbol_p (e))
     return false;
@@ -263,11 +263,11 @@  lto_symtab_resolve_can_prevail_p (symtab_node e)
 /* Resolve the symbol with the candidates in the chain *SLOT and store
    their resolutions.  */
 
-static symtab_node
-lto_symtab_resolve_symbols (symtab_node first)
+static symtab_node *
+lto_symtab_resolve_symbols (symtab_node *first)
 {
-  symtab_node e;
-  symtab_node prevailing = NULL;
+  symtab_node *e;
+  symtab_node *prevailing = NULL;
 
   /* Always set e->node so that edges are updated to reflect decl merging. */
   for (e = first; e; e = e->next_sharing_asm_name)
@@ -359,10 +359,10 @@  lto_symtab_resolve_symbols (symtab_node first)
    do not issue further diagnostics.*/
 
 static void
-lto_symtab_merge_decls_2 (symtab_node first, bool diagnosed_p)
+lto_symtab_merge_decls_2 (symtab_node *first, bool diagnosed_p)
 {
-  symtab_node prevailing;
-  symtab_node e;
+  symtab_node *prevailing;
+  symtab_node *e;
   vec<tree> mismatches = vNULL;
   unsigned i;
   tree decl;
@@ -412,10 +412,10 @@  lto_symtab_merge_decls_2 (symtab_node first, bool diagnosed_p)
 /* Helper to process the decl chain for the symbol table entry *SLOT.  */
 
 static void
-lto_symtab_merge_decls_1 (symtab_node first)
+lto_symtab_merge_decls_1 (symtab_node *first)
 {
-  symtab_node e;
-  symtab_node prevailing;
+  symtab_node *e;
+  symtab_node *prevailing;
   bool diagnosed_p = false;
 
   if (cgraph_dump_file)
@@ -522,7 +522,7 @@  lto_symtab_merge_decls_1 (symtab_node first)
 void
 lto_symtab_merge_decls (void)
 {
-  symtab_node node;
+  symtab_node *node;
 
   /* Populate assembler name hash.   */
   symtab_initialize_asm_name_hash ();
@@ -536,10 +536,10 @@  lto_symtab_merge_decls (void)
 /* Helper to process the decl chain for the symbol table entry *SLOT.  */
 
 static void
-lto_symtab_merge_symbols_1 (symtab_node prevailing)
+lto_symtab_merge_symbols_1 (symtab_node *prevailing)
 {
-  symtab_node e;
-  symtab_node next;
+  symtab_node *e;
+  symtab_node *next;
 
   /* Replace the cgraph node of each entry with the prevailing one.  */
   for (e = prevailing->next_sharing_asm_name; e;
@@ -565,7 +565,7 @@  lto_symtab_merge_symbols_1 (symtab_node prevailing)
 void
 lto_symtab_merge_symbols (void)
 {
-  symtab_node node;
+  symtab_node *node;
 
   if (!flag_ltrans)
     {
@@ -587,11 +587,11 @@  lto_symtab_merge_symbols (void)
 	{
 	  cgraph_node *cnode, *cnode2;
 	  varpool_node *vnode;
-	  symtab_node node2;
+	  symtab_node *node2;
 
 	  if (!node->analyzed && node->alias_target)
 	    {
-	      symtab_node tgt = symtab_node_for_asm (node->alias_target);
+	      symtab_node *tgt = symtab_node_for_asm (node->alias_target);
 	      gcc_assert (node->weakref);
 	      if (tgt)
 		symtab_resolve_alias (node, tgt);
@@ -639,7 +639,7 @@  lto_symtab_merge_symbols (void)
 tree
 lto_symtab_prevailing_decl (tree decl)
 {
-  symtab_node ret;
+  symtab_node *ret;
 
   /* Builtins and local symbols are their own prevailing decl.  */
   if ((!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) || is_builtin_fn (decl))
diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
index 7015f54..88d9d00 100644
--- a/gcc/lto/lto.c
+++ b/gcc/lto/lto.c
@@ -3098,14 +3098,14 @@  lto_wpa_write_files (void)
 	  for (lsei = lsei_start_in_partition (part->encoder); !lsei_end_p (lsei);
 	       lsei_next_in_partition (&lsei))
 	    {
-	      symtab_node node = lsei_node (lsei);
+	      symtab_node *node = lsei_node (lsei);
 	      fprintf (cgraph_dump_file, "%s ", symtab_node_asm_name (node));
 	    }
 	  fprintf (cgraph_dump_file, "\n  Symbols in boundary: ");
 	  for (lsei = lsei_start (part->encoder); !lsei_end_p (lsei);
 	       lsei_next (&lsei))
 	    {
-	      symtab_node node = lsei_node (lsei);
+	      symtab_node *node = lsei_node (lsei);
 	      if (!lto_symtab_encoder_in_partition_p (part->encoder, node))
 		{
 	          fprintf (cgraph_dump_file, "%s ", symtab_node_asm_name (node));
@@ -3369,7 +3369,7 @@  read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
   int count = 0;
   struct lto_file_decl_data **decl_data;
   void **res;
-  symtab_node snode;
+  symtab_node *snode;
 
   init_cgraph ();
 
@@ -3675,7 +3675,7 @@  print_lto_report_1 (void)
 static void
 do_whole_program_analysis (void)
 {
-  symtab_node node;
+  symtab_node *node;
 
   timevar_start (TV_PHASE_OPT_GEN);
 
diff --git a/gcc/symtab.c b/gcc/symtab.c
index 2b612b3..e10906c 100644
--- a/gcc/symtab.c
+++ b/gcc/symtab.c
@@ -48,12 +48,12 @@  const char * const ld_plugin_symbol_resolution_names[]=
 };
 
 /* Hash table used to convert declarations into nodes.  */
-static GTY((param_is (symtab_node_base))) htab_t symtab_hash;
+static GTY((param_is (symtab_node))) htab_t symtab_hash;
 /* Hash table used to convert assembler names into nodes.  */
-static GTY((param_is (symtab_node_base))) htab_t assembler_name_hash;
+static GTY((param_is (symtab_node))) htab_t assembler_name_hash;
 
 /* Linked list of symbol table nodes.  */
-symtab_node symtab_nodes;
+symtab_node *symtab_nodes;
 
 /* The order index of the next symtab node to be created.  This is
    used so that we can sort the cgraph nodes in order by when we saw
@@ -65,7 +65,7 @@  int symtab_order;
 static hashval_t
 hash_node (const void *p)
 {
-  const_symtab_node n = (const_symtab_node ) p;
+  const symtab_node *n = (const symtab_node *) p;
   return (hashval_t) DECL_UID (n->decl);
 }
 
@@ -75,8 +75,8 @@  hash_node (const void *p)
 static int
 eq_node (const void *p1, const void *p2)
 {
-  const_symtab_node n1 = (const_symtab_node) p1;
-  const_symtab_node n2 = (const_symtab_node) p2;
+  const symtab_node *n1 = (const symtab_node *) p1;
+  const symtab_node *n2 = (const symtab_node *) p2;
   return DECL_UID (n1->decl) == DECL_UID (n2->decl);
 }
 
@@ -85,7 +85,7 @@  eq_node (const void *p1, const void *p2)
 static hashval_t
 hash_node_by_assembler_name (const void *p)
 {
-  const_symtab_node n = (const_symtab_node) p;
+  const symtab_node *n = (const symtab_node *) p;
   return (hashval_t) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n->decl));
 }
 
@@ -94,7 +94,7 @@  hash_node_by_assembler_name (const void *p)
 static int
 eq_assembler_name (const void *p1, const void *p2)
 {
-  const_symtab_node n1 = (const_symtab_node) p1;
+  const symtab_node *n1 = (const symtab_node *) p1;
   const_tree name = (const_tree)p2;
   return (decl_assembler_name_equal (n1->decl, name));
 }
@@ -102,7 +102,7 @@  eq_assembler_name (const void *p1, const void *p2)
 /* Insert NODE to assembler name hash.  */
 
 static void
-insert_to_assembler_name_hash (symtab_node node, bool with_clones)
+insert_to_assembler_name_hash (symtab_node *node, bool with_clones)
 {
   if (is_a <varpool_node> (node) && DECL_HARD_REGISTER (node->decl))
     return;
@@ -120,9 +120,9 @@  insert_to_assembler_name_hash (symtab_node node, bool with_clones)
 					decl_assembler_name_hash (name),
 					INSERT);
       gcc_assert (*aslot != node);
-      node->next_sharing_asm_name = (symtab_node)*aslot;
+      node->next_sharing_asm_name = (symtab_node *)*aslot;
       if (*aslot != NULL)
-	((symtab_node)*aslot)->previous_sharing_asm_name = node;
+	((symtab_node *)*aslot)->previous_sharing_asm_name = node;
       *aslot = node;
 
       /* Update also possible inline clones sharing a decl.  */
@@ -138,7 +138,7 @@  insert_to_assembler_name_hash (symtab_node node, bool with_clones)
 /* Remove NODE from assembler name hash.  */
 
 static void
-unlink_from_assembler_name_hash (symtab_node node, bool with_clones)
+unlink_from_assembler_name_hash (symtab_node *node, bool with_clones)
 {
   if (assembler_name_hash)
     {
@@ -181,7 +181,7 @@  unlink_from_assembler_name_hash (symtab_node node, bool with_clones)
 /* Arrange node to be first in its entry of assembler_name_hash.  */
 
 void
-symtab_prevail_in_asm_name_hash (symtab_node node)
+symtab_prevail_in_asm_name_hash (symtab_node *node)
 {
   unlink_from_assembler_name_hash (node, false);
   insert_to_assembler_name_hash (node, false);
@@ -192,10 +192,10 @@  symtab_prevail_in_asm_name_hash (symtab_node node)
    cgraph/varpool node creation routines.  */
 
 void
-symtab_register_node (symtab_node node)
+symtab_register_node (symtab_node *node)
 {
-  struct symtab_node_base key;
-  symtab_node *slot;
+  struct symtab_node key;
+  symtab_node **slot;
 
   node->next = symtab_nodes;
   node->previous = NULL;
@@ -206,7 +206,7 @@  symtab_register_node (symtab_node node)
   if (!symtab_hash)
     symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
   key.decl = node->decl;
-  slot = (symtab_node *) htab_find_slot (symtab_hash, &key, INSERT);
+  slot = (symtab_node **) htab_find_slot (symtab_hash, &key, INSERT);
   if (*slot == NULL)
     *slot = node;
 
@@ -223,15 +223,15 @@  symtab_register_node (symtab_node node)
    of inline clones.  */
 
 void
-symtab_insert_node_to_hashtable (symtab_node node)
+symtab_insert_node_to_hashtable (symtab_node *node)
 {
-  struct symtab_node_base key;
-  symtab_node *slot;
+  struct symtab_node key;
+  symtab_node **slot;
 
   if (!symtab_hash)
     symtab_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
   key.decl = node->decl;
-  slot = (symtab_node *) htab_find_slot (symtab_hash, &key, INSERT);
+  slot = (symtab_node **) htab_find_slot (symtab_hash, &key, INSERT);
   *slot = node;
 }
 
@@ -239,7 +239,7 @@  symtab_insert_node_to_hashtable (symtab_node node)
    cgraph/varpool node removal routines.  */
 
 void
-symtab_unregister_node (symtab_node node)
+symtab_unregister_node (symtab_node *node)
 {
   void **slot;
   ipa_remove_all_references (&node->ref_list);
@@ -247,7 +247,7 @@  symtab_unregister_node (symtab_node node)
 
   if (node->same_comdat_group)
     {
-      symtab_node prev;
+      symtab_node *prev;
       for (prev = node->same_comdat_group;
 	   prev->same_comdat_group != node;
 	   prev = prev->same_comdat_group)
@@ -275,7 +275,7 @@  symtab_unregister_node (symtab_node node)
   gcc_assert ((slot && *slot) || in_lto_p);
   if (slot && *slot && *slot == node)
     {
-      symtab_node replacement_node = NULL;
+      symtab_node *replacement_node = NULL;
       if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
 	replacement_node = cgraph_find_replacement_node (cnode);
       if (!replacement_node)
@@ -290,11 +290,11 @@  symtab_unregister_node (symtab_node node)
 /* Return symbol table node associated with DECL, if any,
    and NULL otherwise.  */
 
-symtab_node
+symtab_node *
 symtab_get_node (const_tree decl)
 {
-  symtab_node *slot;
-  struct symtab_node_base key;
+  symtab_node **slot;
+  struct symtab_node key;
 
 #ifdef ENABLE_CHECKING
   /* Check that we are called for sane type of object - functions
@@ -310,7 +310,7 @@  symtab_get_node (const_tree decl)
 
   key.decl = CONST_CAST2 (tree, const_tree, decl);
 
-  slot = (symtab_node *) htab_find_slot (symtab_hash, &key,
+  slot = (symtab_node **) htab_find_slot (symtab_hash, &key,
 					 NO_INSERT);
 
   if (slot)
@@ -321,7 +321,7 @@  symtab_get_node (const_tree decl)
 /* Remove symtab NODE from the symbol table.  */
 
 void
-symtab_remove_node (symtab_node node)
+symtab_remove_node (symtab_node *node)
 {
   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
     cgraph_remove_node (cnode);
@@ -334,7 +334,7 @@  symtab_remove_node (symtab_node node)
 void
 symtab_initialize_asm_name_hash (void)
 {
-  symtab_node node;
+  symtab_node *node;
   if (!assembler_name_hash)
     {
       assembler_name_hash =
@@ -348,10 +348,10 @@  symtab_initialize_asm_name_hash (void)
 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
    Return NULL if there's no such node.  */
 
-symtab_node
+symtab_node *
 symtab_node_for_asm (const_tree asmname)
 {
-  symtab_node node;
+  symtab_node *node;
   void **slot;
 
   symtab_initialize_asm_name_hash ();
@@ -361,7 +361,7 @@  symtab_node_for_asm (const_tree asmname)
 
   if (slot)
     {
-      node = (symtab_node) *slot;
+      node = (symtab_node *) *slot;
       return node;
     }
   return NULL;
@@ -372,7 +372,7 @@  symtab_node_for_asm (const_tree asmname)
 void
 change_decl_assembler_name (tree decl, tree name)
 {
-  symtab_node node = NULL;
+  symtab_node *node = NULL;
 
   /* We can have user ASM names on things, like global register variables, that
      are not in the symbol table.  */
@@ -414,8 +414,8 @@  change_decl_assembler_name (tree decl, tree name)
 /* Add NEW_ to the same comdat group that OLD is in.  */
 
 void
-symtab_add_to_same_comdat_group (symtab_node new_node,
-				 symtab_node old_node)
+symtab_add_to_same_comdat_group (symtab_node *new_node,
+				 symtab_node *old_node)
 {
   gcc_assert (DECL_ONE_ONLY (old_node->decl));
   gcc_assert (!new_node->same_comdat_group);
@@ -427,7 +427,7 @@  symtab_add_to_same_comdat_group (symtab_node new_node,
     old_node->same_comdat_group = new_node;
   else
     {
-      symtab_node n;
+      symtab_node *n;
       for (n = old_node->same_comdat_group;
 	   n->same_comdat_group != old_node;
 	   n = n->same_comdat_group)
@@ -439,10 +439,10 @@  symtab_add_to_same_comdat_group (symtab_node new_node,
 /* Dissolve the same_comdat_group list in which NODE resides.  */
 
 void
-symtab_dissolve_same_comdat_group_list (symtab_node node)
+symtab_dissolve_same_comdat_group_list (symtab_node *node)
 {
-  symtab_node n = node;
-  symtab_node next;
+  symtab_node *n = node;
+  symtab_node *next;
 
   if (!node->same_comdat_group)
     return;
@@ -460,7 +460,7 @@  symtab_dissolve_same_comdat_group_list (symtab_node node)
    is unknown go with identifier name.  */
 
 const char *
-symtab_node_asm_name (symtab_node node)
+symtab_node_asm_name (symtab_node *node)
 {
   if (!DECL_ASSEMBLER_NAME_SET_P (node->decl))
     return lang_hooks.decl_printable_name (node->decl, 2);
@@ -470,7 +470,7 @@  symtab_node_asm_name (symtab_node node)
 /* Return printable identifier name.  */
 
 const char *
-symtab_node_name (symtab_node node)
+symtab_node_name (symtab_node *node)
 {
   return lang_hooks.decl_printable_name (node->decl, 2);
 }
@@ -480,7 +480,7 @@  static const char * const symtab_type_names[] = {"symbol", "function", "variable
 /* Dump base fields of symtab nodes.  Not to be used directly.  */
 
 void
-dump_symtab_base (FILE *f, symtab_node node)
+dump_symtab_base (FILE *f, symtab_node *node)
 {
   static const char * const visibility_types[] = {
     "default", "protected", "hidden", "internal"
@@ -594,7 +594,7 @@  dump_symtab_base (FILE *f, symtab_node node)
 /* Dump symtab node.  */
 
 void
-dump_symtab_node (FILE *f, symtab_node node)
+dump_symtab_node (FILE *f, symtab_node *node)
 {
   if (cgraph_node *cnode = dyn_cast <cgraph_node> (node))
     dump_cgraph_node (f, cnode);
@@ -607,7 +607,7 @@  dump_symtab_node (FILE *f, symtab_node node)
 void
 dump_symtab (FILE *f)
 {
-  symtab_node node;
+  symtab_node *node;
   fprintf (f, "Symbol table:\n\n");
   FOR_EACH_SYMBOL (node)
     dump_symtab_node (f, node);
@@ -616,7 +616,7 @@  dump_symtab (FILE *f)
 /* Dump symtab node NODE to stderr.  */
 
 DEBUG_FUNCTION void
-debug_symtab_node (symtab_node node)
+debug_symtab_node (symtab_node *node)
 {
   dump_symtab_node (stderr, node);
 }
@@ -632,10 +632,10 @@  debug_symtab (void)
 /* Verify common part of symtab nodes.  */
 
 DEBUG_FUNCTION bool
-verify_symtab_base (symtab_node node)
+verify_symtab_base (symtab_node *node)
 {
   bool error_found = false;
-  symtab_node hashed_node;
+  symtab_node *hashed_node;
 
   if (is_a <cgraph_node> (node))
     {
@@ -728,7 +728,7 @@  verify_symtab_base (symtab_node node)
     }
   if (node->same_comdat_group)
     {
-      symtab_node n = node->same_comdat_group;
+      symtab_node *n = node->same_comdat_group;
 
       if (!DECL_ONE_ONLY (n->decl))
 	{
@@ -763,7 +763,7 @@  verify_symtab_base (symtab_node node)
 /* Verify consistency of NODE.  */
 
 DEBUG_FUNCTION void
-verify_symtab_node (symtab_node node)
+verify_symtab_node (symtab_node *node)
 {
   if (seen_error ())
     return;
@@ -785,7 +785,7 @@  verify_symtab_node (symtab_node node)
 DEBUG_FUNCTION void
 verify_symtab (void)
 {
-  symtab_node node;
+  symtab_node *node;
   FOR_EACH_SYMBOL (node)
    verify_symtab_node (node);
 }
@@ -806,7 +806,7 @@  resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
    Known only when doing LTO via linker plugin.  */
 
 bool
-symtab_used_from_object_file_p (symtab_node node)
+symtab_used_from_object_file_p (symtab_node *node)
 {
   if (!TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl))
     return false;
@@ -858,7 +858,7 @@  symtab_make_decl_local (tree decl)
 /* Return availability of NODE.  */
 
 enum availability
-symtab_node_availability (symtab_node node)
+symtab_node_availability (symtab_node *node)
 {
   if (is_a <cgraph_node> (node))
     return cgraph_function_body_availability (cgraph (node));
@@ -870,8 +870,8 @@  symtab_node_availability (symtab_node node)
    If NODE is not an alias, return NODE.
    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
 
-symtab_node
-symtab_alias_ultimate_target (symtab_node node, enum availability *availability)
+symtab_node *
+symtab_alias_ultimate_target (symtab_node *node, enum availability *availability)
 {
   bool weakref_p = false;
 
@@ -946,7 +946,7 @@  symtab_alias_ultimate_target (symtab_node node, enum availability *availability)
    copy the visibility from the target to get things right.  */
 
 void
-fixup_same_cpp_alias_visibility (symtab_node node, symtab_node target)
+fixup_same_cpp_alias_visibility (symtab_node *node, symtab_node *target)
 {
   if (is_a <cgraph_node> (node))
     {
@@ -982,9 +982,9 @@  fixup_same_cpp_alias_visibility (symtab_node node, symtab_node target)
    it returns false.  */
 
 bool
-symtab_resolve_alias (symtab_node node, symtab_node target)
+symtab_resolve_alias (symtab_node *node, symtab_node *target)
 {
-  symtab_node n;
+  symtab_node *n;
 
   gcc_assert (!node->analyzed
 	      && !vec_safe_length (node->ref_list.references));
@@ -1030,8 +1030,8 @@  symtab_resolve_alias (symtab_node node, symtab_node target)
    skipped. */
 
 bool
-symtab_for_node_and_aliases (symtab_node node,
-			     bool (*callback) (symtab_node, void *),
+symtab_for_node_and_aliases (symtab_node *node,
+			     bool (*callback) (symtab_node *, void *),
 			     void *data,
 			     bool include_overwritable)
 {
@@ -1043,7 +1043,7 @@  symtab_for_node_and_aliases (symtab_node node,
   for (i = 0; ipa_ref_list_referring_iterate (&node->ref_list, i, ref); i++)
     if (ref->use == IPA_REF_ALIAS)
       {
-	symtab_node alias = ref->referring;
+	symtab_node *alias = ref->referring;
 	if (include_overwritable
 	    || symtab_node_availability (alias) > AVAIL_OVERWRITABLE)
           if (symtab_for_node_and_aliases (alias, callback, data,
@@ -1056,11 +1056,11 @@  symtab_for_node_and_aliases (symtab_node node,
 /* Worker searching nonoverwritable alias.  */
 
 static bool
-symtab_nonoverwritable_alias_1 (symtab_node node, void *data)
+symtab_nonoverwritable_alias_1 (symtab_node *node, void *data)
 {
   if (decl_binds_to_current_def_p (node->decl))
     {
-      *(symtab_node *)data = node;
+      *(symtab_node **)data = node;
       return true;
     }
   return false;
@@ -1070,11 +1070,11 @@  symtab_nonoverwritable_alias_1 (symtab_node node, void *data)
    definition, return NODE. Otherwise look for alias with such property and if
    none exists, introduce new one.  */
 
-symtab_node
-symtab_nonoverwritable_alias (symtab_node node)
+symtab_node *
+symtab_nonoverwritable_alias (symtab_node *node)
 {
   tree new_decl;
-  symtab_node new_node = NULL;
+  symtab_node *new_node = NULL;
 
   /* First try to look up existing alias or base object
      (if that is already non-overwritable).  */
@@ -1121,12 +1121,12 @@  symtab_nonoverwritable_alias (symtab_node node)
 /* Return true if A and B represents semantically equivalent symbols.  */
 
 bool
-symtab_semantically_equivalent_p (symtab_node a,
-				  symtab_node b)
+symtab_semantically_equivalent_p (symtab_node *a,
+				  symtab_node *b)
 {
   enum availability avail;
-  symtab_node ba;
-  symtab_node bb;
+  symtab_node *ba;
+  symtab_node *bb;
 
   /* Equivalent functions are equivalent.  */
   if (a->decl == b->decl)
diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index 75692c0..18360e5 100644
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -1205,8 +1205,8 @@  init_node_map (bool local)
 			   n->profile_id,
 			   cgraph_node_name (n),
 			   n->order,
-			   symtab_node_name (*(symtab_node*)val),
-			   (*(symtab_node *)val)->order);
+			   symtab_node_name (*(symtab_node **)val),
+			   (*(symtab_node **)val)->order);
 		n->profile_id = (n->profile_id + 1) & 0x7fffffff;
 	      }
 	  }
diff --git a/gcc/varasm.c b/gcc/varasm.c
index a624851..e976c5c 100644
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -5400,7 +5400,7 @@  weak_finish_1 (tree decl)
 static tree
 find_decl (tree target)
 {
-  symtab_node node = symtab_node_for_asm (target);
+  symtab_node *node = symtab_node_for_asm (target);
   if (node)
     return node->decl;
   return NULL_TREE;
diff --git a/gcc/varpool.c b/gcc/varpool.c
index e14c811..f847577 100644
--- a/gcc/varpool.c
+++ b/gcc/varpool.c
@@ -140,7 +140,7 @@  debug_varpool (void)
 struct varpool_node *
 varpool_node_for_asm (tree asmname)
 {
-  if (symtab_node node = symtab_node_for_asm (asmname))
+  if (symtab_node *node = symtab_node_for_asm (asmname))
     return dyn_cast <varpool_node> (node);
   else
     return NULL;
@@ -417,7 +417,7 @@  varpool_remove_unreferenced_decls (void)
 
       if (node->same_comdat_group)
 	{
-	  symtab_node next;
+	  symtab_node *next;
 	  for (next = node->same_comdat_group;
 	       next != node;
 	       next = next->same_comdat_group)