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 a 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 true when CALLER_DECL calls CALLEE_DECL.  */
 390
 391 bool
 392 cgraph_calls_p (tree caller_decl, tree callee_decl)
 393 {
 394   struct cgraph_node *caller = cgraph_node (caller_decl);
 395   struct cgraph_node *callee = cgraph_node (callee_decl);
 396   struct cgraph_edge *edge;
 397
 398   for (edge = callee->callers; edge && (edge)->caller != caller;
 399        edge = (edge->next_caller))
 400     continue;
 401   return edge != NULL;
 402 }
 403
 404 /* Return local info for the compiled function.  */
 405
 406 struct cgraph_local_info *
 407 cgraph_local_info (tree decl)
 408 {
 409   struct cgraph_node *node;
 410
 411   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 412   node = cgraph_node (decl);
 413   return &node->local;
 414 }
 415
 416 /* Return local info for the compiled function.  */
 417
 418 struct cgraph_global_info *
 419 cgraph_global_info (tree decl)
 420 {
 421   struct cgraph_node *node;
 422
 423   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
 424   node = cgraph_node (decl);
 425   return &node->global;
 426 }
 427
 428 /* Return local info for the compiled function.  */
 429
 430 struct cgraph_rtl_info *
 431 cgraph_rtl_info (tree decl)
 432 {
 433   struct cgraph_node *node;
 434
 435   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
 436   node = cgraph_node (decl);
 437   if (decl != current_function_decl
 438       && !TREE_ASM_WRITTEN (node->decl))
 439     return NULL;
 440   return &node->rtl;
 441 }
 442
 443 /* Return name of the node used in debug output.  */
 444 const char *
 445 cgraph_node_name (struct cgraph_node *node)
 446 {
 447   return lang_hooks.decl_printable_name (node->decl, 2);
 448 }
 449
 450 /* Dump given cgraph node.  */
 451 void
 452 dump_cgraph_node (FILE *f, struct cgraph_node *node)
 453 {
 454   struct cgraph_edge *edge;
 455   fprintf (f, "%s/%i:", cgraph_node_name (node), node->uid);
 456   if (node->global.inlined_to)
 457     fprintf (f, " (inline copy in %s/%i)",
 458              cgraph_node_name (node->global.inlined_to),
 459              node->global.inlined_to->uid);
 460   if (node->local.self_insns)
 461     fprintf (f, " %i insns", node->local.self_insns);
 462   if (node->global.insns && node->global.insns != node->local.self_insns)
 463     fprintf (f, " (%i after inlining)", node->global.insns);
 464   if (node->origin)
 465     fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
 466   if (node->needed)
 467     fprintf (f, " needed");
 468   else if (node->reachable)
 469     fprintf (f, " reachable");
 470   if (DECL_SAVED_TREE (node->decl))
 471     fprintf (f, " tree");
 472   if (node->output)
 473     fprintf (f, " output");
 474
 475   if (node->local.local)
 476     fprintf (f, " local");
 477   if (node->local.disregard_inline_limits)
 478     fprintf (f, " always_inline");
 479   else if (node->local.inlinable)
 480     fprintf (f, " inlinable");
 481   if (TREE_ASM_WRITTEN (node->decl))
 482     fprintf (f, " asm_written");
 483
 484   fprintf (f, "\n  called by: ");
 485   for (edge = node->callers; edge; edge = edge->next_caller)
 486     {
 487       fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
 488                edge->caller->uid);
 489       if (!edge->inline_failed)
 490         fprintf(f, "(inlined) ");
 491     }
 492
 493   fprintf (f, "\n  calls: ");
 494   for (edge = node->callees; edge; edge = edge->next_callee)
 495     {
 496       fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
 497                edge->callee->uid);
 498       if (!edge->inline_failed)
 499         fprintf(f, "(inlined) ");
 500     }
 501   fprintf (f, "\n");
 502 }
 503
 504 /* Dump the callgraph.  */
 505
 506 void
 507 dump_cgraph (FILE *f)
 508 {
 509   struct cgraph_node *node;
 510
 511   fprintf (f, "callgraph:\n\n");
 512   for (node = cgraph_nodes; node; node = node->next)
 513     dump_cgraph_node (f, node);
 514 }
 515
 516 /* Returns a hash code for P.  */
 517
 518 static hashval_t
 519 hash_varpool_node (const void *p)
 520 {
 521   const struct cgraph_varpool_node *n = p;
 522   return (hashval_t) DECL_UID (n->decl);
 523 }
 524
 525 /* Returns nonzero if P1 and P2 are equal.  */
 526
 527 static int
 528 eq_varpool_node (const void *p1, const void *p2)
 529 {
 530   const struct cgraph_varpool_node *n1 = p1, *n2 = p2;
 531   return DECL_UID (n1->decl) == DECL_UID (n2->decl);
 532 }
 533
 534 /* Return cgraph_varpool node assigned to DECL.  Create new one when needed.  */
 535 struct cgraph_varpool_node *
 536 cgraph_varpool_node (tree decl)
 537 {
 538   struct cgraph_varpool_node key, *node, **slot;
 539
 540   gcc_assert (DECL_P (decl) && TREE_CODE (decl) != FUNCTION_DECL);
 541
 542   if (!cgraph_varpool_hash)
 543     cgraph_varpool_hash = htab_create_ggc (10, hash_varpool_node,
 544                                            eq_varpool_node, NULL);
 545   key.decl = decl;
 546   slot = (struct cgraph_varpool_node **)
 547     htab_find_slot (cgraph_varpool_hash, &key, INSERT);
 548   if (*slot)
 549     return *slot;
 550   node = ggc_alloc_cleared (sizeof (*node));
 551   node->decl = decl;
 552   cgraph_varpool_n_nodes++;
 553   cgraph_varpool_nodes = node;
 554   *slot = node;
 555   return node;
 556 }
 557
 558 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables.  */
 559 void
 560 change_decl_assembler_name (tree decl, tree name)
 561 {
 562   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 563     {
 564       SET_DECL_ASSEMBLER_NAME (decl, name);
 565       return;
 566     }
 567   if (name == DECL_ASSEMBLER_NAME (decl))
 568     return;
 569
 570   if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
 571       && DECL_RTL_SET_P (decl))
 572     warning ("%D renamed after being referenced in assembly", decl);
 573
 574   SET_DECL_ASSEMBLER_NAME (decl, name);
 575 }
 576
 577 /* Notify finalize_compilation_unit that given node is reachable
 578    or needed.  */
 579 void
 580 cgraph_varpool_mark_needed_node (struct cgraph_varpool_node *node)
 581 {
 582   if (!node->needed && node->finalized)
 583     {
 584       node->next_needed = cgraph_varpool_nodes_queue;
 585       cgraph_varpool_nodes_queue = node;
 586       notice_global_symbol (node->decl);
 587     }
 588   node->needed = 1;
 589 }
 590
 591 void
 592 cgraph_varpool_finalize_decl (tree decl)
 593 {
 594   struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
 595
 596   /* The first declaration of a variable that comes through this function
 597      decides whether it is global (in C, has external linkage)
 598      or local (in C, has internal linkage).  So do nothing more
 599      if this function has already run.  */
 600   if (node->finalized)
 601     return;
 602   if (node->needed)
 603     {
 604       node->next_needed = cgraph_varpool_nodes_queue;
 605       cgraph_varpool_nodes_queue = node;
 606       notice_global_symbol (decl);
 607     }
 608   node->finalized = true;
 609
 610   if (/* Externally visible variables must be output.  The exception are
 611          COMDAT functions that must be output only when they are needed.  */
 612       (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
 613       /* Function whose name is output to the assembler file must be produced.
 614          It is possible to assemble the name later after finalizing the function
 615          and the fact is noticed in assemble_name then.  */
 616       || (DECL_ASSEMBLER_NAME_SET_P (decl)
 617           && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))))
 618     {
 619       cgraph_varpool_mark_needed_node (node);
 620     }
 621 }
 622
 623 bool
 624 cgraph_varpool_assemble_pending_decls (void)
 625 {
 626   bool changed = false;
 627
 628   while (cgraph_varpool_nodes_queue)
 629     {
 630       tree decl = cgraph_varpool_nodes_queue->decl;
 631       struct cgraph_varpool_node *node = cgraph_varpool_nodes_queue;
 632
 633       cgraph_varpool_nodes_queue = cgraph_varpool_nodes_queue->next_needed;
 634       if (!TREE_ASM_WRITTEN (decl))
 635         {
 636           assemble_variable (decl, 0, 1, 0);
 637           changed = true;
 638         }
 639       node->next_needed = NULL;
 640     }
 641   return changed;
 642 }
 643
 644 /* Return true when the DECL can possibly be inlined.  */
 645 bool
 646 cgraph_function_possibly_inlined_p (tree decl)
 647 {
 648   if (!cgraph_global_info_ready)
 649     return (DECL_INLINE (decl) && !flag_really_no_inline);
 650   return DECL_POSSIBLY_INLINED (decl);
 651 }
 652
 653 /* Create clone of E in the node N represented by CALL_EXPR the callgraph.  */
 654 struct cgraph_edge *
 655 cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n, tree call_expr)
 656 {
 657   struct cgraph_edge *new = cgraph_create_edge (n, e->callee, call_expr);
 658
 659   new->inline_failed = e->inline_failed;
 660   return new;
 661 }
 662
 663 /* Create node representing clone of N.  */
 664 struct cgraph_node *
 665 cgraph_clone_node (struct cgraph_node *n)
 666 {
 667   struct cgraph_node *new = cgraph_create_node ();
 668   struct cgraph_edge *e;
 669
 670   new->decl = n->decl;
 671   new->origin = n->origin;
 672   if (new->origin)
 673     {
 674       new->next_nested = new->origin->nested;
 675       new->origin->nested = new;
 676     }
 677   new->analyzed = n->analyzed;
 678   new->local = n->local;
 679   new->global = n->global;
 680   new->rtl = n->rtl;
 681
 682   for (e = n->callees;e; e=e->next_callee)
 683     cgraph_clone_edge (e, new, e->call_expr);
 684
 685   new->next_clone = n->next_clone;
 686   n->next_clone = new;
 687
 688   return new;
 689 }
 690 #include "gt-cgraph.h"