Index: src/gcc/ipa-prop.c
===================================================================
--- src.orig/gcc/ipa-prop.c
+++ src/gcc/ipa-prop.c
@@ -265,34 +265,45 @@ void
 ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
 {
   struct cgraph_edge *cs;
-  int i;
 
-  fprintf (f, "  Jump functions of caller  %s:\n", cgraph_node_name (node));
+  fprintf (f, "  Jump functions of caller  %s/%i:\n", cgraph_node_name (node),
+	   node->symbol.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->uid,
-	       xstrdup (cgraph_node_name (cs->callee)), cs->callee->uid);
+	       xstrdup (cgraph_node_name (node)), node->symbol.order,
+	       xstrdup (cgraph_node_name (cs->callee)),
+	       cs->callee->symbol.order);
       ipa_print_node_jump_functions_for_edge (f, cs);
     }
 
-  for (cs = node->indirect_calls, i = 0; cs; cs = cs->next_callee, i++)
+  for (cs = node->indirect_calls; cs; cs = cs->next_callee)
     {
+      struct cgraph_indirect_call_info *ii;
       if (!ipa_edge_args_info_available_for_edge_p (cs))
 	continue;
 
+      ii = cs->indirect_info;
+      if (ii->agg_contents)
+	fprintf (f, "    indirect aggregate callsite, calling param %i, "
+		 "offset " HOST_WIDE_INT_PRINT_DEC ", %s",
+		 ii->param_index, ii->offset,
+		 ii->by_ref ? "by reference" : "by_value");
+      else
+	fprintf (f, "    indirect %s callsite, calling param %i",
+		 ii->polymorphic ? "polymorphic" : "simple", ii->param_index);
+
       if (cs->call_stmt)
 	{
-	  fprintf (f, "    indirect callsite %d for stmt ", i);
+	  fprintf (f, ", for stmt ");
 	  print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
 	}
       else
-	fprintf (f, "    indirect callsite %d :\n", i);
+	fprintf (f, "\n");
       ipa_print_node_jump_functions_for_edge (f, cs);
-
     }
 }
 
@@ -2199,8 +2210,8 @@ ipa_make_edge_direct_to_target (struct c
 	{
 	  if (dump_file)
 	    fprintf (dump_file, "ipa-prop: Discovered direct call to non-function"
-				" in (%s/%i).\n",
-		     cgraph_node_name (ie->caller), ie->caller->uid);
+				" in %s/%i.\n",
+		     cgraph_node_name (ie->caller), ie->caller->symbol.order);
 	  return NULL;
 	}
     }
@@ -2221,8 +2232,10 @@ ipa_make_edge_direct_to_target (struct c
 	  if (dump_file)
 	    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->uid,
-		     xstrdup (cgraph_node_name (ie->callee)), ie->callee->uid);
+		     xstrdup (cgraph_node_name (ie->caller)),
+		     ie->caller->symbol.order,
+		     xstrdup (cgraph_node_name (ie->callee)),
+		     ie->callee->symbol.order);
 	  return NULL;
 	}
       callee = cgraph_get_create_real_symbol_node (target);
@@ -2244,8 +2257,10 @@ ipa_make_edge_direct_to_target (struct c
       fprintf (dump_file, "ipa-prop: Discovered %s call to a known target "
 	       "(%s/%i -> %s/%i), for stmt ",
 	       ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
-	       xstrdup (cgraph_node_name (ie->caller)), ie->caller->uid,
-	       xstrdup (cgraph_node_name (ie->callee)), ie->callee->uid);
+	       xstrdup (cgraph_node_name (ie->caller)),
+	       ie->caller->symbol.order,
+	       xstrdup (cgraph_node_name (ie->callee)),
+	       ie->callee->symbol.order);
       if (ie->call_stmt)
 	print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
       else
@@ -2298,7 +2313,7 @@ remove_described_reference (symtab_node
   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->uid, xstrdup (symtab_node_name (symbol)));
