gcc/cgraph.c

   1 /* Callgraph handling code.
   2    Copyright (C) 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Jan Hubicka
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /*  This file contains basic routines manipulating call graph and variable pool
  23
  24 The callgraph:
  25
  26     The call-graph is data structure designed for intra-procedural optimization
  27     but it is also used in non-unit-at-a-time compilation to allow easier code
  28     sharing.
  29
  30     The call-graph consist of nodes and edges represented via linked lists.
  31     Each function (external or not) corresponds to the unique node (in
  32     contrast to tree DECL nodes where we can have multiple nodes for each
  33     function).
  34
  35     The mapping from declarations to call-graph nodes is done using hash table
  36     based on DECL_ASSEMBLER_NAME, so it is essential for assembler name to
  37     not change once the declaration is inserted into the call-graph.
  38     The call-graph nodes are created lazily using cgraph_node function when
  39     called for unknown declaration.
  40
  41     When built, there is one edge for each direct call.  It is possible that
  42     the reference will be later optimized out.  The call-graph is built
  43     conservatively in order to make conservative data flow analysis possible.
  44
  45     The callgraph at the moment does not represent indirect calls or calls
  46     from other compilation unit.  Flag NEEDED is set for each node that may
  47     be accessed in such an invisible way and it shall be considered an
  48     entry point to the callgraph.
  49
  50     Intraprocedural information:
  51
  52       Callgraph is place to store data needed for intraprocedural optimization.
  53       All data structures are divided into three components: local_info that
  54       is produced while analyzing the function, global_info that is result
  55       of global walking of the callgraph on the end of compilation and
  56       rtl_info used by RTL backend to propagate data from already compiled
  57       functions to their callers.
  58
  59     Inlining plans:
  60
  61       The function inlining information is decided in advance and maintained
  62       in the callgraph as so called inline plan.
  63       For each inlined call, the callee's node is cloned to represent the
  64       new function copy produced by inliner.
  65       Each inlined call gets a unique corresponding clone node of the callee
  66       and the data structure is updated while inlining is performed, so
  67       the clones are eliminated and their callee edges redirected to the
  68       caller.
  69
  70       Each edge has "inline_failed" field.  When the field is set to NULL,
  71       the call will be inlined.  When it is non-NULL it contains a reason
  72       why inlining wasn't performed.
  73
  74
  75 The varpool data structure:
  76
  77     Varpool is used to maintain variables in similar manner as call-graph
  78     is used for functions.  Most of the API is symmetric replacing cgraph
  79     function prefix by cgraph_varpool  */
  80
  81
  82 #include "config.h"
  83 #include "system.h"
  84 #include "coretypes.h"
  85 #include "tm.h"
  86 #include "tree.h"
  87 #include "langhooks.h"
  88 #include "hashtab.h"
  89 #include "toplev.h"
  90 #include "flags.h"
  91 #include "ggc.h"
  92 #include "debug.h"
  93 #include "target.h"
  94 #include "cgraph.h"
  95 #include "varray.h"
  96 #include "output.h"
  97 #include "intl.h"
  98
  99 /* Hash table used to convert declarations into nodes.  */
 100 static GTY((param_is (struct cgraph_node))) htab_t cgraph_hash;
 101
 102 /* The linked list of cgraph nodes.  */
 103 struct cgraph_node *cgraph_nodes;
 104
 105 /* Queue of cgraph nodes scheduled to be lowered.  */
 106 struct cgraph_node *cgraph_nodes_queue;
 107
 108 /* Number of nodes in existence.  */
 109 int cgraph_n_nodes;
 110
 111 /* Maximal uid used in cgraph nodes.  */
 112 int cgraph_max_uid;
 113
 114 /* Set when whole unit has been analyzed so we can access global info.  */
 115 bool cgraph_global_info_ready = false;
 116
 117 /* Hash table used to convert declarations into nodes.  */
 118 static GTY((param_is (struct cgraph_varpool_node))) htab_t cgraph_varpool_hash;
 119
 120 /* Queue of cgraph nodes scheduled to be lowered and output.  */
 121 struct cgraph_varpool_node *cgraph_varpool_nodes_queue;
 122
 123 /* Number of nodes in existence.  */
 124 int cgraph_varpool_n_nodes;
 125
 126 /* The linked list of cgraph varpool nodes.  */
 127 static GTY(())  struct cgraph_varpool_node *cgraph_varpool_nodes;
 128
 129 static hashval_t hash_node (const void *);
 130 static int eq_node (const void *, const void *);
 131
 132 /* Returns a hash code for P.  */
 133
 134 static hashval_t
 135 hash_node (const void *p)
 136 {
 137   const struct cgraph_node *n = p;
 138   return (hashval_t) DECL_UID (n->decl);
 139 }
 140
 141 /* Returns nonzero if P1 and P2 are equal.  */
 142
 143 static int
 144 eq_node (const void *p1, const void *p2)
 145 {
 146   const struct cgraph_node *n1 = p1, *n2 = p2;
 147   return DECL_UID (n1->decl) == DECL_UID (n2->decl);
 148 }
 149
 150 /* Allocate new callgraph node and insert it into basic data structures.  */
 151 static struct cgraph_node *
 152 cgraph_create_node (void)
 153 {
 154   struct cgraph_node *node;
 155
 156   node = ggc_alloc_cleared (sizeof (*node));
 157   node->next = cgraph_nodes;
 158   node->uid = cgraph_max_uid++;
 159   if (cgraph_nodes)
 160     cgraph_nodes->previous = node;
 161   node->previous = NULL;
 162   cgraph_nodes = node;
 163   cgraph_n_nodes++;
 164   return node;
 165 }
 166
 167 /* Return cgraph node assigned to DECL.  Create new one when needed.  */
 168 struct cgraph_node *
 169 cgraph_node (tree decl)
 170 {
 171   struct cgraph_node key, *node, **slot;
 172
 173   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 174
 175   if (!cgraph_hash)
 176     cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
 177
 178   key.decl = decl;
 179
 180   slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
 181
 182   if (*slot)
 183     return *slot;
 184
 185   node = cgraph_create_node ();
 186   node->decl = decl;
 187   *slot = node;
 188   if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
 189     {
 190       node->origin = cgraph_node (DECL_CONTEXT (decl));
 191       node->next_nested = node->origin->nested;
 192       node->origin->nested = node;
 193     }
 194   return node;
 195 }
 196
 197 /* Return callgraph edge representing CALL_EXPR.  */
 198 struct cgraph_edge *
 199 cgraph_edge (struct cgraph_node *node, tree call_expr)
 200 {
 201   struct cgraph_edge *e;
 202
 203   /* This loop may turn out to be performance problem.  In such case adding
 204      hashtables into call nodes with very many edges is probably best
 205      solution.  It is not good idea to add pointer into CALL_EXPR itself
 206      because we want to make possible having multiple cgraph nodes representing
 207      different clones of the same body before the body is actually cloned.  */
 208   for (e = node->callees; e; e= e->next_callee)
 209     if (e->call_expr == call_expr)
 210       break;
 211   return e;
 212 }
 213
 214 /* Create edge from CALLER to CALLEE in the cgraph.  */
 215
 216 struct cgraph_edge *
 217 cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
 218                     tree call_expr)
 219 {
 220   struct cgraph_edge *edge = ggc_alloc (sizeof (struct cgraph_edge));
 221 #ifdef ENABLE_CHECKING
 222   struct cgraph_edge *e;
 223
 224   for (e = caller->callees; e; e = e->next_callee)
 225     gcc_assert (e->call_expr != call_expr);
 226 #endif
 227
 228   gcc_assert (TREE_CODE (call_expr) == CALL_EXPR);
 229
 230   if (!DECL_SAVED_TREE (callee->decl))
 231     edge->inline_failed = N_("function body not available");
 232   else if (callee->local.redefined_extern_inline)
 233     edge->inline_failed = N_("redefined extern inline functions are not "
 234                              "considered for inlining");
 235   else if (callee->local.inlinable)
 236     edge->inline_failed = N_("function not considered for inlining");
 237   else
 238     edge->inline_failed = N_("function not inlinable");
 239
 240   edge->aux = NULL;
 241
 242   edge->caller = caller;
 243   edge->callee = callee;
 244   edge->call_expr = call_expr;
 245   edge->next_caller = callee->callers;
 246   edge->next_callee = caller->callees;
 247   caller->callees = edge;
 248   callee->callers = edge;
 249   return edge;
 250 }
 251
 252 /* Remove the edge E the cgraph.  */
 253
 254 void
 255 cgraph_remove_edge (struct cgraph_edge *e)
 256 {
 257   struct cgraph_edge **edge, **edge2;
 258
 259   for (edge = &e->callee->callers; *edge && *edge != e;
 260        edge = &((*edge)->next_caller))
 261     continue;
 262   gcc_assert (*edge);
 263   *edge = (*edge)->next_caller;
 264   for (edge2 = &e->caller->callees; *edge2 && *edge2 != e;
 265        edge2 = &(*edge2)->next_callee)
 266     continue;
 267   gcc_assert (*edge2);
 268   *edge2 = (*edge2)->next_callee;
 269 }
 270
 271 /* Redirect callee of E to N.  The function does not update underlying
 272    call expression.  */
 273
 274 void
 275 cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
 276 {
 277   struct cgraph_edge **edge;
 278
 279   for (edge = &e->callee->callers; *edge && *edge != e;
 280        edge = &((*edge)->next_caller))
 281     continue;
 282   gcc_assert (*edge);
 283   *edge = (*edge)->next_caller;
 284   e->callee = n;
 285   e->next_caller = n->callers;
 286   n->callers = e;
 287 }
 288
 289 /* Remove the node from cgraph.  */
 290
 291 void
 292 cgraph_remove_node (struct cgraph_node *node)
 293 {
 294   void **slot;
 295   bool check_dead = 1;
 296
 297   while (node->callers)
 298     cgraph_remove_edge (node->callers);
 299   while (node->callees)
 300     cgraph_remove_edge (node->callees);
 301   while (node->nested)
 302     cgraph_remove_node (node->nested);
 303   if (node->origin)
 304     {
 305       struct cgraph_node **node2 = &node->origin->nested;
 306
 307       while (*node2 != node)
 308         node2 = &(*node2)->next_nested;
 309       *node2 = node->next_nested;
 310     }
 311   if (node->previous)
 312     node->previous->next = node->next;
 313   else
 314     cgraph_nodes = node->next;
 315   if (node->next)
 316     node->next->previous = node->previous;
 317   slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
 318   if (*slot == node)
 319     {
 320       if (node->next_clone)
 321         *slot = node->next_clone;
 322       else
 323         {
 324           htab_clear_slot (cgraph_hash, slot);
 325           if (!dump_enabled_p (TDI_tree_all))
 326             {
 327               DECL_SAVED_TREE (node->decl) = NULL;
 328               DECL_STRUCT_FUNCTION (node->decl) = NULL;
 329             }
 330           check_dead = false;
 331         }
 332     }
 333   else
 334     {
 335       struct cgraph_node *n;
 336
 337       for (n = *slot; n->next_clone != node; n = n->next_clone)
 338         continue;
 339       n->next_clone = node->next_clone;
 340     }
 341
 342   /* Work out whether we still need a function body (either there is inline
 343      clone or there is out of line function whose body is not written).  */
 344   if (check_dead && flag_unit_at_a_time)
 345     {
 346       struct cgraph_node *n;
 347
 348       for (n = *slot; n; n = n->next_clone)
 349         if (n->global.inlined_to
 350             || (!n->global.inlined_to
 351                 && !TREE_ASM_WRITTEN (n->decl) && !DECL_EXTERNAL (n->decl)))
 352           break;
 353       if (!n && !dump_enabled_p (TDI_tree_all))
 354         {
 355           DECL_SAVED_TREE (node->decl) = NULL;
 356           DECL_STRUCT_FUNCTION (node->decl) = NULL;
 357           DECL_INITIAL (node->decl) = error_mark_node;
 358         }
 359     }
 360   cgraph_n_nodes--;
 361   /* Do not free the structure itself so the walk over chain can continue.  */
 362 }
 363
 364 /* Notify finalize_compilation_unit that given node is reachable.  */
 365
 366 void
 367 cgraph_mark_reachable_node (struct cgraph_node *node)
 368 {
 369   if (!node->reachable && node->local.finalized)
 370     {
 371       notice_global_symbol (node->decl);
 372       node->reachable = 1;
 373
 374       node->next_needed = cgraph_nodes_queue;
 375       cgraph_nodes_queue = node;
 376     }
 377 }
 378
 379 /* Likewise indicate that a node is needed, i.e. reachable via some
 380    external means.  */
 381
 382 void
 383 cgraph_mark_needed_node (struct cgraph_node *node)
 384 {
 385   node->needed = 1;
 386   cgraph_mark_reachable_node (node);
 387 }
 388
 389 /* Return local info for the compiled function.  */
 390
 391 struct cgraph_local_info *
 392 cgraph_local_info (tree decl)
 393 {
 394   struct cgraph_node *node;
 395
 396   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 397   node = cgraph_node (decl);
 398   return &node->local;
 399 }
 400
 401 /* Return local info for the compiled function.  */
 402
 403 struct cgraph_global_info *
 404 cgraph_global_info (tree decl)
 405 {
 406   struct cgraph_node *node;
 407
 408   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
 409   node = cgraph_node (decl);
 410   return &node->global;
 411 }
 412
 413 /* Return local info for the compiled function.  */
 414
 415 struct cgraph_rtl_info *
 416 cgraph_rtl_info (tree decl)
 417 {
 418   struct cgraph_node *node;
 419
 420   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 421   node = cgraph_node (decl);
 422   if (decl != current_function_decl
 423       && !TREE_ASM_WRITTEN (node->decl))
 424     return NULL;
 425   return &node->rtl;
 426 }
 427
 428 /* Return name of the node used in debug output.  */
 429 const char *
 430 cgraph_node_name (struct cgraph_node *node)
 431 {
 432   return lang_hooks.decl_printable_name (node->decl, 2);
 433 }
 434
 435 /* Dump given cgraph node.  */
 436 void
 437 dump_cgraph_node (FILE *f, struct cgraph_node *node)
 438 {
 439   struct cgraph_edge *edge;
 440   fprintf (f, "%s/%i:", cgraph_node_name (node), node->uid);
 441   if (node->global.inlined_to)
 442     fprintf (f, " (inline copy in %s/%i)",
 443              cgraph_node_name (node->global.inlined_to),
 444              node->global.inlined_to->uid);
 445   if (node->local.self_insns)
 446     fprintf (f, " %i insns", node->local.self_insns);
 447   if (node->global.insns && node->global.insns != node->local.self_insns)
 448     fprintf (f, " (%i after inlining)", node->global.insns);
 449   if (node->origin)
 450     fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
 451   if (node->needed)
 452     fprintf (f, " needed");
 453   else if (node->reachable)
 454     fprintf (f, " reachable");
 455   if (DECL_SAVED_TREE (node->decl))
 456     fprintf (f, " tree");
 457   if (node->output)
 458     fprintf (f, " output");
 459   if (node->local.local)
 460     fprintf (f, " local");
 461   if (node->local.disregard_inline_limits)
 462     fprintf (f, " always_inline");
 463   else if (node->local.inlinable)
 464     fprintf (f, " inlinable");
 465   if (TREE_ASM_WRITTEN (node->decl))
 466     fprintf (f, " asm_written");
 467
 468   fprintf (f, "\n  called by: ");
 469   for (edge = node->callers; edge; edge = edge->next_caller)
 470     {
 471       fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
 472                edge->caller->uid);
 473       if (!edge->inline_failed)
 474         fprintf(f, "(inlined) ");
 475     }
 476
 477   fprintf (f, "\n  calls: ");
 478   for (edge = node->callees; edge; edge = edge->next_callee)
 479     {
 480       fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
 481                edge->callee->uid);
 482       if (!edge->inline_failed)
 483         fprintf(f, "(inlined) ");
 484     }
 485   fprintf (f, "\n");
 486 }
 487
 488 /* Dump the callgraph.  */
 489
 490 void
 491 dump_cgraph (FILE *f)
 492 {
 493   struct cgraph_node *node;
 494
 495   fprintf (f, "callgraph:\n\n");
 496   for (node = cgraph_nodes; node; node = node->next)
 497     dump_cgraph_node (f, node);
 498 }
 499
 500 /* Returns a hash code for P.  */
 501
 502 static hashval_t
 503 hash_varpool_node (const void *p)
 504 {
 505   const struct cgraph_varpool_node *n = p;
 506   return (hashval_t) DECL_UID (n->decl);
 507 }
 508
 509 /* Returns nonzero if P1 and P2 are equal.  */
 510
 511 static int
 512 eq_varpool_node (const void *p1, const void *p2)
 513 {
 514   const struct cgraph_varpool_node *n1 = p1, *n2 = p2;
 515   return DECL_UID (n1->decl) == DECL_UID (n2->decl);
 516 }
 517
 518 /* Return cgraph_varpool node assigned to DECL.  Create new one when needed.  */
 519 struct cgraph_varpool_node *
 520 cgraph_varpool_node (tree decl)
 521 {
 522   struct cgraph_varpool_node key, *node, **slot;
 523
 524   gcc_assert (DECL_P (decl) && TREE_CODE (decl) != FUNCTION_DECL);
 525
 526   if (!cgraph_varpool_hash)
 527     cgraph_varpool_hash = htab_create_ggc (10, hash_varpool_node,
 528                                            eq_varpool_node, NULL);
 529   key.decl = decl;
 530   slot = (struct cgraph_varpool_node **)
 531     htab_find_slot (cgraph_varpool_hash, &key, INSERT);
 532   if (*slot)
 533     return *slot;
 534   node = ggc_alloc_cleared (sizeof (*node));
 535   node->decl = decl;
 536   cgraph_varpool_n_nodes++;
 537   cgraph_varpool_nodes = node;
 538   *slot = node;
 539   return node;
 540 }
 541
 542 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables.  */
 543 void
 544 change_decl_assembler_name (tree decl, tree name)
 545 {
 546   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 547     {
 548       SET_DECL_ASSEMBLER_NAME (decl, name);
 549       return;
 550     }
 551   if (name == DECL_ASSEMBLER_NAME (decl))
 552     return;
 553
 554   if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
 555       && DECL_RTL_SET_P (decl))
 556     warning ("%D renamed after being referenced in assembly", decl);
 557
 558   SET_DECL_ASSEMBLER_NAME (decl, name);
 559 }
 560
 561 /* Notify finalize_compilation_unit that given node is reachable
 562    or needed.  */
 563 void
 564 cgraph_varpool_mark_needed_node (struct cgraph_varpool_node *node)
 565 {
 566   if (!node->needed && node->finalized)
 567     {
 568       node->next_needed = cgraph_varpool_nodes_queue;
 569       cgraph_varpool_nodes_queue = node;
 570       notice_global_symbol (node->decl);
 571     }
 572   node->needed = 1;
 573 }
 574
 575 void
 576 cgraph_varpool_finalize_decl (tree decl)
 577 {
 578   struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
 579
 580   /* The first declaration of a variable that comes through this function
 581      decides whether it is global (in C, has external linkage)
 582      or local (in C, has internal linkage).  So do nothing more
 583      if this function has already run.  */
 584   if (node->finalized)
 585     return;
 586   if (node->needed)
 587     {
 588       node->next_needed = cgraph_varpool_nodes_queue;
 589       cgraph_varpool_nodes_queue = node;
 590       notice_global_symbol (decl);
 591     }
 592   node->finalized = true;
 593
 594   if (/* Externally visible variables must be output.  The exception are
 595          COMDAT functions that must be output only when they are needed.  */
 596       (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
 597       /* Function whose name is output to the assembler file must be produced.
 598          It is possible to assemble the name later after finalizing the function
 599          and the fact is noticed in assemble_name then.  */
 600       || (DECL_ASSEMBLER_NAME_SET_P (decl)
 601           && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
 602     {
 603       cgraph_varpool_mark_needed_node (node);
 604     }
 605 }
 606
 607 bool
 608 cgraph_varpool_assemble_pending_decls (void)
 609 {
 610   bool changed = false;
 611
 612   while (cgraph_varpool_nodes_queue)
 613     {
 614       tree decl = cgraph_varpool_nodes_queue->decl;
 615       struct cgraph_varpool_node *node = cgraph_varpool_nodes_queue;
 616
 617       cgraph_varpool_nodes_queue = cgraph_varpool_nodes_queue->next_needed;
 618       if (!TREE_ASM_WRITTEN (decl))
 619         {
 620           assemble_variable (decl, 0, 1, 0);
 621           changed = true;
 622         }
 623       node->next_needed = NULL;
 624     }
 625   return changed;
 626 }
 627
 628 /* Return true when the DECL can possibly be inlined.  */
 629 bool
 630 cgraph_function_possibly_inlined_p (tree decl)
 631 {
 632   if (!cgraph_global_info_ready)
 633     return (DECL_INLINE (decl) && !flag_really_no_inline);
 634   return DECL_POSSIBLY_INLINED (decl);
 635 }
 636
 637 /* Create clone of E in the node N represented by CALL_EXPR the callgraph.  */
 638 struct cgraph_edge *
 639 cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n, tree call_expr)
 640 {
 641   struct cgraph_edge *new = cgraph_create_edge (n, e->callee, call_expr);
 642
 643   new->inline_failed = e->inline_failed;
 644   return new;
 645 }
 646
 647 /* Create node representing clone of N.  */
 648 struct cgraph_node *
 649 cgraph_clone_node (struct cgraph_node *n)
 650 {
 651   struct cgraph_node *new = cgraph_create_node ();
 652   struct cgraph_edge *e;
 653
 654   new->decl = n->decl;
 655   new->origin = n->origin;
 656   if (new->origin)
 657     {
 658       new->next_nested = new->origin->nested;
 659       new->origin->nested = new;
 660     }
 661   new->analyzed = n->analyzed;
 662   new->local = n->local;
 663   new->global = n->global;
 664   new->rtl = n->rtl;
 665
 666   for (e = n->callees;e; e=e->next_callee)
 667     cgraph_clone_edge (e, new, e->call_expr);
 668
 669   new->next_clone = n->next_clone;
 670   n->next_clone = new;
 671
 672   return new;
 673 }
 674
 675 /* NODE is no longer nested function; update cgraph accordingly.  */
 676 void
 677 cgraph_unnest_node (struct cgraph_node *node)
 678 {
 679   struct cgraph_node **node2 = &node->origin->nested;
 680   gcc_assert (node->origin);
 681
 682   while (*node2 != node)
 683     node2 = &(*node2)->next_nested;
 684   *node2 = node->next_nested;
 685   node->origin = NULL;
 686 }
 687 #include "gt-cgraph.h"