OSDN Git Service

PR middle-end/42228
[pf3gnuchains/gcc-fork.git] / gcc / cgraph.c
1 /* Callgraph handling code.
2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
3    Free Software Foundation, Inc.
4    Contributed by Jan Hubicka
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 /*  This file contains basic routines manipulating call graph
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.
32
33     The mapping from declarations to call-graph nodes is done using hash table
34     based on DECL_UID.  The call-graph nodes are created lazily using
35     cgraph_node function when called for unknown declaration.
36
37     The callgraph at the moment does not represent indirect calls or calls
38     from other compilation unit.  Flag NEEDED is set for each node that may
39     be accessed in such an invisible way and it shall be considered an
40     entry point to the callgraph.
41
42     Interprocedural information:
43
44       Callgraph is place to store data needed for interprocedural optimization.
45       All data structures are divided into three components: local_info that
46       is produced while analyzing the function, global_info that is result
47       of global walking of the callgraph on the end of compilation and
48       rtl_info used by RTL backend to propagate data from already compiled
49       functions to their callers.
50
51     Inlining plans:
52
53       The function inlining information is decided in advance and maintained
54       in the callgraph as so called inline plan.
55       For each inlined call, the callee's node is cloned to represent the
56       new function copy produced by inliner.
57       Each inlined call gets a unique corresponding clone node of the callee
58       and the data structure is updated while inlining is performed, so
59       the clones are eliminated and their callee edges redirected to the
60       caller.
61
62       Each edge has "inline_failed" field.  When the field is set to NULL,
63       the call will be inlined.  When it is non-NULL it contains a reason
64       why inlining wasn't performed.  */
65
66 #include "config.h"
67 #include "system.h"
68 #include "coretypes.h"
69 #include "tm.h"
70 #include "tree.h"
71 #include "tree-inline.h"
72 #include "langhooks.h"
73 #include "hashtab.h"
74 #include "toplev.h"
75 #include "flags.h"
76 #include "ggc.h"
77 #include "debug.h"
78 #include "target.h"
79 #include "basic-block.h"
80 #include "cgraph.h"
81 #include "output.h"
82 #include "intl.h"
83 #include "gimple.h"
84 #include "tree-dump.h"
85 #include "tree-flow.h"
86 #include "value-prof.h"
87 #include "except.h"
88 #include "diagnostic.h"
89
90 static void cgraph_node_remove_callers (struct cgraph_node *node);
91 static inline void cgraph_edge_remove_caller (struct cgraph_edge *e);
92 static inline void cgraph_edge_remove_callee (struct cgraph_edge *e);
93
94 /* Hash table used to convert declarations into nodes.  */
95 static GTY((param_is (struct cgraph_node))) htab_t cgraph_hash;
96 /* Hash table used to convert assembler names into nodes.  */
97 static GTY((param_is (struct cgraph_node))) htab_t assembler_name_hash;
98
99 /* The linked list of cgraph nodes.  */
100 struct cgraph_node *cgraph_nodes;
101
102 /* Queue of cgraph nodes scheduled to be lowered.  */
103 struct cgraph_node *cgraph_nodes_queue;
104
105 /* Queue of cgraph nodes scheduled to be added into cgraph.  This is a
106    secondary queue used during optimization to accommodate passes that
107    may generate new functions that need to be optimized and expanded.  */
108 struct cgraph_node *cgraph_new_nodes;
109
110 /* Number of nodes in existence.  */
111 int cgraph_n_nodes;
112
113 /* Maximal uid used in cgraph nodes.  */
114 int cgraph_max_uid;
115
116 /* Maximal uid used in cgraph edges.  */
117 int cgraph_edge_max_uid;
118
119 /* Maximal pid used for profiling */
120 int cgraph_max_pid;
121
122 /* Set when whole unit has been analyzed so we can access global info.  */
123 bool cgraph_global_info_ready = false;
124
125 /* What state callgraph is in right now.  */
126 enum cgraph_state cgraph_state = CGRAPH_STATE_CONSTRUCTION;
127
128 /* Set when the cgraph is fully build and the basic flags are computed.  */
129 bool cgraph_function_flags_ready = false;
130
131 /* Linked list of cgraph asm nodes.  */
132 struct cgraph_asm_node *cgraph_asm_nodes;
133
134 /* Last node in cgraph_asm_nodes.  */
135 static GTY(()) struct cgraph_asm_node *cgraph_asm_last_node;
136
137 /* The order index of the next cgraph node to be created.  This is
138    used so that we can sort the cgraph nodes in order by when we saw
139    them, to support -fno-toplevel-reorder.  */
140 int cgraph_order;
141
142 /* List of hooks trigerred on cgraph_edge events.  */
143 struct cgraph_edge_hook_list {
144   cgraph_edge_hook hook;
145   void *data;
146   struct cgraph_edge_hook_list *next;
147 };
148
149 /* List of hooks trigerred on cgraph_node events.  */
150 struct cgraph_node_hook_list {
151   cgraph_node_hook hook;
152   void *data;
153   struct cgraph_node_hook_list *next;
154 };
155
156 /* List of hooks trigerred on events involving two cgraph_edges.  */
157 struct cgraph_2edge_hook_list {
158   cgraph_2edge_hook hook;
159   void *data;
160   struct cgraph_2edge_hook_list *next;
161 };
162
163 /* List of hooks trigerred on events involving two cgraph_nodes.  */
164 struct cgraph_2node_hook_list {
165   cgraph_2node_hook hook;
166   void *data;
167   struct cgraph_2node_hook_list *next;
168 };
169
170 /* List of hooks triggered when an edge is removed.  */
171 struct cgraph_edge_hook_list *first_cgraph_edge_removal_hook;
172 /* List of hooks triggered when a node is removed.  */
173 struct cgraph_node_hook_list *first_cgraph_node_removal_hook;
174 /* List of hooks triggered when an edge is duplicated.  */
175 struct cgraph_2edge_hook_list *first_cgraph_edge_duplicated_hook;
176 /* List of hooks triggered when a node is duplicated.  */
177 struct cgraph_2node_hook_list *first_cgraph_node_duplicated_hook;
178 /* List of hooks triggered when an function is inserted.  */
179 struct cgraph_node_hook_list *first_cgraph_function_insertion_hook;
180
181 /* Head of a linked list of unused (freed) call graph nodes.
182    Do not GTY((delete)) this list so UIDs gets reliably recycled.  */
183 static GTY(()) struct cgraph_node *free_nodes;
184 /* Head of a linked list of unused (freed) call graph edges.
185    Do not GTY((delete)) this list so UIDs gets reliably recycled.  */
186 static GTY(()) struct cgraph_edge *free_edges;
187
188 /* Macros to access the next item in the list of free cgraph nodes and
189    edges. */
190 #define NEXT_FREE_NODE(NODE) (NODE)->next
191 #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller
192
193 /* Register HOOK to be called with DATA on each removed edge.  */
194 struct cgraph_edge_hook_list *
195 cgraph_add_edge_removal_hook (cgraph_edge_hook hook, void *data)
196 {
197   struct cgraph_edge_hook_list *entry;
198   struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
199
200   entry = (struct cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
201   entry->hook = hook;
202   entry->data = data;
203   entry->next = NULL;
204   while (*ptr)
205     ptr = &(*ptr)->next;
206   *ptr = entry;
207   return entry;
208 }
209
210 /* Remove ENTRY from the list of hooks called on removing edges.  */
211 void
212 cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *entry)
213 {
214   struct cgraph_edge_hook_list **ptr = &first_cgraph_edge_removal_hook;
215
216   while (*ptr != entry)
217     ptr = &(*ptr)->next;
218   *ptr = entry->next;
219   free (entry);
220 }
221
222 /* Call all edge removal hooks.  */
223 static void
224 cgraph_call_edge_removal_hooks (struct cgraph_edge *e)
225 {
226   struct cgraph_edge_hook_list *entry = first_cgraph_edge_removal_hook;
227   while (entry)
228   {
229     entry->hook (e, entry->data);
230     entry = entry->next;
231   }
232 }
233
234 /* Register HOOK to be called with DATA on each removed node.  */
235 struct cgraph_node_hook_list *
236 cgraph_add_node_removal_hook (cgraph_node_hook hook, void *data)
237 {
238   struct cgraph_node_hook_list *entry;
239   struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
240
241   entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
242   entry->hook = hook;
243   entry->data = data;
244   entry->next = NULL;
245   while (*ptr)
246     ptr = &(*ptr)->next;
247   *ptr = entry;
248   return entry;
249 }
250
251 /* Remove ENTRY from the list of hooks called on removing nodes.  */
252 void
253 cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *entry)
254 {
255   struct cgraph_node_hook_list **ptr = &first_cgraph_node_removal_hook;
256
257   while (*ptr != entry)
258     ptr = &(*ptr)->next;
259   *ptr = entry->next;
260   free (entry);
261 }
262
263 /* Call all node removal hooks.  */
264 static void
265 cgraph_call_node_removal_hooks (struct cgraph_node *node)
266 {
267   struct cgraph_node_hook_list *entry = first_cgraph_node_removal_hook;
268   while (entry)
269   {
270     entry->hook (node, entry->data);
271     entry = entry->next;
272   }
273 }
274
275 /* Register HOOK to be called with DATA on each removed node.  */
276 struct cgraph_node_hook_list *
277 cgraph_add_function_insertion_hook (cgraph_node_hook hook, void *data)
278 {
279   struct cgraph_node_hook_list *entry;
280   struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
281
282   entry = (struct cgraph_node_hook_list *) xmalloc (sizeof (*entry));
283   entry->hook = hook;
284   entry->data = data;
285   entry->next = NULL;
286   while (*ptr)
287     ptr = &(*ptr)->next;
288   *ptr = entry;
289   return entry;
290 }
291
292 /* Remove ENTRY from the list of hooks called on removing nodes.  */
293 void
294 cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *entry)
295 {
296   struct cgraph_node_hook_list **ptr = &first_cgraph_function_insertion_hook;
297
298   while (*ptr != entry)
299     ptr = &(*ptr)->next;
300   *ptr = entry->next;
301   free (entry);
302 }
303
304 /* Call all node removal hooks.  */
305 void
306 cgraph_call_function_insertion_hooks (struct cgraph_node *node)
307 {
308   struct cgraph_node_hook_list *entry = first_cgraph_function_insertion_hook;
309   while (entry)
310   {
311     entry->hook (node, entry->data);
312     entry = entry->next;
313   }
314 }
315
316 /* Register HOOK to be called with DATA on each duplicated edge.  */
317 struct cgraph_2edge_hook_list *
318 cgraph_add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
319 {
320   struct cgraph_2edge_hook_list *entry;
321   struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
322
323   entry = (struct cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
324   entry->hook = hook;
325   entry->data = data;
326   entry->next = NULL;
327   while (*ptr)
328     ptr = &(*ptr)->next;
329   *ptr = entry;
330   return entry;
331 }
332
333 /* Remove ENTRY from the list of hooks called on duplicating edges.  */
334 void
335 cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *entry)
336 {
337   struct cgraph_2edge_hook_list **ptr = &first_cgraph_edge_duplicated_hook;
338
339   while (*ptr != entry)
340     ptr = &(*ptr)->next;
341   *ptr = entry->next;
342   free (entry);
343 }
344
345 /* Call all edge duplication hooks.  */
346 static void
347 cgraph_call_edge_duplication_hooks (struct cgraph_edge *cs1,
348                                     struct cgraph_edge *cs2)
349 {
350   struct cgraph_2edge_hook_list *entry = first_cgraph_edge_duplicated_hook;
351   while (entry)
352   {
353     entry->hook (cs1, cs2, entry->data);
354     entry = entry->next;
355   }
356 }
357
358 /* Register HOOK to be called with DATA on each duplicated node.  */
359 struct cgraph_2node_hook_list *
360 cgraph_add_node_duplication_hook (cgraph_2node_hook hook, void *data)
361 {
362   struct cgraph_2node_hook_list *entry;
363   struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
364
365   entry = (struct cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
366   entry->hook = hook;
367   entry->data = data;
368   entry->next = NULL;
369   while (*ptr)
370     ptr = &(*ptr)->next;
371   *ptr = entry;
372   return entry;
373 }
374
375 /* Remove ENTRY from the list of hooks called on duplicating nodes.  */
376 void
377 cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *entry)
378 {
379   struct cgraph_2node_hook_list **ptr = &first_cgraph_node_duplicated_hook;
380
381   while (*ptr != entry)
382     ptr = &(*ptr)->next;
383   *ptr = entry->next;
384   free (entry);
385 }
386
387 /* Call all node duplication hooks.  */
388 static void
389 cgraph_call_node_duplication_hooks (struct cgraph_node *node1,
390                                     struct cgraph_node *node2)
391 {
392   struct cgraph_2node_hook_list *entry = first_cgraph_node_duplicated_hook;
393   while (entry)
394   {
395     entry->hook (node1, node2, entry->data);
396     entry = entry->next;
397   }
398 }
399
400 /* Returns a hash code for P.  */
401
402 static hashval_t
403 hash_node (const void *p)
404 {
405   const struct cgraph_node *n = (const struct cgraph_node *) p;
406   return (hashval_t) DECL_UID (n->decl);
407 }
408
409
410 /* Returns nonzero if P1 and P2 are equal.  */
411
412 static int
413 eq_node (const void *p1, const void *p2)
414 {
415   const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
416   const struct cgraph_node *n2 = (const struct cgraph_node *) p2;
417   return DECL_UID (n1->decl) == DECL_UID (n2->decl);
418 }
419
420 /* Allocate new callgraph node.  */
421
422 static inline struct cgraph_node *
423 cgraph_allocate_node (void)
424 {
425   struct cgraph_node *node;
426
427   if (free_nodes)
428     {
429       node = free_nodes;
430       free_nodes = NEXT_FREE_NODE (node);
431     }
432   else
433     {
434       node = GGC_CNEW (struct cgraph_node);
435       node->uid = cgraph_max_uid++;
436     }
437
438   return node;
439 }
440
441 /* Allocate new callgraph node and insert it into basic data structures.  */
442
443 static struct cgraph_node *
444 cgraph_create_node (void)
445 {
446   struct cgraph_node *node = cgraph_allocate_node ();
447
448   node->next = cgraph_nodes;
449   node->pid = -1;
450   node->order = cgraph_order++;
451   if (cgraph_nodes)
452     cgraph_nodes->previous = node;
453   node->previous = NULL;
454   node->global.estimated_growth = INT_MIN;
455   cgraph_nodes = node;
456   cgraph_n_nodes++;
457   return node;
458 }
459
460 /* Return cgraph node assigned to DECL.  Create new one when needed.  */
461
462 struct cgraph_node *
463 cgraph_node (tree decl)
464 {
465   struct cgraph_node key, *node, **slot;
466
467   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
468
469   if (!cgraph_hash)
470     cgraph_hash = htab_create_ggc (10, hash_node, eq_node, NULL);
471
472   key.decl = decl;
473
474   slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
475
476   if (*slot)
477     {
478       node = *slot;
479       if (node->same_body_alias)
480         node = node->same_body;
481       return node;
482     }
483
484   node = cgraph_create_node ();
485   node->decl = decl;
486   *slot = node;
487   if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
488     {
489       node->origin = cgraph_node (DECL_CONTEXT (decl));
490       node->next_nested = node->origin->nested;
491       node->origin->nested = node;
492     }
493   if (assembler_name_hash)
494     {
495       void **aslot;
496       tree name = DECL_ASSEMBLER_NAME (decl);
497
498       aslot = htab_find_slot_with_hash (assembler_name_hash, name,
499                                         decl_assembler_name_hash (name),
500                                         INSERT);
501       /* We can have multiple declarations with same assembler name. For C++
502          it is __builtin_strlen and strlen, for instance.  Do we need to
503          record them all?  Original implementation marked just first one
504          so lets hope for the best.  */
505       if (*aslot == NULL)
506         *aslot = node;
507     }
508   return node;
509 }
510
511 /* Mark ALIAS as an alias to DECL.  */
512
513 static struct cgraph_node *
514 cgraph_same_body_alias_1 (tree alias, tree decl)
515 {
516   struct cgraph_node key, *alias_node, *decl_node, **slot;
517
518   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
519   gcc_assert (TREE_CODE (alias) == FUNCTION_DECL);
520   decl_node = cgraph_node (decl);
521
522   key.decl = alias;
523
524   slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
525
526   /* If the cgraph_node has been already created, fail.  */
527   if (*slot)
528     return NULL;
529
530   alias_node = cgraph_allocate_node ();
531   alias_node->decl = alias;
532   alias_node->same_body_alias = 1;
533   alias_node->same_body = decl_node;
534   alias_node->previous = NULL;
535   if (decl_node->same_body)
536     decl_node->same_body->previous = alias_node;
537   alias_node->next = decl_node->same_body;
538   alias_node->thunk.alias = decl;
539   decl_node->same_body = alias_node;
540   *slot = alias_node;
541   return alias_node;
542 }
543
544 /* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
545    Same body aliases are output whenever the body of DECL is output,
546    and cgraph_node (ALIAS) transparently returns cgraph_node (DECL).   */
547
548 bool
549 cgraph_same_body_alias (tree alias, tree decl)
550 {
551 #ifndef ASM_OUTPUT_DEF
552   /* If aliases aren't supported by the assembler, fail.  */
553   return false;
554 #endif
555
556   /*gcc_assert (!assembler_name_hash);*/
557
558   return cgraph_same_body_alias_1 (alias, decl) != NULL;
559 }
560
561 void
562 cgraph_add_thunk (tree alias, tree decl, bool this_adjusting,
563                   HOST_WIDE_INT fixed_offset, HOST_WIDE_INT virtual_value,
564                   tree virtual_offset,
565                   tree real_alias)
566 {
567   struct cgraph_node *node = cgraph_get_node (alias);
568
569   if (node)
570     {
571       gcc_assert (node->local.finalized);
572       gcc_assert (!node->same_body);
573       cgraph_remove_node (node);
574     }
575   
576   node = cgraph_same_body_alias_1 (alias, decl);
577   gcc_assert (node);
578 #ifdef ENABLE_CHECKING
579   gcc_assert (!virtual_offset
580               || tree_int_cst_equal (virtual_offset, size_int (virtual_value)));
581 #endif
582   node->thunk.fixed_offset = fixed_offset;
583   node->thunk.this_adjusting = this_adjusting;
584   node->thunk.virtual_value = virtual_value;
585   node->thunk.virtual_offset_p = virtual_offset != NULL;
586   node->thunk.alias = real_alias;
587   node->thunk.thunk_p = true;
588 }
589
590 /* Returns the cgraph node assigned to DECL or NULL if no cgraph node
591    is assigned.  */
592
593 struct cgraph_node *
594 cgraph_get_node (tree decl)
595 {
596   struct cgraph_node key, *node = NULL, **slot;
597
598   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
599
600   if (!cgraph_hash)
601     return NULL;
602
603   key.decl = decl;
604
605   slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key,
606                                                  NO_INSERT);
607
608   if (slot && *slot)
609     {
610       node = *slot;
611       if (node->same_body_alias)
612         node = node->same_body;
613     }
614   return node;
615 }
616
617 /* Insert already constructed node into hashtable.  */
618
619 void
620 cgraph_insert_node_to_hashtable (struct cgraph_node *node)
621 {
622   struct cgraph_node **slot;
623
624   slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, node, INSERT);
625
626   gcc_assert (!*slot);
627   *slot = node;
628 }
629
630 /* Returns a hash code for P.  */
631
632 static hashval_t
633 hash_node_by_assembler_name (const void *p)
634 {
635   const struct cgraph_node *n = (const struct cgraph_node *) p;
636   return (hashval_t) decl_assembler_name_hash (DECL_ASSEMBLER_NAME (n->decl));
637 }
638
639 /* Returns nonzero if P1 and P2 are equal.  */
640
641 static int
642 eq_assembler_name (const void *p1, const void *p2)
643 {
644   const struct cgraph_node *n1 = (const struct cgraph_node *) p1;
645   const_tree name = (const_tree)p2;
646   return (decl_assembler_name_equal (n1->decl, name));
647 }
648
649 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
650    Return NULL if there's no such node.  */
651
652 struct cgraph_node *
653 cgraph_node_for_asm (tree asmname)
654 {
655   struct cgraph_node *node;
656   void **slot;
657
658   if (!assembler_name_hash)
659     {
660       assembler_name_hash =
661         htab_create_ggc (10, hash_node_by_assembler_name, eq_assembler_name,
662                          NULL);
663       for (node = cgraph_nodes; node; node = node->next)
664         if (!node->global.inlined_to)
665           {
666             tree name = DECL_ASSEMBLER_NAME (node->decl);
667             slot = htab_find_slot_with_hash (assembler_name_hash, name,
668                                              decl_assembler_name_hash (name),
669                                              INSERT);
670             /* We can have multiple declarations with same assembler name. For C++
671                it is __builtin_strlen and strlen, for instance.  Do we need to
672                record them all?  Original implementation marked just first one
673                so lets hope for the best.  */
674             if (!*slot)
675               *slot = node;
676             if (node->same_body)
677               {
678                 struct cgraph_node *alias;
679
680                 for (alias = node->same_body; alias; alias = alias->next)
681                   {
682                     hashval_t hash;
683                     name = DECL_ASSEMBLER_NAME (alias->decl);
684                     hash = decl_assembler_name_hash (name);
685                     slot = htab_find_slot_with_hash (assembler_name_hash, name,
686                                                      hash,  INSERT);
687                     if (!*slot)
688                       *slot = alias;
689                   }
690               }
691           }
692     }
693
694   slot = htab_find_slot_with_hash (assembler_name_hash, asmname,
695                                    decl_assembler_name_hash (asmname),
696                                    NO_INSERT);
697
698   if (slot)
699     {
700       node = (struct cgraph_node *) *slot;
701       if (node->same_body_alias)
702         node = node->same_body;
703       return node;
704     }
705   return NULL;
706 }
707
708 /* Returns a hash value for X (which really is a die_struct).  */
709
710 static hashval_t
711 edge_hash (const void *x)
712 {
713   return htab_hash_pointer (((const struct cgraph_edge *) x)->call_stmt);
714 }
715
716 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y.  */
717
718 static int
719 edge_eq (const void *x, const void *y)
720 {
721   return ((const struct cgraph_edge *) x)->call_stmt == y;
722 }
723
724
725 /* Return the callgraph edge representing the GIMPLE_CALL statement
726    CALL_STMT.  */
727
728 struct cgraph_edge *
729 cgraph_edge (struct cgraph_node *node, gimple call_stmt)
730 {
731   struct cgraph_edge *e, *e2;
732   int n = 0;
733
734   if (node->call_site_hash)
735     return (struct cgraph_edge *)
736       htab_find_with_hash (node->call_site_hash, call_stmt,
737                            htab_hash_pointer (call_stmt));
738
739   /* This loop may turn out to be performance problem.  In such case adding
740      hashtables into call nodes with very many edges is probably best
741      solution.  It is not good idea to add pointer into CALL_EXPR itself
742      because we want to make possible having multiple cgraph nodes representing
743      different clones of the same body before the body is actually cloned.  */
744   for (e = node->callees; e; e= e->next_callee)
745     {
746       if (e->call_stmt == call_stmt)
747         break;
748       n++;
749     }
750
751   if (n > 100)
752     {
753       node->call_site_hash = htab_create_ggc (120, edge_hash, edge_eq, NULL);
754       for (e2 = node->callees; e2; e2 = e2->next_callee)
755         {
756           void **slot;
757           slot = htab_find_slot_with_hash (node->call_site_hash,
758                                            e2->call_stmt,
759                                            htab_hash_pointer (e2->call_stmt),
760                                            INSERT);
761           gcc_assert (!*slot);
762           *slot = e2;
763         }
764     }
765
766   return e;
767 }
768
769
770 /* Change field call_stmt of edge E to NEW_STMT.  */
771
772 void
773 cgraph_set_call_stmt (struct cgraph_edge *e, gimple new_stmt)
774 {
775   if (e->caller->call_site_hash)
776     {
777       htab_remove_elt_with_hash (e->caller->call_site_hash,
778                                  e->call_stmt,
779                                  htab_hash_pointer (e->call_stmt));
780     }
781   e->call_stmt = new_stmt;
782   push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
783   e->can_throw_external = stmt_can_throw_external (new_stmt);
784   pop_cfun ();
785   if (e->caller->call_site_hash)
786     {
787       void **slot;
788       slot = htab_find_slot_with_hash (e->caller->call_site_hash,
789                                        e->call_stmt,
790                                        htab_hash_pointer
791                                        (e->call_stmt), INSERT);
792       gcc_assert (!*slot);
793       *slot = e;
794     }
795 }
796
797 /* Like cgraph_set_call_stmt but walk the clone tree and update all
798    clones sharing the same function body.  */
799
800 void
801 cgraph_set_call_stmt_including_clones (struct cgraph_node *orig,
802                                        gimple old_stmt, gimple new_stmt)
803 {
804   struct cgraph_node *node;
805   struct cgraph_edge *edge = cgraph_edge (orig, old_stmt);
806
807   if (edge)
808     cgraph_set_call_stmt (edge, new_stmt);
809
810   node = orig->clones;
811   if (node)
812     while (node != orig)
813       {
814         struct cgraph_edge *edge = cgraph_edge (node, old_stmt);
815         if (edge)
816           cgraph_set_call_stmt (edge, new_stmt);
817         if (node->clones)
818           node = node->clones;
819         else if (node->next_sibling_clone)
820           node = node->next_sibling_clone;
821         else
822           {
823             while (node != orig && !node->next_sibling_clone)
824               node = node->clone_of;
825             if (node != orig)
826               node = node->next_sibling_clone;
827           }
828       }
829 }
830
831 /* Like cgraph_create_edge walk the clone tree and update all clones sharing
832    same function body.  If clones already have edge for OLD_STMT; only
833    update the edge same way as cgraph_set_call_stmt_including_clones does.
834
835    TODO: COUNT and LOOP_DEPTH should be properly distributed based on relative
836    frequencies of the clones.  */
837
838 void
839 cgraph_create_edge_including_clones (struct cgraph_node *orig,
840                                      struct cgraph_node *callee,
841                                      gimple old_stmt,
842                                      gimple stmt, gcov_type count,
843                                      int freq, int loop_depth,
844                                      cgraph_inline_failed_t reason)
845 {
846   struct cgraph_node *node;
847   struct cgraph_edge *edge;
848
849   if (!cgraph_edge (orig, stmt))
850     {
851       edge = cgraph_create_edge (orig, callee, stmt, count, freq, loop_depth);
852       edge->inline_failed = reason;
853     }
854
855   node = orig->clones;
856   if (node)
857     while (node != orig)
858       {
859         struct cgraph_edge *edge = cgraph_edge (node, old_stmt);
860
861         /* It is possible that clones already contain the edge while
862            master didn't.  Either we promoted indirect call into direct
863            call in the clone or we are processing clones of unreachable
864            master where edges has been rmeoved.  */
865         if (edge)
866           cgraph_set_call_stmt (edge, stmt);
867         else if (!cgraph_edge (node, stmt))
868           {
869             edge = cgraph_create_edge (node, callee, stmt, count,
870                                        freq, loop_depth);
871             edge->inline_failed = reason;
872           }
873
874         if (node->clones)
875           node = node->clones;
876         else if (node->next_sibling_clone)
877           node = node->next_sibling_clone;
878         else
879           {
880             while (node != orig && !node->next_sibling_clone)
881               node = node->clone_of;
882             if (node != orig)
883               node = node->next_sibling_clone;
884           }
885       }
886 }
887
888 /* Give initial reasons why inlining would fail on EDGE.  This gets either
889    nullified or usually overwritten by more precise reasons later.  */
890
891 static void
892 initialize_inline_failed (struct cgraph_edge *e)
893 {
894   struct cgraph_node *callee = e->callee;
895
896   if (!callee->analyzed)
897     e->inline_failed = CIF_BODY_NOT_AVAILABLE;
898   else if (callee->local.redefined_extern_inline)
899     e->inline_failed = CIF_REDEFINED_EXTERN_INLINE;
900   else if (!callee->local.inlinable)
901     e->inline_failed = CIF_FUNCTION_NOT_INLINABLE;
902   else if (e->call_stmt && gimple_call_cannot_inline_p (e->call_stmt))
903     e->inline_failed = CIF_MISMATCHED_ARGUMENTS;
904   else
905     e->inline_failed = CIF_FUNCTION_NOT_CONSIDERED;
906 }
907
908 /* Create edge from CALLER to CALLEE in the cgraph.  */
909
910 struct cgraph_edge *
911 cgraph_create_edge (struct cgraph_node *caller, struct cgraph_node *callee,
912                     gimple call_stmt, gcov_type count, int freq, int nest)
913 {
914   struct cgraph_edge *edge;
915
916
917   /* LTO does not actually have access to the call_stmt since these
918      have not been loaded yet.  */
919   if (call_stmt)
920     {
921 #ifdef ENABLE_CHECKING
922       /* This is rather pricely check possibly trigerring construction of
923          call stmt hashtable.  */
924       gcc_assert (!cgraph_edge (caller, call_stmt));
925 #endif
926
927       gcc_assert (is_gimple_call (call_stmt));
928     }
929
930   if (free_edges)
931     {
932       edge = free_edges;
933       free_edges = NEXT_FREE_EDGE (edge);
934     }
935   else
936     {
937       edge = GGC_NEW (struct cgraph_edge);
938       edge->uid = cgraph_edge_max_uid++;
939     }
940
941   edge->aux = NULL;
942
943   edge->caller = caller;
944   edge->callee = callee;
945   edge->call_stmt = call_stmt;
946   push_cfun (DECL_STRUCT_FUNCTION (caller->decl));
947   edge->can_throw_external
948     = call_stmt ? stmt_can_throw_external (call_stmt) : false;
949   pop_cfun ();
950   edge->prev_caller = NULL;
951   edge->next_caller = callee->callers;
952   if (callee->callers)
953     callee->callers->prev_caller = edge;
954   edge->prev_callee = NULL;
955   edge->next_callee = caller->callees;
956   if (caller->callees)
957     caller->callees->prev_callee = edge;
958   caller->callees = edge;
959   callee->callers = edge;
960   edge->count = count;
961   gcc_assert (count >= 0);
962   edge->frequency = freq;
963   gcc_assert (freq >= 0);
964   gcc_assert (freq <= CGRAPH_FREQ_MAX);
965   edge->loop_nest = nest;
966   edge->indirect_call = 0;
967   edge->call_stmt_cannot_inline_p =
968     (call_stmt ? gimple_call_cannot_inline_p (call_stmt) : false);
969   if (call_stmt && caller->call_site_hash)
970     {
971       void **slot;
972       slot = htab_find_slot_with_hash (caller->call_site_hash,
973                                        edge->call_stmt,
974                                        htab_hash_pointer
975                                          (edge->call_stmt),
976                                        INSERT);
977       gcc_assert (!*slot);
978       *slot = edge;
979     }
980
981   initialize_inline_failed (edge);
982
983   return edge;
984 }
985
986 /* Remove the edge E from the list of the callers of the callee.  */
987
988 static inline void
989 cgraph_edge_remove_callee (struct cgraph_edge *e)
990 {
991   if (e->prev_caller)
992     e->prev_caller->next_caller = e->next_caller;
993   if (e->next_caller)
994     e->next_caller->prev_caller = e->prev_caller;
995   if (!e->prev_caller)
996     e->callee->callers = e->next_caller;
997 }
998
999 /* Remove the edge E from the list of the callees of the caller.  */
1000
1001 static inline void
1002 cgraph_edge_remove_caller (struct cgraph_edge *e)
1003 {
1004   if (e->prev_callee)
1005     e->prev_callee->next_callee = e->next_callee;
1006   if (e->next_callee)
1007     e->next_callee->prev_callee = e->prev_callee;
1008   if (!e->prev_callee)
1009     e->caller->callees = e->next_callee;
1010   if (e->caller->call_site_hash)
1011     htab_remove_elt_with_hash (e->caller->call_site_hash,
1012                                e->call_stmt,
1013                                htab_hash_pointer (e->call_stmt));
1014 }
1015
1016 /* Put the edge onto the free list.  */
1017
1018 static void
1019 cgraph_free_edge (struct cgraph_edge *e)
1020 {
1021   int uid = e->uid;
1022
1023   /* Clear out the edge so we do not dangle pointers.  */
1024   memset (e, 0, sizeof (*e));
1025   e->uid = uid;
1026   NEXT_FREE_EDGE (e) = free_edges;
1027   free_edges = e;
1028 }
1029
1030 /* Remove the edge E in the cgraph.  */
1031
1032 void
1033 cgraph_remove_edge (struct cgraph_edge *e)
1034 {
1035   /* Call all edge removal hooks.  */
1036   cgraph_call_edge_removal_hooks (e);
1037
1038   /* Remove from callers list of the callee.  */
1039   cgraph_edge_remove_callee (e);
1040
1041   /* Remove from callees list of the callers.  */
1042   cgraph_edge_remove_caller (e);
1043
1044   /* Put the edge onto the free list.  */
1045   cgraph_free_edge (e);
1046 }
1047
1048 /* Redirect callee of E to N.  The function does not update underlying
1049    call expression.  */
1050
1051 void
1052 cgraph_redirect_edge_callee (struct cgraph_edge *e, struct cgraph_node *n)
1053 {
1054   /* Remove from callers list of the current callee.  */
1055   cgraph_edge_remove_callee (e);
1056
1057   /* Insert to callers list of the new callee.  */
1058   e->prev_caller = NULL;
1059   if (n->callers)
1060     n->callers->prev_caller = e;
1061   e->next_caller = n->callers;
1062   n->callers = e;
1063   e->callee = n;
1064 }
1065
1066
1067 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1068    OLD_STMT changed into NEW_STMT.  OLD_CALL is gimple_call_fndecl
1069    of OLD_STMT if it was previously call statement.  */
1070
1071 static void
1072 cgraph_update_edges_for_call_stmt_node (struct cgraph_node *node,
1073                                         gimple old_stmt, tree old_call, gimple new_stmt)
1074 {
1075   tree new_call = (is_gimple_call (new_stmt)) ? gimple_call_fndecl (new_stmt) : 0;
1076
1077   /* We are seeing indirect calls, then there is nothing to update.  */
1078   if (!new_call && !old_call)
1079     return;
1080   /* See if we turned indirect call into direct call or folded call to one builtin
1081      into different bultin.  */
1082   if (old_call != new_call)
1083     {
1084       struct cgraph_edge *e = cgraph_edge (node, old_stmt);
1085       struct cgraph_edge *ne = NULL;
1086       gcov_type count;
1087       int frequency;
1088       int loop_nest;
1089
1090       if (e)
1091         {
1092           /* See if the call is already there.  It might be because of indirect
1093              inlining already found it.  */
1094           if (new_call && e->callee->decl == new_call)
1095             return;
1096
1097           /* Otherwise remove edge and create new one; we can't simply redirect
1098              since function has changed, so inline plan and other information
1099              attached to edge is invalid.  */
1100           count = e->count;
1101           frequency = e->frequency;
1102           loop_nest = e->loop_nest;
1103           cgraph_remove_edge (e);
1104         }
1105       else
1106         {
1107           /* We are seeing new direct call; compute profile info based on BB.  */
1108           basic_block bb = gimple_bb (new_stmt);
1109           count = bb->count;
1110           frequency = compute_call_stmt_bb_frequency (current_function_decl,
1111                                                       bb);
1112           loop_nest = bb->loop_depth;
1113         }
1114
1115       if (new_call)
1116         {
1117           ne = cgraph_create_edge (node, cgraph_node (new_call),
1118                                    new_stmt, count, frequency,
1119                                    loop_nest);
1120           gcc_assert (ne->inline_failed);
1121         }
1122     }
1123   /* We only updated the call stmt; update pointer in cgraph edge..  */
1124   else if (old_stmt != new_stmt)
1125     cgraph_set_call_stmt (cgraph_edge (node, old_stmt), new_stmt);
1126 }
1127
1128 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1129    OLD_STMT changed into NEW_STMT.  OLD_DECL is gimple_call_fndecl
1130    of OLD_STMT before it was updated (updating can happen inplace).  */
1131
1132 void
1133 cgraph_update_edges_for_call_stmt (gimple old_stmt, tree old_decl, gimple new_stmt)
1134 {
1135   struct cgraph_node *orig = cgraph_node (cfun->decl);
1136   struct cgraph_node *node;
1137
1138   cgraph_update_edges_for_call_stmt_node (orig, old_stmt, old_decl, new_stmt);
1139   if (orig->clones)
1140     for (node = orig->clones; node != orig;)
1141       {
1142         cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_decl, new_stmt);
1143         if (node->clones)
1144           node = node->clones;
1145         else if (node->next_sibling_clone)
1146           node = node->next_sibling_clone;
1147         else
1148           {
1149             while (node != orig && !node->next_sibling_clone)
1150               node = node->clone_of;
1151             if (node != orig)
1152               node = node->next_sibling_clone;
1153           }
1154       }
1155 }
1156
1157
1158 /* Remove all callees from the node.  */
1159
1160 void
1161 cgraph_node_remove_callees (struct cgraph_node *node)
1162 {
1163   struct cgraph_edge *e, *f;
1164
1165   /* It is sufficient to remove the edges from the lists of callers of
1166      the callees.  The callee list of the node can be zapped with one
1167      assignment.  */
1168   for (e = node->callees; e; e = f)
1169     {
1170       f = e->next_callee;
1171       cgraph_call_edge_removal_hooks (e);
1172       cgraph_edge_remove_callee (e);
1173       cgraph_free_edge (e);
1174     }
1175   node->callees = NULL;
1176   if (node->call_site_hash)
1177     {
1178       htab_delete (node->call_site_hash);
1179       node->call_site_hash = NULL;
1180     }
1181 }
1182
1183 /* Remove all callers from the node.  */
1184
1185 static void
1186 cgraph_node_remove_callers (struct cgraph_node *node)
1187 {
1188   struct cgraph_edge *e, *f;
1189
1190   /* It is sufficient to remove the edges from the lists of callees of
1191      the callers.  The caller list of the node can be zapped with one
1192      assignment.  */
1193   for (e = node->callers; e; e = f)
1194     {
1195       f = e->next_caller;
1196       cgraph_call_edge_removal_hooks (e);
1197       cgraph_edge_remove_caller (e);
1198       cgraph_free_edge (e);
1199     }
1200   node->callers = NULL;
1201 }
1202
1203 /* Release memory used to represent body of function NODE.  */
1204
1205 void
1206 cgraph_release_function_body (struct cgraph_node *node)
1207 {
1208   if (DECL_STRUCT_FUNCTION (node->decl))
1209     {
1210       tree old_decl = current_function_decl;
1211       push_cfun (DECL_STRUCT_FUNCTION (node->decl));
1212       if (cfun->gimple_df)
1213         {
1214           current_function_decl = node->decl;
1215           delete_tree_ssa ();
1216           delete_tree_cfg_annotations ();
1217           cfun->eh = NULL;
1218           current_function_decl = old_decl;
1219         }
1220       if (cfun->cfg)
1221         {
1222           gcc_assert (dom_computed[0] == DOM_NONE);
1223           gcc_assert (dom_computed[1] == DOM_NONE);
1224           clear_edges ();
1225         }
1226       if (cfun->value_histograms)
1227         free_histograms ();
1228       gcc_assert (!current_loops);
1229       pop_cfun();
1230       gimple_set_body (node->decl, NULL);
1231       VEC_free (ipa_opt_pass, heap,
1232                 node->ipa_transforms_to_apply);
1233       /* Struct function hangs a lot of data that would leak if we didn't
1234          removed all pointers to it.   */
1235       ggc_free (DECL_STRUCT_FUNCTION (node->decl));
1236       DECL_STRUCT_FUNCTION (node->decl) = NULL;
1237     }
1238   DECL_SAVED_TREE (node->decl) = NULL;
1239   /* If the node is abstract and needed, then do not clear DECL_INITIAL
1240      of its associated function function declaration because it's
1241      needed to emit debug info later.  */
1242   if (!node->abstract_and_needed)
1243     DECL_INITIAL (node->decl) = error_mark_node;
1244 }
1245
1246 /* Remove same body alias node.  */
1247
1248 void
1249 cgraph_remove_same_body_alias (struct cgraph_node *node)
1250 {
1251   void **slot;
1252   int uid = node->uid;
1253
1254   gcc_assert (node->same_body_alias);
1255   if (node->previous)
1256     node->previous->next = node->next;
1257   else
1258     node->same_body->same_body = node->next;
1259   if (node->next)
1260     node->next->previous = node->previous;
1261   node->next = NULL;
1262   node->previous = NULL;
1263   slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
1264   if (*slot == node)
1265     htab_clear_slot (cgraph_hash, slot);
1266   if (assembler_name_hash)
1267     {
1268       tree name = DECL_ASSEMBLER_NAME (node->decl);
1269       slot = htab_find_slot_with_hash (assembler_name_hash, name,
1270                                        decl_assembler_name_hash (name),
1271                                        NO_INSERT);
1272       if (slot && *slot == node)
1273         htab_clear_slot (assembler_name_hash, slot);
1274     }
1275
1276   /* Clear out the node to NULL all pointers and add the node to the free
1277      list.  */
1278   memset (node, 0, sizeof(*node));
1279   node->uid = uid;
1280   NEXT_FREE_NODE (node) = free_nodes;
1281   free_nodes = node;
1282 }
1283
1284 /* Remove the node from cgraph.  */
1285
1286 void
1287 cgraph_remove_node (struct cgraph_node *node)
1288 {
1289   void **slot;
1290   bool kill_body = false;
1291   struct cgraph_node *n;
1292   int uid = node->uid;
1293
1294   cgraph_call_node_removal_hooks (node);
1295   cgraph_node_remove_callers (node);
1296   cgraph_node_remove_callees (node);
1297   VEC_free (ipa_opt_pass, heap,
1298             node->ipa_transforms_to_apply);
1299
1300   /* Incremental inlining access removed nodes stored in the postorder list.
1301      */
1302   node->needed = node->reachable = false;
1303   for (n = node->nested; n; n = n->next_nested)
1304     n->origin = NULL;
1305   node->nested = NULL;
1306   if (node->origin)
1307     {
1308       struct cgraph_node **node2 = &node->origin->nested;
1309
1310       while (*node2 != node)
1311         node2 = &(*node2)->next_nested;
1312       *node2 = node->next_nested;
1313     }
1314   if (node->previous)
1315     node->previous->next = node->next;
1316   else
1317     cgraph_nodes = node->next;
1318   if (node->next)
1319     node->next->previous = node->previous;
1320   node->next = NULL;
1321   node->previous = NULL;
1322   slot = htab_find_slot (cgraph_hash, node, NO_INSERT);
1323   if (*slot == node)
1324     {
1325       struct cgraph_node *next_inline_clone;
1326
1327       for (next_inline_clone = node->clones;
1328            next_inline_clone && next_inline_clone->decl != node->decl;
1329            next_inline_clone = next_inline_clone->next_sibling_clone)
1330         ;
1331
1332       /* If there is inline clone of the node being removed, we need
1333          to put it into the position of removed node and reorganize all
1334          other clones to be based on it.  */
1335       if (next_inline_clone)
1336         {
1337           struct cgraph_node *n;
1338           struct cgraph_node *new_clones;
1339
1340           *slot = next_inline_clone;
1341
1342           /* Unlink inline clone from the list of clones of removed node.  */
1343           if (next_inline_clone->next_sibling_clone)
1344             next_inline_clone->next_sibling_clone->prev_sibling_clone
1345               = next_inline_clone->prev_sibling_clone;
1346           if (next_inline_clone->prev_sibling_clone)
1347             {
1348               gcc_assert (node->clones != next_inline_clone);
1349               next_inline_clone->prev_sibling_clone->next_sibling_clone
1350                 = next_inline_clone->next_sibling_clone;
1351             }
1352           else
1353             {
1354               gcc_assert (node->clones == next_inline_clone);
1355               node->clones = next_inline_clone->next_sibling_clone;
1356             }
1357
1358           new_clones = node->clones;
1359           node->clones = NULL;
1360
1361           /* Copy clone info.  */
1362           next_inline_clone->clone = node->clone;
1363
1364           /* Now place it into clone tree at same level at NODE.  */
1365           next_inline_clone->clone_of = node->clone_of;
1366           next_inline_clone->prev_sibling_clone = NULL;
1367           next_inline_clone->next_sibling_clone = NULL;
1368           if (node->clone_of)
1369             {
1370               if (node->clone_of->clones)
1371                 node->clone_of->clones->prev_sibling_clone = next_inline_clone;
1372               next_inline_clone->next_sibling_clone = node->clone_of->clones;
1373               node->clone_of->clones = next_inline_clone;
1374             }
1375
1376           /* Merge the clone list.  */
1377           if (new_clones)
1378             {
1379               if (!next_inline_clone->clones)
1380                 next_inline_clone->clones = new_clones;
1381               else
1382                 {
1383                   n = next_inline_clone->clones;
1384                   while (n->next_sibling_clone)
1385                     n =  n->next_sibling_clone;
1386                   n->next_sibling_clone = new_clones;
1387                   new_clones->prev_sibling_clone = n;
1388                 }
1389             }
1390
1391           /* Update clone_of pointers.  */
1392           n = new_clones;
1393           while (n)
1394             {
1395               n->clone_of = next_inline_clone;
1396               n = n->next_sibling_clone;
1397             }
1398         }
1399       else
1400         {
1401           htab_clear_slot (cgraph_hash, slot);
1402           kill_body = true;
1403         }
1404
1405     }
1406   if (node->prev_sibling_clone)
1407     node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
1408   else if (node->clone_of)
1409     node->clone_of->clones = node->next_sibling_clone;
1410   if (node->next_sibling_clone)
1411     node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
1412   if (node->clones)
1413     {
1414       struct cgraph_node *n, *next;
1415
1416       if (node->clone_of)
1417         {
1418           for (n = node->clones; n->next_sibling_clone; n = n->next_sibling_clone)
1419             n->clone_of = node->clone_of;
1420           n->clone_of = node->clone_of;
1421           n->next_sibling_clone = node->clone_of->clones;
1422           if (node->clone_of->clones)
1423             node->clone_of->clones->prev_sibling_clone = n;
1424           node->clone_of->clones = node->clones;
1425         }
1426       else
1427         {
1428           /* We are removing node with clones.  this makes clones inconsistent,
1429              but assume they will be removed subsequently and just keep clone
1430              tree intact.  This can happen in unreachable function removal since
1431              we remove unreachable functions in random order, not by bottom-up
1432              walk of clone trees.  */
1433           for (n = node->clones; n; n = next)
1434             {
1435                next = n->next_sibling_clone;
1436                n->next_sibling_clone = NULL;
1437                n->prev_sibling_clone = NULL;
1438                n->clone_of = NULL;
1439             }
1440         }
1441     }
1442
1443   while (node->same_body)
1444     cgraph_remove_same_body_alias (node->same_body);
1445
1446   /* While all the clones are removed after being proceeded, the function
1447      itself is kept in the cgraph even after it is compiled.  Check whether
1448      we are done with this body and reclaim it proactively if this is the case.
1449      */
1450   if (!kill_body && *slot)
1451     {
1452       struct cgraph_node *n = (struct cgraph_node *) *slot;
1453       if (!n->clones && !n->clone_of && !n->global.inlined_to
1454           && (cgraph_global_info_ready
1455               && (TREE_ASM_WRITTEN (n->decl) || DECL_EXTERNAL (n->decl))))
1456         kill_body = true;
1457     }
1458   if (assembler_name_hash)
1459     {
1460       tree name = DECL_ASSEMBLER_NAME (node->decl);
1461       slot = htab_find_slot_with_hash (assembler_name_hash, name,
1462                                        decl_assembler_name_hash (name),
1463                                        NO_INSERT);
1464       /* Inline clones are not hashed.  */
1465       if (slot && *slot == node)
1466         htab_clear_slot (assembler_name_hash, slot);
1467     }
1468
1469   if (kill_body)
1470     cgraph_release_function_body (node);
1471   node->decl = NULL;
1472   if (node->call_site_hash)
1473     {
1474       htab_delete (node->call_site_hash);
1475       node->call_site_hash = NULL;
1476     }
1477   cgraph_n_nodes--;
1478
1479   /* Clear out the node to NULL all pointers and add the node to the free
1480      list.  */
1481   memset (node, 0, sizeof(*node));
1482   node->uid = uid;
1483   NEXT_FREE_NODE (node) = free_nodes;
1484   free_nodes = node;
1485 }
1486
1487 /* Remove the node from cgraph.  */
1488
1489 void
1490 cgraph_remove_node_and_inline_clones (struct cgraph_node *node)
1491 {
1492   struct cgraph_edge *e, *next;
1493   for (e = node->callees; e; e = next)
1494     {
1495       next = e->next_callee;
1496       if (!e->inline_failed)
1497         cgraph_remove_node_and_inline_clones (e->callee);
1498     }
1499   cgraph_remove_node (node);
1500 }
1501
1502 /* Notify finalize_compilation_unit that given node is reachable.  */
1503
1504 void
1505 cgraph_mark_reachable_node (struct cgraph_node *node)
1506 {
1507   if (!node->reachable && node->local.finalized)
1508     {
1509       notice_global_symbol (node->decl);
1510       node->reachable = 1;
1511       gcc_assert (!cgraph_global_info_ready);
1512
1513       node->next_needed = cgraph_nodes_queue;
1514       cgraph_nodes_queue = node;
1515     }
1516 }
1517
1518 /* Likewise indicate that a node is needed, i.e. reachable via some
1519    external means.  */
1520
1521 void
1522 cgraph_mark_needed_node (struct cgraph_node *node)
1523 {
1524   node->needed = 1;
1525   gcc_assert (!node->global.inlined_to);
1526   cgraph_mark_reachable_node (node);
1527 }
1528
1529 /* Likewise indicate that a node is having address taken.  */
1530
1531 void
1532 cgraph_mark_address_taken_node (struct cgraph_node *node)
1533 {
1534   node->address_taken = 1;
1535   cgraph_mark_needed_node (node);
1536 }
1537
1538 /* Return local info for the compiled function.  */
1539
1540 struct cgraph_local_info *
1541 cgraph_local_info (tree decl)
1542 {
1543   struct cgraph_node *node;
1544
1545   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1546   node = cgraph_node (decl);
1547   return &node->local;
1548 }
1549
1550 /* Return local info for the compiled function.  */
1551
1552 struct cgraph_global_info *
1553 cgraph_global_info (tree decl)
1554 {
1555   struct cgraph_node *node;
1556
1557   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL && cgraph_global_info_ready);
1558   node = cgraph_node (decl);
1559   return &node->global;
1560 }
1561
1562 /* Return local info for the compiled function.  */
1563
1564 struct cgraph_rtl_info *
1565 cgraph_rtl_info (tree decl)
1566 {
1567   struct cgraph_node *node;
1568
1569   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1570   node = cgraph_node (decl);
1571   if (decl != current_function_decl
1572       && !TREE_ASM_WRITTEN (node->decl))
1573     return NULL;
1574   return &node->rtl;
1575 }
1576
1577 /* Return a string describing the failure REASON.  */
1578
1579 const char*
1580 cgraph_inline_failed_string (cgraph_inline_failed_t reason)
1581 {
1582 #undef DEFCIFCODE
1583 #define DEFCIFCODE(code, string)        string,
1584
1585   static const char *cif_string_table[CIF_N_REASONS] = {
1586 #include "cif-code.def"
1587   };
1588
1589   /* Signedness of an enum type is implementation defined, so cast it
1590      to unsigned before testing. */
1591   gcc_assert ((unsigned) reason < CIF_N_REASONS);
1592   return cif_string_table[reason];
1593 }
1594
1595 /* Return name of the node used in debug output.  */
1596 const char *
1597 cgraph_node_name (struct cgraph_node *node)
1598 {
1599   return lang_hooks.decl_printable_name (node->decl, 2);
1600 }
1601
1602 /* Names used to print out the availability enum.  */
1603 const char * const cgraph_availability_names[] =
1604   {"unset", "not_available", "overwritable", "available", "local"};
1605
1606
1607 /* Dump call graph node NODE to file F.  */
1608
1609 void
1610 dump_cgraph_node (FILE *f, struct cgraph_node *node)
1611 {
1612   struct cgraph_edge *edge;
1613   fprintf (f, "%s/%i(%i)", cgraph_node_name (node), node->uid,
1614            node->pid);
1615   dump_addr (f, " @", (void *)node);
1616   if (node->global.inlined_to)
1617     fprintf (f, " (inline copy in %s/%i)",
1618              cgraph_node_name (node->global.inlined_to),
1619              node->global.inlined_to->uid);
1620   if (node->clone_of)
1621     fprintf (f, " (clone of %s/%i)",
1622              cgraph_node_name (node->clone_of),
1623              node->clone_of->uid);
1624   if (cgraph_function_flags_ready)
1625     fprintf (f, " availability:%s",
1626              cgraph_availability_names [cgraph_function_body_availability (node)]);
1627   if (node->count)
1628     fprintf (f, " executed "HOST_WIDEST_INT_PRINT_DEC"x",
1629              (HOST_WIDEST_INT)node->count);
1630   if (node->local.inline_summary.self_time)
1631     fprintf (f, " %i time, %i benefit", node->local.inline_summary.self_time,
1632                                         node->local.inline_summary.time_inlining_benefit);
1633   if (node->global.time && node->global.time
1634       != node->local.inline_summary.self_time)
1635     fprintf (f, " (%i after inlining)", node->global.time);
1636   if (node->local.inline_summary.self_size)
1637     fprintf (f, " %i size, %i benefit", node->local.inline_summary.self_size,
1638                                         node->local.inline_summary.size_inlining_benefit);
1639   if (node->global.size && node->global.size
1640       != node->local.inline_summary.self_size)
1641     fprintf (f, " (%i after inlining)", node->global.size);
1642   if (node->local.inline_summary.estimated_self_stack_size)
1643     fprintf (f, " %i bytes stack usage", (int)node->local.inline_summary.estimated_self_stack_size);
1644   if (node->global.estimated_stack_size != node->local.inline_summary.estimated_self_stack_size)
1645     fprintf (f, " %i bytes after inlining", (int)node->global.estimated_stack_size);
1646   if (node->origin)
1647     fprintf (f, " nested in: %s", cgraph_node_name (node->origin));
1648   if (node->needed)
1649     fprintf (f, " needed");
1650   if (node->address_taken)
1651     fprintf (f, " address_taken");
1652   else if (node->reachable)
1653     fprintf (f, " reachable");
1654   if (gimple_has_body_p (node->decl))
1655     fprintf (f, " body");
1656   if (node->process)
1657     fprintf (f, " process");
1658   if (node->local.local)
1659     fprintf (f, " local");
1660   if (node->local.externally_visible)
1661     fprintf (f, " externally_visible");
1662   if (node->local.finalized)
1663     fprintf (f, " finalized");
1664   if (node->local.disregard_inline_limits)
1665     fprintf (f, " always_inline");
1666   else if (node->local.inlinable)
1667     fprintf (f, " inlinable");
1668   if (node->local.redefined_extern_inline)
1669     fprintf (f, " redefined_extern_inline");
1670   if (TREE_ASM_WRITTEN (node->decl))
1671     fprintf (f, " asm_written");
1672
1673   fprintf (f, "\n  called by: ");
1674   for (edge = node->callers; edge; edge = edge->next_caller)
1675     {
1676       fprintf (f, "%s/%i ", cgraph_node_name (edge->caller),
1677                edge->caller->uid);
1678       if (edge->count)
1679         fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1680                  (HOST_WIDEST_INT)edge->count);
1681       if (edge->frequency)
1682         fprintf (f, "(%.2f per call) ",
1683                  edge->frequency / (double)CGRAPH_FREQ_BASE);
1684       if (!edge->inline_failed)
1685         fprintf(f, "(inlined) ");
1686       if (edge->indirect_call)
1687         fprintf(f, "(indirect) ");
1688       if (edge->can_throw_external)
1689         fprintf(f, "(can throw external) ");
1690     }
1691
1692   fprintf (f, "\n  calls: ");
1693   for (edge = node->callees; edge; edge = edge->next_callee)
1694     {
1695       fprintf (f, "%s/%i ", cgraph_node_name (edge->callee),
1696                edge->callee->uid);
1697       if (!edge->inline_failed)
1698         fprintf(f, "(inlined) ");
1699       if (edge->indirect_call)
1700         fprintf(f, "(indirect) ");
1701       if (edge->count)
1702         fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
1703                  (HOST_WIDEST_INT)edge->count);
1704       if (edge->frequency)
1705         fprintf (f, "(%.2f per call) ",
1706                  edge->frequency / (double)CGRAPH_FREQ_BASE);
1707       if (edge->loop_nest)
1708         fprintf (f, "(nested in %i loops) ", edge->loop_nest);
1709       if (edge->can_throw_external)
1710         fprintf(f, "(can throw external) ");
1711     }
1712   fprintf (f, "\n");
1713
1714   if (node->same_body)
1715     {
1716       struct cgraph_node *n;
1717       fprintf (f, "  aliases & thunks:");
1718       for (n = node->same_body; n; n = n->next)
1719         {
1720           fprintf (f, " %s/%i", cgraph_node_name (n), n->uid);
1721           if (n->thunk.thunk_p)
1722             {
1723               fprintf (f, " (thunk of %s fixed ofset %i virtual value %i has "
1724                        "virtual offset %i",
1725                        lang_hooks.decl_printable_name (n->thunk.alias, 2),
1726                        (int)n->thunk.fixed_offset,
1727                        (int)n->thunk.virtual_value,
1728                        (int)n->thunk.virtual_offset_p);
1729               fprintf (f, ")");
1730             }
1731         }
1732       fprintf (f, "\n");
1733     }
1734 }
1735
1736
1737 /* Dump call graph node NODE to stderr.  */
1738
1739 void
1740 debug_cgraph_node (struct cgraph_node *node)
1741 {
1742   dump_cgraph_node (stderr, node);
1743 }
1744
1745
1746 /* Dump the callgraph to file F.  */
1747
1748 void
1749 dump_cgraph (FILE *f)
1750 {
1751   struct cgraph_node *node;
1752
1753   fprintf (f, "callgraph:\n\n");
1754   for (node = cgraph_nodes; node; node = node->next)
1755     dump_cgraph_node (f, node);
1756 }
1757
1758
1759 /* Dump the call graph to stderr.  */
1760
1761 void
1762 debug_cgraph (void)
1763 {
1764   dump_cgraph (stderr);
1765 }
1766
1767
1768 /* Set the DECL_ASSEMBLER_NAME and update cgraph hashtables.  */
1769
1770 void
1771 change_decl_assembler_name (tree decl, tree name)
1772 {
1773   gcc_assert (!assembler_name_hash);
1774   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
1775     {
1776       SET_DECL_ASSEMBLER_NAME (decl, name);
1777       return;
1778     }
1779   if (name == DECL_ASSEMBLER_NAME (decl))
1780     return;
1781
1782   if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
1783       && DECL_RTL_SET_P (decl))
1784     warning (0, "%D renamed after being referenced in assembly", decl);
1785
1786   SET_DECL_ASSEMBLER_NAME (decl, name);
1787 }
1788
1789 /* Add a top-level asm statement to the list.  */
1790
1791 struct cgraph_asm_node *
1792 cgraph_add_asm_node (tree asm_str)
1793 {
1794   struct cgraph_asm_node *node;
1795
1796   node = GGC_CNEW (struct cgraph_asm_node);
1797   node->asm_str = asm_str;
1798   node->order = cgraph_order++;
1799   node->next = NULL;
1800   if (cgraph_asm_nodes == NULL)
1801     cgraph_asm_nodes = node;
1802   else
1803     cgraph_asm_last_node->next = node;
1804   cgraph_asm_last_node = node;
1805   return node;
1806 }
1807
1808 /* Return true when the DECL can possibly be inlined.  */
1809 bool
1810 cgraph_function_possibly_inlined_p (tree decl)
1811 {
1812   if (!cgraph_global_info_ready)
1813     return !DECL_UNINLINABLE (decl);
1814   return DECL_POSSIBLY_INLINED (decl);
1815 }
1816
1817 /* Create clone of E in the node N represented by CALL_EXPR the callgraph.  */
1818 struct cgraph_edge *
1819 cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
1820                    gimple call_stmt, unsigned stmt_uid, gcov_type count_scale,
1821                    int freq_scale, int loop_nest, bool update_original)
1822 {
1823   struct cgraph_edge *new_edge;
1824   gcov_type count = e->count * count_scale / REG_BR_PROB_BASE;
1825   gcov_type freq;
1826
1827   /* We do not want to ignore loop nest after frequency drops to 0.  */
1828   if (!freq_scale)
1829     freq_scale = 1;
1830   freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
1831   if (freq > CGRAPH_FREQ_MAX)
1832     freq = CGRAPH_FREQ_MAX;
1833   new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq,
1834                             e->loop_nest + loop_nest);
1835
1836   new_edge->inline_failed = e->inline_failed;
1837   new_edge->indirect_call = e->indirect_call;
1838   new_edge->lto_stmt_uid = stmt_uid;
1839   if (update_original)
1840     {
1841       e->count -= new_edge->count;
1842       if (e->count < 0)
1843         e->count = 0;
1844     }
1845   cgraph_call_edge_duplication_hooks (e, new_edge);
1846   return new_edge;
1847 }
1848
1849 /* Create node representing clone of N executed COUNT times.  Decrease
1850    the execution counts from original node too.
1851
1852    When UPDATE_ORIGINAL is true, the counts are subtracted from the original
1853    function's profile to reflect the fact that part of execution is handled
1854    by node.  */
1855 struct cgraph_node *
1856 cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq,
1857                    int loop_nest, bool update_original,
1858                    VEC(cgraph_edge_p,heap) *redirect_callers)
1859 {
1860   struct cgraph_node *new_node = cgraph_create_node ();
1861   struct cgraph_edge *e;
1862   gcov_type count_scale;
1863   unsigned i;
1864
1865   new_node->decl = n->decl;
1866   new_node->origin = n->origin;
1867   if (new_node->origin)
1868     {
1869       new_node->next_nested = new_node->origin->nested;
1870       new_node->origin->nested = new_node;
1871     }
1872   new_node->analyzed = n->analyzed;
1873   new_node->local = n->local;
1874   new_node->local.externally_visible = false;
1875   new_node->global = n->global;
1876   new_node->rtl = n->rtl;
1877   new_node->count = count;
1878   new_node->clone = n->clone;
1879   if (n->count)
1880     {
1881       if (new_node->count > n->count)
1882         count_scale = REG_BR_PROB_BASE;
1883       else
1884         count_scale = new_node->count * REG_BR_PROB_BASE / n->count;
1885     }
1886   else
1887     count_scale = 0;
1888   if (update_original)
1889     {
1890       n->count -= count;
1891       if (n->count < 0)
1892         n->count = 0;
1893     }
1894
1895   for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++)
1896     {
1897       /* Redirect calls to the old version node to point to its new
1898          version.  */
1899       cgraph_redirect_edge_callee (e, new_node);
1900     }
1901
1902
1903   for (e = n->callees;e; e=e->next_callee)
1904     cgraph_clone_edge (e, new_node, e->call_stmt, e->lto_stmt_uid,
1905                        count_scale, freq, loop_nest, update_original);
1906
1907   new_node->next_sibling_clone = n->clones;
1908   if (n->clones)
1909     n->clones->prev_sibling_clone = new_node;
1910   n->clones = new_node;
1911   new_node->clone_of = n;
1912
1913   cgraph_call_node_duplication_hooks (n, new_node);
1914   return new_node;
1915 }
1916
1917 /* Create a new name for omp child function.  Returns an identifier.  */
1918
1919 static GTY(()) unsigned int clone_fn_id_num;
1920
1921 static tree
1922 clone_function_name (tree decl)
1923 {
1924   tree name = DECL_ASSEMBLER_NAME (decl);
1925   size_t len = IDENTIFIER_LENGTH (name);
1926   char *tmp_name, *prefix;
1927
1928   prefix = XALLOCAVEC (char, len + strlen ("_clone") + 1);
1929   memcpy (prefix, IDENTIFIER_POINTER (name), len);
1930   strcpy (prefix + len, "_clone");
1931 #ifndef NO_DOT_IN_LABEL
1932   prefix[len] = '.';
1933 #elif !defined NO_DOLLAR_IN_LABEL
1934   prefix[len] = '$';
1935 #endif
1936   ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix, clone_fn_id_num++);
1937   return get_identifier (tmp_name);
1938 }
1939
1940 /* Create callgraph node clone with new declaration.  The actual body will
1941    be copied later at compilation stage.
1942
1943    TODO: after merging in ipa-sra use function call notes instead of args_to_skip
1944    bitmap interface.
1945    */
1946 struct cgraph_node *
1947 cgraph_create_virtual_clone (struct cgraph_node *old_node,
1948                              VEC(cgraph_edge_p,heap) *redirect_callers,
1949                              VEC(ipa_replace_map_p,gc) *tree_map,
1950                              bitmap args_to_skip)
1951 {
1952   tree old_decl = old_node->decl;
1953   struct cgraph_node *new_node = NULL;
1954   tree new_decl;
1955   struct cgraph_node key, **slot;
1956
1957   gcc_assert  (tree_versionable_function_p (old_decl));
1958
1959   /* Make a new FUNCTION_DECL tree node */
1960   if (!args_to_skip)
1961     new_decl = copy_node (old_decl);
1962   else
1963     new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
1964   DECL_STRUCT_FUNCTION (new_decl) = NULL;
1965
1966   /* Generate a new name for the new version. */
1967   DECL_NAME (new_decl) = clone_function_name (old_decl);
1968   SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
1969   SET_DECL_RTL (new_decl, NULL);
1970
1971   new_node = cgraph_clone_node (old_node, old_node->count,
1972                                 CGRAPH_FREQ_BASE, 0, false,
1973                                 redirect_callers);
1974   new_node->decl = new_decl;
1975   /* Update the properties.
1976      Make clone visible only within this translation unit.  Make sure
1977      that is not weak also.
1978      ??? We cannot use COMDAT linkage because there is no
1979      ABI support for this.  */
1980   DECL_EXTERNAL (new_node->decl) = 0;
1981   DECL_COMDAT_GROUP (new_node->decl) = 0;
1982   TREE_PUBLIC (new_node->decl) = 0;
1983   DECL_COMDAT (new_node->decl) = 0;
1984   DECL_WEAK (new_node->decl) = 0;
1985   new_node->clone.tree_map = tree_map;
1986   new_node->clone.args_to_skip = args_to_skip;
1987   if (!args_to_skip)
1988     new_node->clone.combined_args_to_skip = old_node->clone.combined_args_to_skip;
1989   else if (old_node->clone.combined_args_to_skip)
1990     {
1991       int newi = 0, oldi = 0;
1992       tree arg;
1993       bitmap new_args_to_skip = BITMAP_GGC_ALLOC ();
1994       struct cgraph_node *orig_node;
1995       for (orig_node = old_node; orig_node->clone_of; orig_node = orig_node->clone_of)
1996         ;
1997       for (arg = DECL_ARGUMENTS (orig_node->decl); arg; arg = TREE_CHAIN (arg), oldi++)
1998         {
1999           if (bitmap_bit_p (old_node->clone.combined_args_to_skip, oldi))
2000             {
2001               bitmap_set_bit (new_args_to_skip, oldi);
2002               continue;
2003             }
2004           if (bitmap_bit_p (args_to_skip, newi))
2005             bitmap_set_bit (new_args_to_skip, oldi);
2006           newi++;
2007         }
2008       new_node->clone.combined_args_to_skip = new_args_to_skip;
2009     }
2010   else
2011     new_node->clone.combined_args_to_skip = args_to_skip;
2012   new_node->local.externally_visible = 0;
2013   new_node->local.local = 1;
2014   new_node->lowered = true;
2015   new_node->reachable = true;
2016
2017   key.decl = new_decl;
2018   slot = (struct cgraph_node **) htab_find_slot (cgraph_hash, &key, INSERT);
2019   gcc_assert (!*slot);
2020   *slot = new_node;
2021   if (assembler_name_hash)
2022     {
2023       void **aslot;
2024       tree name = DECL_ASSEMBLER_NAME (new_decl);
2025
2026       aslot = htab_find_slot_with_hash (assembler_name_hash, name,
2027                                         decl_assembler_name_hash (name),
2028                                         INSERT);
2029       gcc_assert (!*aslot);
2030       *aslot = new_node;
2031     }
2032
2033   return new_node;
2034 }
2035
2036 /* NODE is no longer nested function; update cgraph accordingly.  */
2037 void
2038 cgraph_unnest_node (struct cgraph_node *node)
2039 {
2040   struct cgraph_node **node2 = &node->origin->nested;
2041   gcc_assert (node->origin);
2042
2043   while (*node2 != node)
2044     node2 = &(*node2)->next_nested;
2045   *node2 = node->next_nested;
2046   node->origin = NULL;
2047 }
2048
2049 /* Return function availability.  See cgraph.h for description of individual
2050    return values.  */
2051 enum availability
2052 cgraph_function_body_availability (struct cgraph_node *node)
2053 {
2054   enum availability avail;
2055   gcc_assert (cgraph_function_flags_ready);
2056   if (!node->analyzed)
2057     avail = AVAIL_NOT_AVAILABLE;
2058   else if (node->local.local)
2059     avail = AVAIL_LOCAL;
2060   else if (!node->local.externally_visible)
2061     avail = AVAIL_AVAILABLE;
2062   /* Inline functions are safe to be analyzed even if their sybol can
2063      be overwritten at runtime.  It is not meaningful to enfore any sane
2064      behaviour on replacing inline function by different body.  */
2065   else if (DECL_DECLARED_INLINE_P (node->decl))
2066     avail = AVAIL_AVAILABLE;
2067
2068   /* If the function can be overwritten, return OVERWRITABLE.  Take
2069      care at least of two notable extensions - the COMDAT functions
2070      used to share template instantiations in C++ (this is symmetric
2071      to code cp_cannot_inline_tree_fn and probably shall be shared and
2072      the inlinability hooks completely eliminated).
2073
2074      ??? Does the C++ one definition rule allow us to always return
2075      AVAIL_AVAILABLE here?  That would be good reason to preserve this
2076      bit.  */
2077
2078   else if (DECL_REPLACEABLE_P (node->decl) && !DECL_EXTERNAL (node->decl))
2079     avail = AVAIL_OVERWRITABLE;
2080   else avail = AVAIL_AVAILABLE;
2081
2082   return avail;
2083 }
2084
2085 /* Add the function FNDECL to the call graph.
2086    Unlike cgraph_finalize_function, this function is intended to be used
2087    by middle end and allows insertion of new function at arbitrary point
2088    of compilation.  The function can be either in high, low or SSA form
2089    GIMPLE.
2090
2091    The function is assumed to be reachable and have address taken (so no
2092    API breaking optimizations are performed on it).
2093
2094    Main work done by this function is to enqueue the function for later
2095    processing to avoid need the passes to be re-entrant.  */
2096
2097 void
2098 cgraph_add_new_function (tree fndecl, bool lowered)
2099 {
2100   struct cgraph_node *node;
2101   switch (cgraph_state)
2102     {
2103       case CGRAPH_STATE_CONSTRUCTION:
2104         /* Just enqueue function to be processed at nearest occurrence.  */
2105         node = cgraph_node (fndecl);
2106         node->next_needed = cgraph_new_nodes;
2107         if (lowered)
2108           node->lowered = true;
2109         cgraph_new_nodes = node;
2110         break;
2111
2112       case CGRAPH_STATE_IPA:
2113       case CGRAPH_STATE_IPA_SSA:
2114       case CGRAPH_STATE_EXPANSION:
2115         /* Bring the function into finalized state and enqueue for later
2116            analyzing and compilation.  */
2117         node = cgraph_node (fndecl);
2118         node->local.local = false;
2119         node->local.finalized = true;
2120         node->reachable = node->needed = true;
2121         if (!lowered && cgraph_state == CGRAPH_STATE_EXPANSION)
2122           {
2123             push_cfun (DECL_STRUCT_FUNCTION (fndecl));
2124             current_function_decl = fndecl;
2125             gimple_register_cfg_hooks ();
2126             tree_lowering_passes (fndecl);
2127             bitmap_obstack_initialize (NULL);
2128             if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
2129               execute_pass_list (pass_early_local_passes.pass.sub);
2130             bitmap_obstack_release (NULL);
2131             pop_cfun ();
2132             current_function_decl = NULL;
2133
2134             lowered = true;
2135           }
2136         if (lowered)
2137           node->lowered = true;
2138         node->next_needed = cgraph_new_nodes;
2139         cgraph_new_nodes = node;
2140         break;
2141
2142       case CGRAPH_STATE_FINISHED:
2143         /* At the very end of compilation we have to do all the work up
2144            to expansion.  */
2145         push_cfun (DECL_STRUCT_FUNCTION (fndecl));
2146         current_function_decl = fndecl;
2147         gimple_register_cfg_hooks ();
2148         if (!lowered)
2149           tree_lowering_passes (fndecl);
2150         bitmap_obstack_initialize (NULL);
2151         if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
2152           execute_pass_list (pass_early_local_passes.pass.sub);
2153         bitmap_obstack_release (NULL);
2154         tree_rest_of_compilation (fndecl);
2155         pop_cfun ();
2156         current_function_decl = NULL;
2157         break;
2158     }
2159
2160   /* Set a personality if required and we already passed EH lowering.  */
2161   if (lowered
2162       && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl))
2163           == eh_personality_lang))
2164     DECL_FUNCTION_PERSONALITY (fndecl) = lang_hooks.eh_personality ();
2165 }
2166
2167 /* Return true if NODE can be made local for API change.
2168    Extern inline functions and C++ COMDAT functions can be made local
2169    at the expense of possible code size growth if function is used in multiple
2170    compilation units.  */
2171 bool
2172 cgraph_node_can_be_local_p (struct cgraph_node *node)
2173 {
2174   return (!node->needed
2175           && (DECL_COMDAT (node->decl) || !node->local.externally_visible));
2176 }
2177
2178 /* Bring NODE local.  */
2179 void
2180 cgraph_make_node_local (struct cgraph_node *node)
2181 {
2182   gcc_assert (cgraph_node_can_be_local_p (node));
2183   if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
2184     {
2185       DECL_COMDAT (node->decl) = 0;
2186       DECL_COMDAT_GROUP (node->decl) = 0;
2187       TREE_PUBLIC (node->decl) = 0;
2188       DECL_WEAK (node->decl) = 0;
2189       DECL_EXTERNAL (node->decl) = 0;
2190       node->local.externally_visible = false;
2191       node->local.local = true;
2192       gcc_assert (cgraph_function_body_availability (node) == AVAIL_LOCAL);
2193     }
2194 }
2195
2196 #include "gt-cgraph.h"