+	     origin->caller->symbol.order, xstrdup (symtab_node_name (symbol)));
 }
 
 /* If JFUNC has a reference description with refcount different from
@@ -2568,8 +2583,8 @@ propagate_controlled_uses (struct cgraph
 		    fprintf (dump_file, "ipa-prop: Removing cloning-created "
 			     "reference from %s/%i to %s/%i.\n",
 			     xstrdup (cgraph_node_name (new_root)),
-			     new_root->uid,
-			     xstrdup (cgraph_node_name (n)), n->uid);
+			     new_root->symbol.order,
+			     xstrdup (cgraph_node_name (n)), n->symbol.order);
 		  ipa_remove_reference (ref);
 		}
 	    }
@@ -2608,9 +2623,9 @@ propagate_controlled_uses (struct cgraph
 				     "cloning-created reference "
 				     "from %s/%i to %s/%i.\n",
 				     xstrdup (cgraph_node_name (clone)),
-				     clone->uid,
+				     clone->symbol.order,
 				     xstrdup (cgraph_node_name (n)),
-				     n->uid);
+				     n->symbol.order);
 			  ipa_remove_reference (ref);
 			}
 		      clone = clone->callers->caller;
@@ -2957,8 +2972,8 @@ ipa_print_node_params (FILE *f, struct c
   if (!node->analyzed)
     return;
   info = IPA_NODE_REF (node);
-  fprintf (f, "  function  %s parameter descriptors:\n",
-	   cgraph_node_name (node));
+  fprintf (f, "  function  %s/%i parameter descriptors:\n",
+	   cgraph_node_name (node), node->symbol.order);
   count = ipa_get_param_count (info);
   for (i = 0; i < count; i++)
     {
@@ -4200,7 +4215,7 @@ ipcp_transform_function (struct cgraph_n
 
   if (dump_file)
     fprintf (dump_file, "Modification phase of node %s/%i\n",
-	     cgraph_node_name (node), node->uid);
+	     cgraph_node_name (node), node->symbol.order);
 
   aggval = ipa_get_agg_replacements_for_node (node);
   if (!aggval)
Index: src/gcc/cgraph.c
===================================================================
--- src.orig/gcc/cgraph.c
+++ src/gcc/cgraph.c
@@ -1049,8 +1049,8 @@ cgraph_redirect_edge_call_stmt_to_callee
   if (cgraph_dump_file)
     {
       fprintf (cgraph_dump_file, "updating call of %s/%i -> %s/%i: ",
-	       xstrdup (cgraph_node_name (e->caller)), e->caller->uid,
-	       xstrdup (cgraph_node_name (e->callee)), e->callee->uid);
+	       xstrdup (cgraph_node_name (e->caller)), e->caller->symbol.order,
+	       xstrdup (cgraph_node_name (e->callee)), e->callee->symbol.order);
       print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
       if (e->callee->clone.combined_args_to_skip)
 	{
@@ -2642,11 +2642,12 @@ cgraph_get_create_real_symbol_node (tree
       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->uid);
+		 xstrdup (cgraph_node_name (node)), node->symbol.order);
     }
   else if (dump_file)
     fprintf (dump_file, "Introduced new external node "
-	     "(%s/%i).\n", xstrdup (cgraph_node_name (node)), node->uid);
+	     "(%s/%i).\n", xstrdup (cgraph_node_name (node)),
+	     node->symbol.order);
   return node;
 }
 #include "gt-cgraph.h"
Index: src/gcc/ipa-cp.c
===================================================================
--- src.orig/gcc/ipa-cp.c
+++ src/gcc/ipa-cp.c
@@ -369,7 +369,8 @@ print_lattice (FILE * f, struct ipcp_lat
 
 	  fprintf (f, " [from:");
 	  for (s = val->sources; s; s = s->next)
-	    fprintf (f, " %i(%i)", s->cs->caller->uid,s->cs->frequency);
+	    fprintf (f, " %i(%i)", s->cs->caller->symbol.order,
+		     s->cs->frequency);
 	  fprintf (f, "]");
 	}
 
@@ -397,7 +398,8 @@ print_all_lattices (FILE * f, bool dump_
       struct ipa_node_params *info;
 
       info = IPA_NODE_REF (node);
-      fprintf (f, "  Node: %s/%i:\n", cgraph_node_name (node), node->uid);
+      fprintf (f, "  Node: %s/%i:\n", cgraph_node_name (node),
+	       node->symbol.order);
       count = ipa_get_param_count (info);
       for (i = 0; i < count; i++)
 	{
@@ -447,7 +449,7 @@ determine_versionability (struct cgraph_
 
   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->uid, reason);
+	     cgraph_node_name (node), node->symbol.order, reason);
 
   node->local.versionable = (reason == NULL);
 }
@@ -727,7 +729,7 @@ initialize_node_lattices (struct cgraph_
       if (dump_file && (dump_flags & TDF_DETAILS)
 	  && !node->alias && !node->thunk.thunk_p)
 	fprintf (dump_file, "Marking all lattices of %s/%i as %s\n",
-		 cgraph_node_name (node), node->uid,
+		 cgraph_node_name (node), node->symbol.order,
 		 disable ? "BOTTOM" : "VARIABLE");
     }
 
@@ -1820,7 +1822,7 @@ estimate_local_effects (struct cgraph_no
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "\nEstimating effects for %s/%i, base_time: %i.\n",
-	     cgraph_node_name (node), node->uid, base_time);
+	     cgraph_node_name (node), node->symbol.order, base_time);
 
   always_const = gather_context_independent_values (info, &known_csts,
 						    &known_binfos, &known_aggs,
@@ -2570,7 +2572,7 @@ update_profiling_info (struct cgraph_nod
 	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->uid,
+		 cgraph_node_name (orig_node), orig_node->symbol.order,
 		 (HOST_WIDE_INT) orig_node_count,
 		 (HOST_WIDE_INT) (orig_sum + new_sum));
 
@@ -2704,7 +2706,7 @@ create_specialized_node (struct cgraph_n
   if (dump_file && (dump_flags & TDF_DETAILS))
     {
       fprintf (dump_file, "     the new node is %s/%i.\n",
-	       cgraph_node_name (new_node), new_node->uid);
+	       cgraph_node_name (new_node), new_node->symbol.order);
       if (aggvals)
 	ipa_dump_agg_replacement_values (dump_file, aggvals);
     }
@@ -3254,9 +3256,9 @@ perhaps_add_new_callers (struct cgraph_n
 		    fprintf (dump_file, " - adding an extra caller %s/%i"
 			     " of %s/%i\n",
 			     xstrdup (cgraph_node_name (cs->caller)),
-			     cs->caller->uid,
+			     cs->caller->symbol.order,
 			     xstrdup (cgraph_node_name (val->spec_node)),
-			     val->spec_node->uid);
+			     val->spec_node->symbol.order);
 
 		  cgraph_redirect_edge_callee (cs, val->spec_node);
 		  redirected_sum += cs->count;
@@ -3361,7 +3363,7 @@ decide_about_value (struct cgraph_node *
 
   if (dump_file)
     fprintf (dump_file, "  Creating a specialized node of %s/%i.\n",
-	     cgraph_node_name (node), node->uid);
+	     cgraph_node_name (node), node->symbol.order);
 
   callers = gather_edges_for_value (val, caller_count);
   kv = known_csts.copy ();
@@ -3398,7 +3400,7 @@ decide_whether_version_node (struct cgra
 
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "\nEvaluating opportunities for %s/%i.\n",
-	     cgraph_node_name (node), node->uid);
+	     cgraph_node_name (node), node->symbol.order);
 
   gather_context_independent_values (info, &known_csts, &known_binfos,
 				  info->do_clone_for_all_contexts ? &known_aggs
@@ -3442,7 +3444,7 @@ decide_whether_version_node (struct cgra
       if (dump_file)
 	fprintf (dump_file, " - Creating a specialized node of %s/%i "
 		 "for all known contexts.\n", cgraph_node_name (node),
-		 node->uid);
+		 node->symbol.order);
 
       callers = collect_callers_of_node (node);
       move_binfos_to_values (known_csts, known_binfos);
@@ -3533,7 +3535,7 @@ identify_dead_nodes (struct cgraph_node
       for (v = node; v ; v = ((struct ipa_dfs_info *) v->symbol.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->uid);
+		   cgraph_node_name (v), v->symbol.order);
     }
 }
 
Index: src/gcc/ipa-inline-analysis.c
===================================================================
--- src.orig/gcc/ipa-inline-analysis.c
+++ src/gcc/ipa-inline-analysis.c
@@ -1291,7 +1291,7 @@ dump_inline_edge_summary (FILE *f, int i
       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->uid,
+	       indent, "", cgraph_node_name (callee), callee->symbol.order,
 	       !edge->inline_failed
 	       ? "inlined" : cgraph_inline_failed_string (edge-> inline_failed),
 	       indent, "", es->loop_depth, edge->frequency,
@@ -1357,7 +1357,7 @@ dump_inline_summary (FILE *f, struct cgr
       size_time_entry *e;
       int i;
       fprintf (f, "Inline summary for %s/%i", cgraph_node_name (node),
-	       node->uid);
+	       node->symbol.order);
       if (DECL_DISREGARD_INLINE_LIMITS (node->symbol.decl))
 	fprintf (f, " always_inline");
       if (s->inlinable)
@@ -2870,7 +2870,8 @@ estimate_node_size_and_time (struct cgra
     {
       bool found = false;
       fprintf (dump_file, "   Estimating body: %s/%i\n"
-	       "   Known to be false: ", cgraph_node_name (node), node->uid);
+	       "   Known to be false: ", cgraph_node_name (node),
+	       node->symbol.order);
 
       for (i = predicate_not_inlined_condition;
 	   i < (predicate_first_dynamic_condition
@@ -3650,7 +3651,7 @@ inline_analyze_function (struct cgraph_n
 
   if (dump_file)
     fprintf (dump_file, "\nAnalyzing function: %s/%u\n",
-	     cgraph_node_name (node), node->uid);
+	     cgraph_node_name (node), node->symbol.order);
   if (optimize && !node->thunk.thunk_p)
     inline_indirect_intraprocedural_analysis (node);
   compute_inline_parameters (node, false);
Index: src/gcc/ipa-inline.c
===================================================================
--- src.orig/gcc/ipa-inline.c
+++ src/gcc/ipa-inline.c
@@ -218,8 +218,8 @@ report_inline_failed_reason (struct cgra
   if (dump_file)
     {
       fprintf (dump_file, "  not inlinable: %s/%i -> %s/%i, %s\n",
-	       xstrdup (cgraph_node_name (e->caller)), e->caller->uid,
-	       xstrdup (cgraph_node_name (e->callee)), e->callee->uid,
+	       xstrdup (cgraph_node_name (e->caller)), e->caller->symbol.order,
+	       xstrdup (cgraph_node_name (e->callee)), e->callee->symbol.order,
 	       cgraph_inline_failed_string (e->inline_failed));
     }
 }
@@ -424,8 +424,9 @@ want_early_inline_function_p (struct cgr
 	  if (dump_file)
 	    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->uid,
-		     xstrdup (cgraph_node_name (callee)), callee->uid,
+		     xstrdup (cgraph_node_name (e->caller)),
+		     e->caller->symbol.order,
+		     xstrdup (cgraph_node_name (callee)), callee->symbol.order,
 		     growth);
 	  want_inline = false;
 	}
@@ -434,8 +435,9 @@ want_early_inline_function_p (struct cgr
 	  if (dump_file)
 	    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->uid,
-		     xstrdup (cgraph_node_name (callee)), callee->uid,
+		     xstrdup (cgraph_node_name (e->caller)),
+		     e->caller->symbol.order,
+		     xstrdup (cgraph_node_name (callee)), callee->symbol.order,
 		     growth);
 	  want_inline = false;
 	}
@@ -446,8 +448,9 @@ want_early_inline_function_p (struct cgr
 	    fprintf (dump_file, "  will not early inline: %s/%i->%s/%i, "
 		     "growth %i exceeds --param early-inlining-insns "
 		     "divided by number of calls\n",
-		     xstrdup (cgraph_node_name (e->caller)), e->caller->uid,
-		     xstrdup (cgraph_node_name (callee)), callee->uid,
+		     xstrdup (cgraph_node_name (e->caller)),
+		     e->caller->symbol.order,
+		     xstrdup (cgraph_node_name (callee)), callee->symbol.order,
 		     growth);
 	  want_inline = false;
 	}
@@ -851,9 +854,9 @@ edge_badness (struct cgraph_edge *edge,
     {
       fprintf (dump_file, "    Badness calculation for %s/%i -> %s/%i\n",
 	       xstrdup (cgraph_node_name (edge->caller)),
-	       edge->caller->uid,
+	       edge->caller->symbol.order,
 	       xstrdup (cgraph_node_name (callee)),
-	       edge->callee->uid);
+	       edge->callee->symbol.order);
       fprintf (dump_file, "      size growth %i, time %i ",
 	       growth,
 	       edge_time);
@@ -1002,9 +1005,9 @@ update_edge_key (fibheap_t heap, struct
 	      fprintf (dump_file,
 		       "  decreasing badness %s/%i -> %s/%i, %i to %i\n",
 		       xstrdup (cgraph_node_name (edge->caller)),
-		       edge->caller->uid,
+		       edge->caller->symbol.order,
 		       xstrdup (cgraph_node_name (edge->callee)),
-		       edge->callee->uid,
+		       edge->callee->symbol.order,
 		       (int)n->key,
 		       badness);
 	    }
@@ -1019,9 +1022,9 @@ update_edge_key (fibheap_t heap, struct
 	   fprintf (dump_file,
 		    "  enqueuing call %s/%i -> %s/%i, badness %i\n",
 		    xstrdup (cgraph_node_name (edge->caller)),
-		    edge->caller->uid,
+		    edge->caller->symbol.order,
 		    xstrdup (cgraph_node_name (edge->callee)),
-		    edge->callee->uid,
+		    edge->callee->symbol.order,
 		    badness);
 	 }
       edge->aux = fibheap_insert (heap, badness, edge);
@@ -1465,7 +1468,7 @@ inline_small_functions (void)
       {
 	if (dump_file)
 	  fprintf (dump_file, "Enqueueing calls of %s/%i.\n",
-		   cgraph_node_name (node), node->uid);
+		   cgraph_node_name (node), node->symbol.order);
 
 	for (edge = node->callers; edge; edge = edge->next_caller)
 	  if (edge->inline_failed
@@ -1524,14 +1527,14 @@ inline_small_functions (void)
       if (dump_file)
 	{
 	  fprintf (dump_file,
-		   "\nConsidering %s with %i size\n",
-		   cgraph_node_name (callee),
+		   "\nConsidering %s/%i with %i size\n",
+		   cgraph_node_name (callee), callee->symbol.order,
 		   inline_summary (callee)->size);
 	  fprintf (dump_file,
-		   " to be inlined into %s in %s:%i\n"
+		   " 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),
+		   cgraph_node_name (edge->caller), edge->caller->symbol.order,
 		   flag_wpa ? "unknown"
 		   : gimple_filename ((const_gimple) edge->call_stmt),
 		   flag_wpa ? -1
Index: src/gcc/ipa-pure-const.c
===================================================================
--- src.orig/gcc/ipa-pure-const.c
+++ src/gcc/ipa-pure-const.c
@@ -1044,7 +1044,7 @@ pure_const_read_summary (void)
 		  int flags = flags_from_decl_or_type (node->symbol.decl);
 		  fprintf (dump_file, "Read info for %s/%i ",
 			   cgraph_node_name (node),
-			   node->uid);
+			   node->symbol.order);
 		  if (flags & ECF_CONST)
 		    fprintf (dump_file, " const");
 		  if (flags & ECF_PURE)
@@ -1143,7 +1143,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->uid,
+		     w->symbol.order,
 		     pure_const_names[w_l->pure_const_state],
 		     w_l->looping);
 
@@ -1190,7 +1190,7 @@ propagate_pure_const (void)
 		  fprintf (dump_file,
 			   "    Call to %s/%i",
 			   cgraph_node_name (e->callee),
-			   e->callee->uid);
+			   e->callee->symbol.order);
 		}
 	      if (avail > AVAIL_OVERWRITABLE)
 		{
Index: src/gcc/ipa-utils.c
===================================================================
--- src.orig/gcc/ipa-utils.c
+++ src/gcc/ipa-utils.c
@@ -465,7 +465,7 @@ dump_cgraph_node_set (FILE *f, cgraph_no
   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->uid);
+      fprintf (f, " %s/%i", cgraph_node_name (node), node->symbol.order);
     }
   fprintf (f, "\n");
 }
Index: src/gcc/lto-cgraph.c
===================================================================
--- src.orig/gcc/lto-cgraph.c
+++ src/gcc/lto-cgraph.c
@@ -979,7 +979,7 @@ input_node (struct lto_file_decl_data *f
      functions, they are expected to be read more than once.  */
   if (node->symbol.aux && !DECL_BUILT_IN (node->symbol.decl))
     internal_error ("bytecode stream: found multiple instances of cgraph "
-		    "node %d", node->uid);
+		    "node with uid %d", node->uid);
 
   bp = streamer_read_bitpack (ib);
   input_overwrite_node (file_data, node, tag, &bp);
Index: src/gcc/lto-symtab.c
===================================================================
--- src.orig/gcc/lto-symtab.c
+++ src/gcc/lto-symtab.c
@@ -46,9 +46,9 @@ lto_cgraph_replace_node (struct cgraph_n
     {
       fprintf (cgraph_dump_file, "Replacing cgraph node %s/%i by %s/%i"
  	       " for symbol %s\n",
-	       cgraph_node_name (node), node->uid,
+	       cgraph_node_name (node), node->symbol.order,
 	       cgraph_node_name (prevailing_node),
-	       prevailing_node->uid,
+	       prevailing_node->symbol.order,
 	       IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name)
 		 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (node->symbol.decl)))));
     }
Index: src/gcc/lto/lto-partition.c
===================================================================
--- src.orig/gcc/lto/lto-partition.c
+++ src/gcc/lto/lto-partition.c
@@ -690,8 +690,10 @@ lto_balanced_map (void)
 	  best_total_size = total_size;
 	}
       if (cgraph_dump_file)
-	fprintf (cgraph_dump_file, "Step %i: added %s/%i, size %i, cost %i/%i best %i/%i, step %i\n", i,
-		 cgraph_node_name (order[i]), order[i]->uid, partition->insns, cost, internal,
+	fprintf (cgraph_dump_file, "Step %i: added %s/%i, size %i, cost %i/%i "
+		 "best %i/%i, step %i\n", i,
+		 cgraph_node_name (order[i]), order[i]->symbol.order,
+		 partition->insns, cost, internal,
 		 best_cost, best_internal, best_i);
       /* Partition is too large, unwind into step when best cost was reached and
 	 start new partition.  */
Index: src/gcc/tree-pretty-print.c
===================================================================
--- src.orig/gcc/tree-pretty-print.c
+++ src/gcc/tree-pretty-print.c
@@ -3149,7 +3149,7 @@ dump_function_header (FILE *dump_file, t
     fprintf (dump_file, ", decl_uid=%d", DECL_UID (fdecl));
   if (node)
     {
-      fprintf (dump_file, ", cgraph_uid=%d)%s\n\n", node->uid,
+      fprintf (dump_file, ", symbol_order=%d)%s\n\n", node->symbol.order,
                node->frequency == NODE_FREQUENCY_HOT
                ? " (hot)"
                : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
Index: src/gcc/tree-sra.c
===================================================================
--- src.orig/gcc/tree-sra.c
+++ src/gcc/tree-sra.c
@@ -4797,10 +4797,11 @@ convert_callers_for_node (struct cgraph_
       push_cfun (DECL_STRUCT_FUNCTION (cs->caller->symbol.decl));
 
       if (dump_file)
-	fprintf (dump_file, "Adjusting call (%i -> %i) %s -> %s\n",
-		 cs->caller->uid, cs->callee->uid,
+	fprintf (dump_file, "Adjusting call %s/%i -> %s/%i\n",
 		 xstrdup (cgraph_node_name (cs->caller)),
-		 xstrdup (cgraph_node_name (cs->callee)));
+		 cs->caller->symbol.order,
+		 xstrdup (cgraph_node_name (cs->callee)),
+		 cs->callee->symbol.order);
 
       ipa_modify_call_arguments (cs, cs->call_stmt, *adjustments);
 
