Update gcc-50 to SVN version 221572
[dragonfly.git] / contrib / gcc-5.0 / gcc / cgraph.c
1 /* Callgraph handling code.
2    Copyright (C) 2003-2015 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 3, 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 COPYING3.  If not see
19 <http://www.gnu.org/licenses/>.  */
20
21 /*  This file contains basic routines manipulating call graph
22
23     The call-graph is a data structure designed for intra-procedural optimization.
24     It represents a multi-graph where nodes are functions and edges are call sites. */
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "hash-set.h"
31 #include "machmode.h"
32 #include "vec.h"
33 #include "double-int.h"
34 #include "input.h"
35 #include "alias.h"
36 #include "symtab.h"
37 #include "wide-int.h"
38 #include "inchash.h"
39 #include "tree.h"
40 #include "fold-const.h"
41 #include "varasm.h"
42 #include "calls.h"
43 #include "print-tree.h"
44 #include "tree-inline.h"
45 #include "langhooks.h"
46 #include "hashtab.h"
47 #include "toplev.h"
48 #include "flags.h"
49 #include "debug.h"
50 #include "target.h"
51 #include "predict.h"
52 #include "dominance.h"
53 #include "cfg.h"
54 #include "basic-block.h"
55 #include "hash-map.h"
56 #include "is-a.h"
57 #include "plugin-api.h"
58 #include "hard-reg-set.h"
59 #include "function.h"
60 #include "ipa-ref.h"
61 #include "cgraph.h"
62 #include "intl.h"
63 #include "tree-ssa-alias.h"
64 #include "internal-fn.h"
65 #include "tree-eh.h"
66 #include "gimple-expr.h"
67 #include "gimple.h"
68 #include "gimple-iterator.h"
69 #include "timevar.h"
70 #include "dumpfile.h"
71 #include "gimple-ssa.h"
72 #include "tree-cfg.h"
73 #include "tree-ssa.h"
74 #include "value-prof.h"
75 #include "except.h"
76 #include "diagnostic-core.h"
77 #include "rtl.h"
78 #include "ipa-utils.h"
79 #include "lto-streamer.h"
80 #include "alloc-pool.h"
81 #include "symbol-summary.h"
82 #include "ipa-prop.h"
83 #include "ipa-inline.h"
84 #include "cfgloop.h"
85 #include "gimple-pretty-print.h"
86 #include "statistics.h"
87 #include "real.h"
88 #include "fixed-value.h"
89 #include "insn-config.h"
90 #include "expmed.h"
91 #include "dojump.h"
92 #include "explow.h"
93 #include "emit-rtl.h"
94 #include "stmt.h"
95 #include "expr.h"
96 #include "tree-dfa.h"
97 #include "profile.h"
98 #include "params.h"
99 #include "tree-chkp.h"
100 #include "context.h"
101
102 /* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this.  */
103 #include "tree-pass.h"
104
105 /* Queue of cgraph nodes scheduled to be lowered.  */
106 symtab_node *x_cgraph_nodes_queue;
107 #define cgraph_nodes_queue ((cgraph_node *)x_cgraph_nodes_queue)
108
109 /* Symbol table global context.  */
110 symbol_table *symtab;
111
112 /* List of hooks triggered on cgraph_edge events.  */
113 struct cgraph_edge_hook_list {
114   cgraph_edge_hook hook;
115   void *data;
116   struct cgraph_edge_hook_list *next;
117 };
118
119 /* List of hooks triggered on cgraph_node events.  */
120 struct cgraph_node_hook_list {
121   cgraph_node_hook hook;
122   void *data;
123   struct cgraph_node_hook_list *next;
124 };
125
126 /* List of hooks triggered on events involving two cgraph_edges.  */
127 struct cgraph_2edge_hook_list {
128   cgraph_2edge_hook hook;
129   void *data;
130   struct cgraph_2edge_hook_list *next;
131 };
132
133 /* List of hooks triggered on events involving two cgraph_nodes.  */
134 struct cgraph_2node_hook_list {
135   cgraph_2node_hook hook;
136   void *data;
137   struct cgraph_2node_hook_list *next;
138 };
139
140 /* Hash descriptor for cgraph_function_version_info.  */
141
142 struct function_version_hasher : ggc_hasher<cgraph_function_version_info *>
143 {
144   static hashval_t hash (cgraph_function_version_info *);
145   static bool equal (cgraph_function_version_info *,
146                      cgraph_function_version_info *);
147 };
148
149 /* Map a cgraph_node to cgraph_function_version_info using this htab.
150    The cgraph_function_version_info has a THIS_NODE field that is the
151    corresponding cgraph_node..  */
152
153 static GTY(()) hash_table<function_version_hasher> *cgraph_fnver_htab = NULL;
154
155 /* Hash function for cgraph_fnver_htab.  */
156 hashval_t
157 function_version_hasher::hash (cgraph_function_version_info *ptr)
158 {
159   int uid = ptr->this_node->uid;
160   return (hashval_t)(uid);
161 }
162
163 /* eq function for cgraph_fnver_htab.  */
164 bool
165 function_version_hasher::equal (cgraph_function_version_info *n1,
166                                 cgraph_function_version_info *n2)
167 {
168   return n1->this_node->uid == n2->this_node->uid;
169 }
170
171 /* Mark as GC root all allocated nodes.  */
172 static GTY(()) struct cgraph_function_version_info *
173   version_info_node = NULL;
174
175 /* Get the cgraph_function_version_info node corresponding to node.  */
176 cgraph_function_version_info *
177 cgraph_node::function_version (void)
178 {
179   cgraph_function_version_info key;
180   key.this_node = this;
181
182   if (cgraph_fnver_htab == NULL)
183     return NULL;
184
185   return cgraph_fnver_htab->find (&key);
186 }
187
188 /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
189    corresponding to cgraph_node NODE.  */
190 cgraph_function_version_info *
191 cgraph_node::insert_new_function_version (void)
192 {
193   version_info_node = NULL;
194   version_info_node = ggc_cleared_alloc<cgraph_function_version_info> ();
195   version_info_node->this_node = this;
196
197   if (cgraph_fnver_htab == NULL)
198     cgraph_fnver_htab = hash_table<function_version_hasher>::create_ggc (2);
199
200   *cgraph_fnver_htab->find_slot (version_info_node, INSERT)
201     = version_info_node;
202   return version_info_node;
203 }
204
205 /* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
206    DECL is a duplicate declaration.  */
207 void
208 cgraph_node::delete_function_version (tree decl)
209 {
210   cgraph_node *decl_node = cgraph_node::get (decl);
211   cgraph_function_version_info *decl_v = NULL;
212
213   if (decl_node == NULL)
214     return;
215
216   decl_v = decl_node->function_version ();
217
218   if (decl_v == NULL)
219     return;
220
221   if (decl_v->prev != NULL)
222    decl_v->prev->next = decl_v->next;
223
224   if (decl_v->next != NULL)
225     decl_v->next->prev = decl_v->prev;
226
227   if (cgraph_fnver_htab != NULL)
228     cgraph_fnver_htab->remove_elt (decl_v);
229
230   decl_node->remove ();
231 }
232
233 /* Record that DECL1 and DECL2 are semantically identical function
234    versions.  */
235 void
236 cgraph_node::record_function_versions (tree decl1, tree decl2)
237 {
238   cgraph_node *decl1_node = cgraph_node::get_create (decl1);
239   cgraph_node *decl2_node = cgraph_node::get_create (decl2);
240   cgraph_function_version_info *decl1_v = NULL;
241   cgraph_function_version_info *decl2_v = NULL;
242   cgraph_function_version_info *before;
243   cgraph_function_version_info *after;
244
245   gcc_assert (decl1_node != NULL && decl2_node != NULL);
246   decl1_v = decl1_node->function_version ();
247   decl2_v = decl2_node->function_version ();
248
249   if (decl1_v != NULL && decl2_v != NULL)
250     return;
251
252   if (decl1_v == NULL)
253     decl1_v = decl1_node->insert_new_function_version ();
254
255   if (decl2_v == NULL)
256     decl2_v = decl2_node->insert_new_function_version ();
257
258   /* Chain decl2_v and decl1_v.  All semantically identical versions
259      will be chained together.  */
260
261   before = decl1_v;
262   after = decl2_v;
263
264   while (before->next != NULL)
265     before = before->next;
266
267   while (after->prev != NULL)
268     after= after->prev;
269
270   before->next = after;
271   after->prev = before;
272 }
273
274 /* Initialize callgraph dump file.  */
275
276 void
277 symbol_table::initialize (void)
278 {
279   if (!dump_file)
280     dump_file = dump_begin (TDI_cgraph, NULL);
281 }
282
283 /* Allocate new callgraph node and insert it into basic data structures.  */
284
285 cgraph_node *
286 symbol_table::create_empty (void)
287 {
288   cgraph_node *node = allocate_cgraph_symbol ();
289
290   node->type = SYMTAB_FUNCTION;
291   node->frequency = NODE_FREQUENCY_NORMAL;
292   node->count_materialization_scale = REG_BR_PROB_BASE;
293   cgraph_count++;
294
295   return node;
296 }
297
298 /* Register HOOK to be called with DATA on each removed edge.  */
299 cgraph_edge_hook_list *
300 symbol_table::add_edge_removal_hook (cgraph_edge_hook hook, void *data)
301 {
302   cgraph_edge_hook_list *entry;
303   cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;
304
305   entry = (cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
306   entry->hook = hook;
307   entry->data = data;
308   entry->next = NULL;
309   while (*ptr)
310     ptr = &(*ptr)->next;
311   *ptr = entry;
312   return entry;
313 }
314
315 /* Remove ENTRY from the list of hooks called on removing edges.  */
316 void
317 symbol_table::remove_edge_removal_hook (cgraph_edge_hook_list *entry)
318 {
319   cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;
320
321   while (*ptr != entry)
322     ptr = &(*ptr)->next;
323   *ptr = entry->next;
324   free (entry);
325 }
326
327 /* Call all edge removal hooks.  */
328 void
329 symbol_table::call_edge_removal_hooks (cgraph_edge *e)
330 {
331   cgraph_edge_hook_list *entry = m_first_edge_removal_hook;
332   while (entry)
333   {
334     entry->hook (e, entry->data);
335     entry = entry->next;
336   }
337 }
338
339 /* Register HOOK to be called with DATA on each removed node.  */
340 cgraph_node_hook_list *
341 symbol_table::add_cgraph_removal_hook (cgraph_node_hook hook, void *data)
342 {
343   cgraph_node_hook_list *entry;
344   cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;
345
346   entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
347   entry->hook = hook;
348   entry->data = data;
349   entry->next = NULL;
350   while (*ptr)
351     ptr = &(*ptr)->next;
352   *ptr = entry;
353   return entry;
354 }
355
356 /* Remove ENTRY from the list of hooks called on removing nodes.  */
357 void
358 symbol_table::remove_cgraph_removal_hook (cgraph_node_hook_list *entry)
359 {
360   cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;
361
362   while (*ptr != entry)
363     ptr = &(*ptr)->next;
364   *ptr = entry->next;
365   free (entry);
366 }
367
368 /* Call all node removal hooks.  */
369 void
370 symbol_table::call_cgraph_removal_hooks (cgraph_node *node)
371 {
372   cgraph_node_hook_list *entry = m_first_cgraph_removal_hook;
373   while (entry)
374   {
375     entry->hook (node, entry->data);
376     entry = entry->next;
377   }
378 }
379
380 /* Call all node removal hooks.  */
381 void
382 symbol_table::call_cgraph_insertion_hooks (cgraph_node *node)
383 {
384   cgraph_node_hook_list *entry = m_first_cgraph_insertion_hook;
385   while (entry)
386   {
387     entry->hook (node, entry->data);
388     entry = entry->next;
389   }
390 }
391
392
393 /* Register HOOK to be called with DATA on each inserted node.  */
394 cgraph_node_hook_list *
395 symbol_table::add_cgraph_insertion_hook (cgraph_node_hook hook, void *data)
396 {
397   cgraph_node_hook_list *entry;
398   cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;
399
400   entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
401   entry->hook = hook;
402   entry->data = data;
403   entry->next = NULL;
404   while (*ptr)
405     ptr = &(*ptr)->next;
406   *ptr = entry;
407   return entry;
408 }
409
410 /* Remove ENTRY from the list of hooks called on inserted nodes.  */
411 void
412 symbol_table::remove_cgraph_insertion_hook (cgraph_node_hook_list *entry)
413 {
414   cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;
415
416   while (*ptr != entry)
417     ptr = &(*ptr)->next;
418   *ptr = entry->next;
419   free (entry);
420 }
421
422 /* Register HOOK to be called with DATA on each duplicated edge.  */
423 cgraph_2edge_hook_list *
424 symbol_table::add_edge_duplication_hook (cgraph_2edge_hook hook, void *data)
425 {
426   cgraph_2edge_hook_list *entry;
427   cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;
428
429   entry = (cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
430   entry->hook = hook;
431   entry->data = data;
432   entry->next = NULL;
433   while (*ptr)
434     ptr = &(*ptr)->next;
435   *ptr = entry;
436   return entry;
437 }
438
439 /* Remove ENTRY from the list of hooks called on duplicating edges.  */
440 void
441 symbol_table::remove_edge_duplication_hook (cgraph_2edge_hook_list *entry)
442 {
443   cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;
444
445   while (*ptr != entry)
446     ptr = &(*ptr)->next;
447   *ptr = entry->next;
448   free (entry);
449 }
450
451 /* Call all edge duplication hooks.  */
452 void
453 symbol_table::call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2)
454 {
455   cgraph_2edge_hook_list *entry = m_first_edge_duplicated_hook;
456   while (entry)
457   {
458     entry->hook (cs1, cs2, entry->data);
459     entry = entry->next;
460   }
461 }
462
463 /* Register HOOK to be called with DATA on each duplicated node.  */
464 cgraph_2node_hook_list *
465 symbol_table::add_cgraph_duplication_hook (cgraph_2node_hook hook, void *data)
466 {
467   cgraph_2node_hook_list *entry;
468   cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;
469
470   entry = (cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
471   entry->hook = hook;
472   entry->data = data;
473   entry->next = NULL;
474   while (*ptr)
475     ptr = &(*ptr)->next;
476   *ptr = entry;
477   return entry;
478 }
479
480 /* Remove ENTRY from the list of hooks called on duplicating nodes.  */
481 void
482 symbol_table::remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry)
483 {
484   cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;
485
486   while (*ptr != entry)
487     ptr = &(*ptr)->next;
488   *ptr = entry->next;
489   free (entry);
490 }
491
492 /* Call all node duplication hooks.  */
493 void
494 symbol_table::call_cgraph_duplication_hooks (cgraph_node *node,
495                                              cgraph_node *node2)
496 {
497   cgraph_2node_hook_list *entry = m_first_cgraph_duplicated_hook;
498   while (entry)
499   {
500     entry->hook (node, node2, entry->data);
501     entry = entry->next;
502   }
503 }
504
505 /* Return cgraph node assigned to DECL.  Create new one when needed.  */
506
507 cgraph_node *
508 cgraph_node::create (tree decl)
509 {
510   cgraph_node *node = symtab->create_empty ();
511   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
512
513   node->decl = decl;
514
515   if ((flag_openacc || flag_openmp)
516       && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl)))
517     {
518       node->offloadable = 1;
519 #ifdef ENABLE_OFFLOADING
520       g->have_offload = true;
521 #endif
522     }
523
524   node->register_symbol ();
525
526   if (DECL_CONTEXT (decl) && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL)
527     {
528       node->origin = cgraph_node::get_create (DECL_CONTEXT (decl));
529       node->next_nested = node->origin->nested;
530       node->origin->nested = node;
531     }
532   return node;
533 }
534
535 /* Try to find a call graph node for declaration DECL and if it does not exist
536    or if it corresponds to an inline clone, create a new one.  */
537
538 cgraph_node *
539 cgraph_node::get_create (tree decl)
540 {
541   cgraph_node *first_clone = cgraph_node::get (decl);
542
543   if (first_clone && !first_clone->global.inlined_to)
544     return first_clone;
545
546   cgraph_node *node = cgraph_node::create (decl);
547   if (first_clone)
548     {
549       first_clone->clone_of = node;
550       node->clones = first_clone;
551       symtab->symtab_prevail_in_asm_name_hash (node);
552       node->decl->decl_with_vis.symtab_node = node;
553       if (dump_file)
554         fprintf (dump_file, "Introduced new external node "
555                  "(%s/%i) and turned into root of the clone tree.\n",
556                  node->name (), node->order);
557     }
558   else if (dump_file)
559     fprintf (dump_file, "Introduced new external node "
560              "(%s/%i).\n", node->name (), node->order);
561   return node;
562 }
563
564 /* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
565    the function body is associated with (not necessarily cgraph_node (DECL).  */
566
567 cgraph_node *
568 cgraph_node::create_alias (tree alias, tree target)
569 {
570   cgraph_node *alias_node;
571
572   gcc_assert (TREE_CODE (target) == FUNCTION_DECL
573               || TREE_CODE (target) == IDENTIFIER_NODE);
574   gcc_assert (TREE_CODE (alias) == FUNCTION_DECL);
575   alias_node = cgraph_node::get_create (alias);
576   gcc_assert (!alias_node->definition);
577   alias_node->alias_target = target;
578   alias_node->definition = true;
579   alias_node->alias = true;
580   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)) != NULL)
581     alias_node->weakref = true;
582   return alias_node;
583 }
584
585 /* Attempt to mark ALIAS as an alias to DECL.  Return alias node if successful
586    and NULL otherwise.
587    Same body aliases are output whenever the body of DECL is output,
588    and cgraph_node::get (ALIAS) transparently returns
589    cgraph_node::get (DECL).  */
590
591 cgraph_node *
592 cgraph_node::create_same_body_alias (tree alias, tree decl)
593 {
594   cgraph_node *n;
595 #ifndef ASM_OUTPUT_DEF
596   /* If aliases aren't supported by the assembler, fail.  */
597   return NULL;
598 #endif
599   /* Langhooks can create same body aliases of symbols not defined.
600      Those are useless. Drop them on the floor.  */
601   if (symtab->global_info_ready)
602     return NULL;
603
604   n = cgraph_node::create_alias (alias, decl);
605   n->cpp_implicit_alias = true;
606   if (symtab->cpp_implicit_aliases_done)
607     n->resolve_alias (cgraph_node::get (decl));
608   return n;
609 }
610
611 /* Add thunk alias into callgraph.  The alias declaration is ALIAS and it
612    aliases DECL with an adjustments made into the first parameter.
613    See comments in thunk_adjust for detail on the parameters.  */
614
615 cgraph_node *
616 cgraph_node::create_thunk (tree alias, tree, bool this_adjusting,
617                            HOST_WIDE_INT fixed_offset,
618                            HOST_WIDE_INT virtual_value,
619                            tree virtual_offset,
620                            tree real_alias)
621 {
622   cgraph_node *node;
623
624   node = cgraph_node::get (alias);
625   if (node)
626     node->reset ();
627   else
628     node = cgraph_node::create (alias);
629   gcc_checking_assert (!virtual_offset
630                        || wi::eq_p (virtual_offset, virtual_value));
631   node->thunk.fixed_offset = fixed_offset;
632   node->thunk.this_adjusting = this_adjusting;
633   node->thunk.virtual_value = virtual_value;
634   node->thunk.virtual_offset_p = virtual_offset != NULL;
635   node->thunk.alias = real_alias;
636   node->thunk.thunk_p = true;
637   node->definition = true;
638
639   return node;
640 }
641
642 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
643    Return NULL if there's no such node.  */
644
645 cgraph_node *
646 cgraph_node::get_for_asmname (tree asmname)
647 {
648   /* We do not want to look at inline clones.  */
649   for (symtab_node *node = symtab_node::get_for_asmname (asmname);
650        node;
651        node = node->next_sharing_asm_name)
652     {
653       cgraph_node *cn = dyn_cast <cgraph_node *> (node);
654       if (cn && !cn->global.inlined_to)
655         return cn;
656     }
657   return NULL;
658 }
659
660 /* Returns a hash value for X (which really is a cgraph_edge).  */
661
662 hashval_t
663 cgraph_edge_hasher::hash (cgraph_edge *e)
664 {
665   /* This is a really poor hash function, but it is what htab_hash_pointer
666      uses.  */
667   return (hashval_t) ((intptr_t)e->call_stmt >> 3);
668 }
669
670 /* Returns a hash value for X (which really is a cgraph_edge).  */
671
672 hashval_t
673 cgraph_edge_hasher::hash (gimple call_stmt)
674 {
675   /* This is a really poor hash function, but it is what htab_hash_pointer
676      uses.  */
677   return (hashval_t) ((intptr_t)call_stmt >> 3);
678 }
679
680 /* Return nonzero if the call_stmt of of cgraph_edge X is stmt *Y.  */
681
682 inline bool
683 cgraph_edge_hasher::equal (cgraph_edge *x, gimple y)
684 {
685   return x->call_stmt == y;
686 }
687
688 /* Add call graph edge E to call site hash of its caller.  */
689
690 static inline void
691 cgraph_update_edge_in_call_site_hash (cgraph_edge *e)
692 {
693   gimple call = e->call_stmt;
694   *e->caller->call_site_hash->find_slot_with_hash
695       (call, cgraph_edge_hasher::hash (call), INSERT) = e;
696 }
697
698 /* Add call graph edge E to call site hash of its caller.  */
699
700 static inline void
701 cgraph_add_edge_to_call_site_hash (cgraph_edge *e)
702 {
703   /* There are two speculative edges for every statement (one direct,
704      one indirect); always hash the direct one.  */
705   if (e->speculative && e->indirect_unknown_callee)
706     return;
707   cgraph_edge **slot = e->caller->call_site_hash->find_slot_with_hash
708       (e->call_stmt, cgraph_edge_hasher::hash (e->call_stmt), INSERT);
709   if (*slot)
710     {
711       gcc_assert (((cgraph_edge *)*slot)->speculative);
712       if (e->callee)
713         *slot = e;
714       return;
715     }
716   gcc_assert (!*slot || e->speculative);
717   *slot = e;
718 }
719
720 /* Return the callgraph edge representing the GIMPLE_CALL statement
721    CALL_STMT.  */
722
723 cgraph_edge *
724 cgraph_node::get_edge (gimple call_stmt)
725 {
726   cgraph_edge *e, *e2;
727   int n = 0;
728
729   if (call_site_hash)
730     return call_site_hash->find_with_hash
731         (call_stmt, cgraph_edge_hasher::hash (call_stmt));
732
733   /* This loop may turn out to be performance problem.  In such case adding
734      hashtables into call nodes with very many edges is probably best
735      solution.  It is not good idea to add pointer into CALL_EXPR itself
736      because we want to make possible having multiple cgraph nodes representing
737      different clones of the same body before the body is actually cloned.  */
738   for (e = callees; e; e = e->next_callee)
739     {
740       if (e->call_stmt == call_stmt)
741         break;
742       n++;
743     }
744
745   if (!e)
746     for (e = indirect_calls; e; e = e->next_callee)
747       {
748         if (e->call_stmt == call_stmt)
749           break;
750         n++;
751       }
752
753   if (n > 100)
754     {
755       call_site_hash = hash_table<cgraph_edge_hasher>::create_ggc (120);
756       for (e2 = callees; e2; e2 = e2->next_callee)
757         cgraph_add_edge_to_call_site_hash (e2);
758       for (e2 = indirect_calls; e2; e2 = e2->next_callee)
759         cgraph_add_edge_to_call_site_hash (e2);
760     }
761
762   return e;
763 }
764
765
766 /* Change field call_stmt of edge to NEW_STMT.
767    If UPDATE_SPECULATIVE and E is any component of speculative
768    edge, then update all components.  */
769
770 void
771 cgraph_edge::set_call_stmt (gcall *new_stmt, bool update_speculative)
772 {
773   tree decl;
774
775   /* Speculative edges has three component, update all of them
776      when asked to.  */
777   if (update_speculative && speculative)
778     {
779       cgraph_edge *direct, *indirect;
780       ipa_ref *ref;
781
782       speculative_call_info (direct, indirect, ref);
783       direct->set_call_stmt (new_stmt, false);
784       indirect->set_call_stmt (new_stmt, false);
785       ref->stmt = new_stmt;
786       return;
787     }
788
789   /* Only direct speculative edges go to call_site_hash.  */
790   if (caller->call_site_hash
791       && (!speculative || !indirect_unknown_callee))
792     {
793       caller->call_site_hash->remove_elt_with_hash
794         (call_stmt, cgraph_edge_hasher::hash (call_stmt));
795     }
796
797   cgraph_edge *e = this;
798
799   call_stmt = new_stmt;
800   if (indirect_unknown_callee
801       && (decl = gimple_call_fndecl (new_stmt)))
802     {
803       /* Constant propagation (and possibly also inlining?) can turn an
804          indirect call into a direct one.  */
805       cgraph_node *new_callee = cgraph_node::get (decl);
806
807       gcc_checking_assert (new_callee);
808       e = make_direct (new_callee);
809     }
810
811   push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
812   e->can_throw_external = stmt_can_throw_external (new_stmt);
813   pop_cfun ();
814   if (e->caller->call_site_hash)
815     cgraph_add_edge_to_call_site_hash (e);
816 }
817
818 /* Allocate a cgraph_edge structure and fill it with data according to the
819    parameters of which only CALLEE can be NULL (when creating an indirect call
820    edge).  */
821
822 cgraph_edge *
823 symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee,
824                            gcall *call_stmt, gcov_type count, int freq,
825                            bool indir_unknown_callee)
826 {
827   cgraph_edge *edge;
828
829   /* LTO does not actually have access to the call_stmt since these
830      have not been loaded yet.  */
831   if (call_stmt)
832     {
833       /* This is a rather expensive check possibly triggering
834          construction of call stmt hashtable.  */
835 #ifdef ENABLE_CHECKING
836       cgraph_edge *e;
837       gcc_checking_assert (
838         !(e = caller->get_edge (call_stmt)) || e->speculative);
839 #endif
840
841       gcc_assert (is_gimple_call (call_stmt));
842     }
843
844   if (free_edges)
845     {
846       edge = free_edges;
847       free_edges = NEXT_FREE_EDGE (edge);
848     }
849   else
850     {
851       edge = ggc_alloc<cgraph_edge> ();
852       edge->uid = edges_max_uid++;
853     }
854
855   edges_count++;
856
857   edge->aux = NULL;
858   edge->caller = caller;
859   edge->callee = callee;
860   edge->prev_caller = NULL;
861   edge->next_caller = NULL;
862   edge->prev_callee = NULL;
863   edge->next_callee = NULL;
864   edge->lto_stmt_uid = 0;
865
866   edge->count = count;
867   gcc_assert (count >= 0);
868   edge->frequency = freq;
869   gcc_assert (freq >= 0);
870   gcc_assert (freq <= CGRAPH_FREQ_MAX);
871
872   edge->call_stmt = call_stmt;
873   push_cfun (DECL_STRUCT_FUNCTION (caller->decl));
874   edge->can_throw_external
875     = call_stmt ? stmt_can_throw_external (call_stmt) : false;
876   pop_cfun ();
877   if (call_stmt
878       && callee && callee->decl
879       && !gimple_check_call_matching_types (call_stmt, callee->decl,
880                                             false))
881     edge->call_stmt_cannot_inline_p = true;
882   else
883     edge->call_stmt_cannot_inline_p = false;
884
885   edge->indirect_info = NULL;
886   edge->indirect_inlining_edge = 0;
887   edge->speculative = false;
888   edge->indirect_unknown_callee = indir_unknown_callee;
889   if (opt_for_fn (edge->caller->decl, flag_devirtualize)
890       && call_stmt && DECL_STRUCT_FUNCTION (caller->decl))
891     edge->in_polymorphic_cdtor
892       = decl_maybe_in_construction_p (NULL, NULL, call_stmt,
893                                       caller->decl);
894   else
895     edge->in_polymorphic_cdtor = caller->thunk.thunk_p;
896   if (call_stmt && caller->call_site_hash)
897     cgraph_add_edge_to_call_site_hash (edge);
898
899   return edge;
900 }
901
902 /* Create edge from a given function to CALLEE in the cgraph.  */
903
904 cgraph_edge *
905 cgraph_node::create_edge (cgraph_node *callee,
906                           gcall *call_stmt, gcov_type count, int freq)
907 {
908   cgraph_edge *edge = symtab->create_edge (this, callee, call_stmt, count,
909                                            freq, false);
910
911   initialize_inline_failed (edge);
912
913   edge->next_caller = callee->callers;
914   if (callee->callers)
915     callee->callers->prev_caller = edge;
916   edge->next_callee = callees;
917   if (callees)
918     callees->prev_callee = edge;
919   callees = edge;
920   callee->callers = edge;
921
922   return edge;
923 }
924
925 /* Allocate cgraph_indirect_call_info and set its fields to default values. */
926
927 cgraph_indirect_call_info *
928 cgraph_allocate_init_indirect_info (void)
929 {
930   cgraph_indirect_call_info *ii;
931
932   ii = ggc_cleared_alloc<cgraph_indirect_call_info> ();
933   ii->param_index = -1;
934   return ii;
935 }
936
937 /* Create an indirect edge with a yet-undetermined callee where the call
938    statement destination is a formal parameter of the caller with index
939    PARAM_INDEX. */
940
941 cgraph_edge *
942 cgraph_node::create_indirect_edge (gcall *call_stmt, int ecf_flags,
943                                    gcov_type count, int freq,
944                                    bool compute_indirect_info)
945 {
946   cgraph_edge *edge = symtab->create_edge (this, NULL, call_stmt,
947                                                             count, freq, true);
948   tree target;
949
950   initialize_inline_failed (edge);
951
952   edge->indirect_info = cgraph_allocate_init_indirect_info ();
953   edge->indirect_info->ecf_flags = ecf_flags;
954   edge->indirect_info->vptr_changed = true;
955
956   /* Record polymorphic call info.  */
957   if (compute_indirect_info
958       && call_stmt
959       && (target = gimple_call_fn (call_stmt))
960       && virtual_method_call_p (target))
961     {
962       ipa_polymorphic_call_context context (decl, target, call_stmt);
963
964       /* Only record types can have virtual calls.  */
965       edge->indirect_info->polymorphic = true;
966       edge->indirect_info->param_index = -1;
967       edge->indirect_info->otr_token
968          = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target));
969       edge->indirect_info->otr_type = obj_type_ref_class (target);
970       gcc_assert (TREE_CODE (edge->indirect_info->otr_type) == RECORD_TYPE);
971       edge->indirect_info->context = context;
972     }
973
974   edge->next_callee = indirect_calls;
975   if (indirect_calls)
976     indirect_calls->prev_callee = edge;
977   indirect_calls = edge;
978
979   return edge;
980 }
981
982 /* Remove the edge from the list of the callees of the caller.  */
983
984 void
985 cgraph_edge::remove_caller (void)
986 {
987   if (prev_callee)
988     prev_callee->next_callee = next_callee;
989   if (next_callee)
990     next_callee->prev_callee = prev_callee;
991   if (!prev_callee)
992     {
993       if (indirect_unknown_callee)
994         caller->indirect_calls = next_callee;
995       else
996         caller->callees = next_callee;
997     }
998   if (caller->call_site_hash)
999     caller->call_site_hash->remove_elt_with_hash
1000         (call_stmt, cgraph_edge_hasher::hash (call_stmt));
1001 }
1002
1003 /* Put the edge onto the free list.  */
1004
1005 void
1006 symbol_table::free_edge (cgraph_edge *e)
1007 {
1008   int uid = e->uid;
1009
1010   if (e->indirect_info)
1011     ggc_free (e->indirect_info);
1012
1013   /* Clear out the edge so we do not dangle pointers.  */
1014   memset (e, 0, sizeof (*e));
1015   e->uid = uid;
1016   NEXT_FREE_EDGE (e) = free_edges;
1017   free_edges = e;
1018   edges_count--;
1019 }
1020
1021 /* Remove the edge in the cgraph.  */
1022
1023 void
1024 cgraph_edge::remove (void)
1025 {
1026   /* Call all edge removal hooks.  */
1027   symtab->call_edge_removal_hooks (this);
1028
1029   if (!indirect_unknown_callee)
1030     /* Remove from callers list of the callee.  */
1031     remove_callee ();
1032
1033   /* Remove from callees list of the callers.  */
1034   remove_caller ();
1035
1036   /* Put the edge onto the free list.  */
1037   symtab->free_edge (this);
1038 }
1039
1040 /* Turn edge into speculative call calling N2. Update
1041    the profile so the direct call is taken COUNT times
1042    with FREQUENCY.  
1043
1044    At clone materialization time, the indirect call E will
1045    be expanded as:
1046
1047    if (call_dest == N2)
1048      n2 ();
1049    else
1050      call call_dest
1051
1052    At this time the function just creates the direct call,
1053    the referencd representing the if conditional and attaches
1054    them all to the orginal indirect call statement.  
1055
1056    Return direct edge created.  */
1057
1058 cgraph_edge *
1059 cgraph_edge::make_speculative (cgraph_node *n2, gcov_type direct_count,
1060                                int direct_frequency)
1061 {
1062   cgraph_node *n = caller;
1063   ipa_ref *ref = NULL;
1064   cgraph_edge *e2;
1065
1066   if (dump_file)
1067     {
1068       fprintf (dump_file, "Indirect call -> speculative call"
1069                " %s/%i => %s/%i\n",
1070                xstrdup_for_dump (n->name ()), n->order,
1071                xstrdup_for_dump (n2->name ()), n2->order);
1072     }
1073   speculative = true;
1074   e2 = n->create_edge (n2, call_stmt, direct_count, direct_frequency);
1075   initialize_inline_failed (e2);
1076   e2->speculative = true;
1077   if (TREE_NOTHROW (n2->decl))
1078     e2->can_throw_external = false;
1079   else
1080     e2->can_throw_external = can_throw_external;
1081   e2->lto_stmt_uid = lto_stmt_uid;
1082   e2->in_polymorphic_cdtor = in_polymorphic_cdtor;
1083   count -= e2->count;
1084   frequency -= e2->frequency;
1085   symtab->call_edge_duplication_hooks (this, e2);
1086   ref = n->create_reference (n2, IPA_REF_ADDR, call_stmt);
1087   ref->lto_stmt_uid = lto_stmt_uid;
1088   ref->speculative = speculative;
1089   n2->mark_address_taken ();
1090   return e2;
1091 }
1092
1093 /* Speculative call consist of three components:
1094    1) an indirect edge representing the original call
1095    2) an direct edge representing the new call
1096    3) ADDR_EXPR reference representing the speculative check.
1097    All three components are attached to single statement (the indirect
1098    call) and if one of them exists, all of them must exist.
1099
1100    Given speculative call edge, return all three components.
1101  */
1102
1103 void
1104 cgraph_edge::speculative_call_info (cgraph_edge *&direct,
1105                                     cgraph_edge *&indirect,
1106                                     ipa_ref *&reference)
1107 {
1108   ipa_ref *ref;
1109   int i;
1110   cgraph_edge *e2;
1111   cgraph_edge *e = this;
1112
1113   if (!e->indirect_unknown_callee)
1114     for (e2 = e->caller->indirect_calls;
1115          e2->call_stmt != e->call_stmt || e2->lto_stmt_uid != e->lto_stmt_uid;
1116          e2 = e2->next_callee)
1117       ;
1118   else
1119     {
1120       e2 = e;
1121       /* We can take advantage of the call stmt hash.  */
1122       if (e2->call_stmt)
1123         {
1124           e = e->caller->get_edge (e2->call_stmt);
1125           gcc_assert (e->speculative && !e->indirect_unknown_callee);
1126         }
1127       else
1128         for (e = e->caller->callees; 
1129              e2->call_stmt != e->call_stmt
1130              || e2->lto_stmt_uid != e->lto_stmt_uid;
1131              e = e->next_callee)
1132           ;
1133     }
1134   gcc_assert (e->speculative && e2->speculative);
1135   direct = e;
1136   indirect = e2;
1137
1138   reference = NULL;
1139   for (i = 0; e->caller->iterate_reference (i, ref); i++)
1140     if (ref->speculative
1141         && ((ref->stmt && ref->stmt == e->call_stmt)
1142             || (!ref->stmt && ref->lto_stmt_uid == e->lto_stmt_uid)))
1143       {
1144         reference = ref;
1145         break;
1146       }
1147
1148   /* Speculative edge always consist of all three components - direct edge,
1149      indirect and reference.  */
1150   
1151   gcc_assert (e && e2 && ref);
1152 }
1153
1154 /* Speculative call edge turned out to be direct call to CALLE_DECL.
1155    Remove the speculative call sequence and return edge representing the call.
1156    It is up to caller to redirect the call as appropriate. */
1157
1158 cgraph_edge *
1159 cgraph_edge::resolve_speculation (tree callee_decl)
1160 {
1161   cgraph_edge *edge = this;
1162   cgraph_edge *e2;
1163   ipa_ref *ref;
1164
1165   gcc_assert (edge->speculative);
1166   edge->speculative_call_info (e2, edge, ref);
1167   if (!callee_decl
1168       || !ref->referred->semantically_equivalent_p
1169            (symtab_node::get (callee_decl)))
1170     {
1171       if (dump_file)
1172         {
1173           if (callee_decl)
1174             {
1175               fprintf (dump_file, "Speculative indirect call %s/%i => %s/%i has "
1176                        "turned out to have contradicting known target ",
1177                        xstrdup_for_dump (edge->caller->name ()),
1178                        edge->caller->order,
1179                        xstrdup_for_dump (e2->callee->name ()),
1180                        e2->callee->order);
1181               print_generic_expr (dump_file, callee_decl, 0);
1182               fprintf (dump_file, "\n");
1183             }
1184           else
1185             {
1186               fprintf (dump_file, "Removing speculative call %s/%i => %s/%i\n",
1187                        xstrdup_for_dump (edge->caller->name ()),
1188                        edge->caller->order,
1189                        xstrdup_for_dump (e2->callee->name ()),
1190                        e2->callee->order);
1191             }
1192         }
1193     }
1194   else
1195     {
1196       cgraph_edge *tmp = edge;
1197       if (dump_file)
1198         fprintf (dump_file, "Speculative call turned into direct call.\n");
1199       edge = e2;
1200       e2 = tmp;
1201       /* FIXME:  If EDGE is inlined, we should scale up the frequencies and counts
1202          in the functions inlined through it.  */
1203     }
1204   edge->count += e2->count;
1205   edge->frequency += e2->frequency;
1206   if (edge->frequency > CGRAPH_FREQ_MAX)
1207     edge->frequency = CGRAPH_FREQ_MAX;
1208   edge->speculative = false;
1209   e2->speculative = false;
1210   ref->remove_reference ();
1211   if (e2->indirect_unknown_callee || e2->inline_failed)
1212     e2->remove ();
1213   else
1214     e2->callee->remove_symbol_and_inline_clones ();
1215   if (edge->caller->call_site_hash)
1216     cgraph_update_edge_in_call_site_hash (edge);
1217   return edge;
1218 }
1219
1220 /* Make an indirect edge with an unknown callee an ordinary edge leading to
1221    CALLEE.  DELTA is an integer constant that is to be added to the this
1222    pointer (first parameter) to compensate for skipping a thunk adjustment.  */
1223
1224 cgraph_edge *
1225 cgraph_edge::make_direct (cgraph_node *callee)
1226 {
1227   cgraph_edge *edge = this;
1228   gcc_assert (indirect_unknown_callee);
1229
1230   /* If we are redirecting speculative call, make it non-speculative.  */
1231   if (indirect_unknown_callee && speculative)
1232     {
1233       edge = edge->resolve_speculation (callee->decl);
1234
1235       /* On successful speculation just return the pre existing direct edge.  */
1236       if (!indirect_unknown_callee)
1237         return edge;
1238     }
1239
1240   indirect_unknown_callee = 0;
1241   ggc_free (indirect_info);
1242   indirect_info = NULL;
1243
1244   /* Get the edge out of the indirect edge list. */
1245   if (prev_callee)
1246     prev_callee->next_callee = next_callee;
1247   if (next_callee)
1248     next_callee->prev_callee = prev_callee;
1249   if (!prev_callee)
1250     caller->indirect_calls = next_callee;
1251
1252   /* Put it into the normal callee list */
1253   prev_callee = NULL;
1254   next_callee = caller->callees;
1255   if (caller->callees)
1256     caller->callees->prev_callee = edge;
1257   caller->callees = edge;
1258
1259   /* Insert to callers list of the new callee.  */
1260   edge->set_callee (callee);
1261
1262   if (call_stmt)
1263     call_stmt_cannot_inline_p
1264       = !gimple_check_call_matching_types (call_stmt, callee->decl,
1265                                            false);
1266
1267   /* We need to re-determine the inlining status of the edge.  */
1268   initialize_inline_failed (edge);
1269   return edge;
1270 }
1271
1272 /* If necessary, change the function declaration in the call statement
1273    associated with E so that it corresponds to the edge callee.  */
1274
1275 gimple
1276 cgraph_edge::redirect_call_stmt_to_callee (void)
1277 {
1278   cgraph_edge *e = this;
1279
1280   tree decl = gimple_call_fndecl (e->call_stmt);
1281   tree lhs = gimple_call_lhs (e->call_stmt);
1282   gcall *new_stmt;
1283   gimple_stmt_iterator gsi;
1284 #ifdef ENABLE_CHECKING
1285   cgraph_node *node;
1286 #endif
1287
1288   if (e->speculative)
1289     {
1290       cgraph_edge *e2;
1291       gcall *new_stmt;
1292       ipa_ref *ref;
1293
1294       e->speculative_call_info (e, e2, ref);
1295       /* If there already is an direct call (i.e. as a result of inliner's
1296          substitution), forget about speculating.  */
1297       if (decl)
1298         e = e->resolve_speculation (decl);
1299       /* If types do not match, speculation was likely wrong. 
1300          The direct edge was posisbly redirected to the clone with a different
1301          signature.  We did not update the call statement yet, so compare it 
1302          with the reference that still points to the proper type.  */
1303       else if (!gimple_check_call_matching_types (e->call_stmt,
1304                                                   ref->referred->decl,
1305                                                   true))
1306         {
1307           if (dump_file)
1308             fprintf (dump_file, "Not expanding speculative call of %s/%i -> %s/%i\n"
1309                      "Type mismatch.\n",
1310                      xstrdup_for_dump (e->caller->name ()),
1311                      e->caller->order,
1312                      xstrdup_for_dump (e->callee->name ()),
1313                      e->callee->order);
1314           e = e->resolve_speculation ();
1315           /* We are producing the final function body and will throw away the
1316              callgraph edges really soon.  Reset the counts/frequencies to
1317              keep verifier happy in the case of roundoff errors.  */
1318           e->count = gimple_bb (e->call_stmt)->count;
1319           e->frequency = compute_call_stmt_bb_frequency
1320                           (e->caller->decl, gimple_bb (e->call_stmt));
1321         }
1322       /* Expand speculation into GIMPLE code.  */
1323       else
1324         {
1325           if (dump_file)
1326             fprintf (dump_file,
1327                      "Expanding speculative call of %s/%i -> %s/%i count:"
1328                      "%"PRId64"\n",
1329                      xstrdup_for_dump (e->caller->name ()),
1330                      e->caller->order,
1331                      xstrdup_for_dump (e->callee->name ()),
1332                      e->callee->order,
1333                      (int64_t)e->count);
1334           gcc_assert (e2->speculative);
1335           push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl));
1336           new_stmt = gimple_ic (e->call_stmt,
1337                                 dyn_cast<cgraph_node *> (ref->referred),
1338                                 e->count || e2->count
1339                                 ?  RDIV (e->count * REG_BR_PROB_BASE,
1340                                          e->count + e2->count)
1341                                 : e->frequency || e2->frequency
1342                                 ? RDIV (e->frequency * REG_BR_PROB_BASE,
1343                                         e->frequency + e2->frequency)
1344                                 : REG_BR_PROB_BASE / 2,
1345                                 e->count, e->count + e2->count);
1346           e->speculative = false;
1347           e->caller->set_call_stmt_including_clones (e->call_stmt, new_stmt,
1348                                                      false);
1349
1350           /* Fix edges for BUILT_IN_CHKP_BNDRET calls attached to the
1351              processed call stmt.  */
1352           if (gimple_call_with_bounds_p (new_stmt)
1353               && gimple_call_lhs (new_stmt)
1354               && chkp_retbnd_call_by_val (gimple_call_lhs (e2->call_stmt)))
1355             {
1356               tree dresult = gimple_call_lhs (new_stmt);
1357               tree iresult = gimple_call_lhs (e2->call_stmt);
1358               gcall *dbndret = chkp_retbnd_call_by_val (dresult);
1359               gcall *ibndret = chkp_retbnd_call_by_val (iresult);
1360               struct cgraph_edge *iedge
1361                 = e2->caller->cgraph_node::get_edge (ibndret);
1362               struct cgraph_edge *dedge;
1363
1364               if (dbndret)
1365                 {
1366                   dedge = iedge->caller->create_edge (iedge->callee,
1367                                                       dbndret, e->count,
1368                                                       e->frequency);
1369                   dedge->frequency = compute_call_stmt_bb_frequency
1370                     (dedge->caller->decl, gimple_bb (dedge->call_stmt));
1371                 }
1372               iedge->frequency = compute_call_stmt_bb_frequency
1373                 (iedge->caller->decl, gimple_bb (iedge->call_stmt));
1374             }
1375
1376           e->frequency = compute_call_stmt_bb_frequency
1377                            (e->caller->decl, gimple_bb (e->call_stmt));
1378           e2->frequency = compute_call_stmt_bb_frequency
1379                            (e2->caller->decl, gimple_bb (e2->call_stmt));
1380           e2->speculative = false;
1381           ref->speculative = false;
1382           ref->stmt = NULL;
1383           /* Indirect edges are not both in the call site hash.
1384              get it updated.  */
1385           if (e->caller->call_site_hash)
1386             cgraph_update_edge_in_call_site_hash (e2);
1387           pop_cfun ();
1388           /* Continue redirecting E to proper target.  */
1389         }
1390     }
1391
1392   if (e->indirect_unknown_callee
1393       || decl == e->callee->decl)
1394     return e->call_stmt;
1395
1396 #ifdef ENABLE_CHECKING
1397   if (decl)
1398     {
1399       node = cgraph_node::get (decl);
1400       gcc_assert (!node || !node->clone.combined_args_to_skip);
1401     }
1402 #endif
1403
1404   if (symtab->dump_file)
1405     {
1406       fprintf (symtab->dump_file, "updating call of %s/%i -> %s/%i: ",
1407                xstrdup_for_dump (e->caller->name ()), e->caller->order,
1408                xstrdup_for_dump (e->callee->name ()), e->callee->order);
1409       print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
1410       if (e->callee->clone.combined_args_to_skip)
1411         {
1412           fprintf (symtab->dump_file, " combined args to skip: ");
1413           dump_bitmap (symtab->dump_file,
1414                        e->callee->clone.combined_args_to_skip);
1415         }
1416     }
1417
1418   if (e->callee->clone.combined_args_to_skip)
1419     {
1420       int lp_nr;
1421
1422       new_stmt
1423         = gimple_call_copy_skip_args (e->call_stmt,
1424                                       e->callee->clone.combined_args_to_skip);
1425       gimple_call_set_fndecl (new_stmt, e->callee->decl);
1426       gimple_call_set_fntype (new_stmt, gimple_call_fntype (e->call_stmt));
1427
1428       if (gimple_vdef (new_stmt)
1429           && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
1430         SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
1431
1432       gsi = gsi_for_stmt (e->call_stmt);
1433       gsi_replace (&gsi, new_stmt, false);
1434       /* We need to defer cleaning EH info on the new statement to
1435          fixup-cfg.  We may not have dominator information at this point
1436          and thus would end up with unreachable blocks and have no way
1437          to communicate that we need to run CFG cleanup then.  */
1438       lp_nr = lookup_stmt_eh_lp (e->call_stmt);
1439       if (lp_nr != 0)
1440         {
1441           remove_stmt_from_eh_lp (e->call_stmt);
1442           add_stmt_to_eh_lp (new_stmt, lp_nr);
1443         }
1444     }
1445   else
1446     {
1447       new_stmt = e->call_stmt;
1448       gimple_call_set_fndecl (new_stmt, e->callee->decl);
1449       update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
1450     }
1451
1452   /* If the call becomes noreturn, remove the lhs.  */
1453   if (lhs && (gimple_call_flags (new_stmt) & ECF_NORETURN))
1454     {
1455       if (TREE_CODE (lhs) == SSA_NAME)
1456         {
1457           tree var = create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e->caller->decl),
1458                                         TREE_TYPE (lhs), NULL);
1459           var = get_or_create_ssa_default_def
1460                   (DECL_STRUCT_FUNCTION (e->caller->decl), var);
1461           gimple set_stmt = gimple_build_assign (lhs, var);
1462           gsi = gsi_for_stmt (new_stmt);
1463           gsi_insert_before_without_update (&gsi, set_stmt, GSI_SAME_STMT);
1464           update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), set_stmt);
1465         }
1466       gimple_call_set_lhs (new_stmt, NULL_TREE);
1467       update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
1468     }
1469
1470   /* If new callee has no static chain, remove it.  */
1471   if (gimple_call_chain (new_stmt) && !DECL_STATIC_CHAIN (e->callee->decl))
1472     {
1473       gimple_call_set_chain (new_stmt, NULL);
1474       update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
1475     }
1476
1477   maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e->caller->decl),
1478                                  new_stmt);
1479
1480   e->caller->set_call_stmt_including_clones (e->call_stmt, new_stmt, false);
1481
1482   if (symtab->dump_file)
1483     {
1484       fprintf (symtab->dump_file, "  updated to:");
1485       print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
1486     }
1487   return new_stmt;
1488 }
1489
1490 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1491    OLD_STMT changed into NEW_STMT.  OLD_CALL is gimple_call_fndecl
1492    of OLD_STMT if it was previously call statement.
1493    If NEW_STMT is NULL, the call has been dropped without any
1494    replacement.  */
1495
1496 static void
1497 cgraph_update_edges_for_call_stmt_node (cgraph_node *node,
1498                                         gimple old_stmt, tree old_call,
1499                                         gimple new_stmt)
1500 {
1501   tree new_call = (new_stmt && is_gimple_call (new_stmt))
1502                   ? gimple_call_fndecl (new_stmt) : 0;
1503
1504   /* We are seeing indirect calls, then there is nothing to update.  */
1505   if (!new_call && !old_call)
1506     return;
1507   /* See if we turned indirect call into direct call or folded call to one builtin
1508      into different builtin.  */
1509   if (old_call != new_call)
1510     {
1511       cgraph_edge *e = node->get_edge (old_stmt);
1512       cgraph_edge *ne = NULL;
1513       gcov_type count;
1514       int frequency;
1515
1516       if (e)
1517         {
1518           /* See if the edge is already there and has the correct callee.  It
1519              might be so because of indirect inlining has already updated
1520              it.  We also might've cloned and redirected the edge.  */
1521           if (new_call && e->callee)
1522             {
1523               cgraph_node *callee = e->callee;
1524               while (callee)
1525                 {
1526                   if (callee->decl == new_call
1527                       || callee->former_clone_of == new_call)
1528                     {
1529                       e->set_call_stmt (as_a <gcall *> (new_stmt));
1530                       return;
1531                     }
1532                   callee = callee->clone_of;
1533                 }
1534             }
1535
1536           /* Otherwise remove edge and create new one; we can't simply redirect
1537              since function has changed, so inline plan and other information
1538              attached to edge is invalid.  */
1539           count = e->count;
1540           frequency = e->frequency;
1541           if (e->indirect_unknown_callee || e->inline_failed)
1542             e->remove ();
1543           else
1544             e->callee->remove_symbol_and_inline_clones ();
1545         }
1546       else if (new_call)
1547         {
1548           /* We are seeing new direct call; compute profile info based on BB.  */
1549           basic_block bb = gimple_bb (new_stmt);
1550           count = bb->count;
1551           frequency = compute_call_stmt_bb_frequency (current_function_decl,
1552                                                       bb);
1553         }
1554
1555       if (new_call)
1556         {
1557           ne = node->create_edge (cgraph_node::get_create (new_call),
1558                                   as_a <gcall *> (new_stmt), count,
1559                                   frequency);
1560           gcc_assert (ne->inline_failed);
1561         }
1562     }
1563   /* We only updated the call stmt; update pointer in cgraph edge..  */
1564   else if (old_stmt != new_stmt)
1565     node->get_edge (old_stmt)->set_call_stmt (as_a <gcall *> (new_stmt));
1566 }
1567
1568 /* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
1569    OLD_STMT changed into NEW_STMT.  OLD_DECL is gimple_call_fndecl
1570    of OLD_STMT before it was updated (updating can happen inplace).  */
1571
1572 void
1573 cgraph_update_edges_for_call_stmt (gimple old_stmt, tree old_decl, gimple new_stmt)
1574 {
1575   cgraph_node *orig = cgraph_node::get (cfun->decl);
1576   cgraph_node *node;
1577
1578   gcc_checking_assert (orig);
1579   cgraph_update_edges_for_call_stmt_node (orig, old_stmt, old_decl, new_stmt);
1580   if (orig->clones)
1581     for (node = orig->clones; node != orig;)
1582       {
1583         cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_decl, new_stmt);
1584         if (node->clones)
1585           node = node->clones;
1586         else if (node->next_sibling_clone)
1587           node = node->next_sibling_clone;
1588         else
1589           {
1590             while (node != orig && !node->next_sibling_clone)
1591               node = node->clone_of;
1592             if (node != orig)
1593               node = node->next_sibling_clone;
1594           }
1595       }
1596 }
1597
1598
1599 /* Remove all callees from the node.  */
1600
1601 void
1602 cgraph_node::remove_callees (void)
1603 {
1604   cgraph_edge *e, *f;
1605
1606   /* It is sufficient to remove the edges from the lists of callers of
1607      the callees.  The callee list of the node can be zapped with one
1608      assignment.  */
1609   for (e = callees; e; e = f)
1610     {
1611       f = e->next_callee;
1612       symtab->call_edge_removal_hooks (e);
1613       if (!e->indirect_unknown_callee)
1614         e->remove_callee ();
1615       symtab->free_edge (e);
1616     }
1617   for (e = indirect_calls; e; e = f)
1618     {
1619       f = e->next_callee;
1620       symtab->call_edge_removal_hooks (e);
1621       if (!e->indirect_unknown_callee)
1622         e->remove_callee ();
1623       symtab->free_edge (e);
1624     }
1625   indirect_calls = NULL;
1626   callees = NULL;
1627   if (call_site_hash)
1628     {
1629       call_site_hash->empty ();
1630       call_site_hash = NULL;
1631     }
1632 }
1633
1634 /* Remove all callers from the node.  */
1635
1636 void
1637 cgraph_node::remove_callers (void)
1638 {
1639   cgraph_edge *e, *f;
1640
1641   /* It is sufficient to remove the edges from the lists of callees of
1642      the callers.  The caller list of the node can be zapped with one
1643      assignment.  */
1644   for (e = callers; e; e = f)
1645     {
1646       f = e->next_caller;
1647       symtab->call_edge_removal_hooks (e);
1648       e->remove_caller ();
1649       symtab->free_edge (e);
1650     }
1651   callers = NULL;
1652 }
1653
1654 /* Helper function for cgraph_release_function_body and free_lang_data.
1655    It releases body from function DECL without having to inspect its
1656    possibly non-existent symtab node.  */
1657
1658 void
1659 release_function_body (tree decl)
1660 {
1661   if (DECL_STRUCT_FUNCTION (decl))
1662     {
1663       if (DECL_STRUCT_FUNCTION (decl)->cfg
1664           || DECL_STRUCT_FUNCTION (decl)->gimple_df)
1665         {
1666           push_cfun (DECL_STRUCT_FUNCTION (decl));
1667           if (cfun->cfg
1668               && current_loops)
1669             {
1670               cfun->curr_properties &= ~PROP_loops;
1671               loop_optimizer_finalize ();
1672             }
1673           if (cfun->gimple_df)
1674             {
1675               delete_tree_ssa ();
1676               delete_tree_cfg_annotations ();
1677               cfun->eh = NULL;
1678             }
1679           if (cfun->cfg)
1680             {
1681               gcc_assert (!dom_info_available_p (CDI_DOMINATORS));
1682               gcc_assert (!dom_info_available_p (CDI_POST_DOMINATORS));
1683               clear_edges ();
1684               cfun->cfg = NULL;
1685             }
1686           if (cfun->value_histograms)
1687             free_histograms ();
1688           pop_cfun ();
1689         }
1690       gimple_set_body (decl, NULL);
1691       /* Struct function hangs a lot of data that would leak if we didn't
1692          removed all pointers to it.   */
1693       ggc_free (DECL_STRUCT_FUNCTION (decl));
1694       DECL_STRUCT_FUNCTION (decl) = NULL;
1695     }
1696   DECL_SAVED_TREE (decl) = NULL;
1697 }
1698
1699 /* Release memory used to represent body of function.
1700    Use this only for functions that are released before being translated to
1701    target code (i.e. RTL).  Functions that are compiled to RTL and beyond
1702    are free'd in final.c via free_after_compilation().
1703    KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk.  */
1704
1705 void
1706 cgraph_node::release_body (bool keep_arguments)
1707 {
1708   ipa_transforms_to_apply.release ();
1709   if (!used_as_abstract_origin && symtab->state != PARSING)
1710     {
1711       DECL_RESULT (decl) = NULL;
1712
1713       if (!keep_arguments)
1714         DECL_ARGUMENTS (decl) = NULL;
1715     }
1716   /* If the node is abstract and needed, then do not clear DECL_INITIAL
1717      of its associated function function declaration because it's
1718      needed to emit debug info later.  */
1719   if (!used_as_abstract_origin && DECL_INITIAL (decl))
1720     DECL_INITIAL (decl) = error_mark_node;
1721   release_function_body (decl);
1722   if (lto_file_data)
1723     {
1724       lto_free_function_in_decl_state_for_node (this);
1725       lto_file_data = NULL;
1726     }
1727 }
1728
1729 /* Remove function from symbol table.  */
1730
1731 void
1732 cgraph_node::remove (void)
1733 {
1734   cgraph_node *n;
1735   int uid = this->uid;
1736
1737   symtab->call_cgraph_removal_hooks (this);
1738   remove_callers ();
1739   remove_callees ();
1740   ipa_transforms_to_apply.release ();
1741
1742   /* Incremental inlining access removed nodes stored in the postorder list.
1743      */
1744   force_output = false;
1745   forced_by_abi = false;
1746   for (n = nested; n; n = n->next_nested)
1747     n->origin = NULL;
1748   nested = NULL;
1749   if (origin)
1750     {
1751       cgraph_node **node2 = &origin->nested;
1752
1753       while (*node2 != this)
1754         node2 = &(*node2)->next_nested;
1755       *node2 = next_nested;
1756     }
1757   unregister ();
1758   if (prev_sibling_clone)
1759     prev_sibling_clone->next_sibling_clone = next_sibling_clone;
1760   else if (clone_of)
1761     clone_of->clones = next_sibling_clone;
1762   if (next_sibling_clone)
1763     next_sibling_clone->prev_sibling_clone = prev_sibling_clone;
1764   if (clones)
1765     {
1766       cgraph_node *n, *next;
1767
1768       if (clone_of)
1769         {
1770           for (n = clones; n->next_sibling_clone; n = n->next_sibling_clone)
1771             n->clone_of = clone_of;
1772           n->clone_of = clone_of;
1773           n->next_sibling_clone = clone_of->clones;
1774           if (clone_of->clones)
1775             clone_of->clones->prev_sibling_clone = n;
1776           clone_of->clones = clones;
1777         }
1778       else
1779         {
1780           /* We are removing node with clones.  This makes clones inconsistent,
1781              but assume they will be removed subsequently and just keep clone
1782              tree intact.  This can happen in unreachable function removal since
1783              we remove unreachable functions in random order, not by bottom-up
1784              walk of clone trees.  */
1785           for (n = clones; n; n = next)
1786             {
1787                next = n->next_sibling_clone;
1788                n->next_sibling_clone = NULL;
1789                n->prev_sibling_clone = NULL;
1790                n->clone_of = NULL;
1791             }
1792         }
1793     }
1794
1795   /* While all the clones are removed after being proceeded, the function
1796      itself is kept in the cgraph even after it is compiled.  Check whether
1797      we are done with this body and reclaim it proactively if this is the case.
1798      */
1799   if (symtab->state != LTO_STREAMING)
1800     {
1801       n = cgraph_node::get (decl);
1802       if (!n
1803           || (!n->clones && !n->clone_of && !n->global.inlined_to
1804               && ((symtab->global_info_ready || in_lto_p)
1805                   && (TREE_ASM_WRITTEN (n->decl)
1806                       || DECL_EXTERNAL (n->decl)
1807                       || !n->analyzed
1808                       || (!flag_wpa && n->in_other_partition)))))
1809         release_body ();
1810     }
1811   else
1812     {
1813       lto_free_function_in_decl_state_for_node (this);
1814       lto_file_data = NULL;
1815     }
1816
1817   decl = NULL;
1818   if (call_site_hash)
1819     {
1820       call_site_hash->empty ();
1821       call_site_hash = NULL;
1822     }
1823
1824   if (instrumented_version)
1825     {
1826       instrumented_version->instrumented_version = NULL;
1827       instrumented_version = NULL;
1828     }
1829
1830   symtab->release_symbol (this, uid);
1831 }
1832
1833 /* Likewise indicate that a node is having address taken.  */
1834
1835 void
1836 cgraph_node::mark_address_taken (void)
1837 {
1838   /* Indirect inlining can figure out that all uses of the address are
1839      inlined.  */
1840   if (global.inlined_to)
1841     {
1842       gcc_assert (cfun->after_inlining);
1843       gcc_assert (callers->indirect_inlining_edge);
1844       return;
1845     }
1846   /* FIXME: address_taken flag is used both as a shortcut for testing whether
1847      IPA_REF_ADDR reference exists (and thus it should be set on node
1848      representing alias we take address of) and as a test whether address
1849      of the object was taken (and thus it should be set on node alias is
1850      referring to).  We should remove the first use and the remove the
1851      following set.  */
1852   address_taken = 1;
1853   cgraph_node *node = ultimate_alias_target ();
1854   node->address_taken = 1;
1855 }
1856
1857 /* Return local info for the compiled function.  */
1858
1859 cgraph_local_info *
1860 cgraph_node::local_info (tree decl)
1861 {
1862   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1863   cgraph_node *node = get (decl);
1864   if (!node)
1865     return NULL;
1866   return &node->ultimate_alias_target ()->local;
1867 }
1868
1869 /* Return local info for the compiled function.  */
1870
1871 cgraph_rtl_info *
1872 cgraph_node::rtl_info (tree decl)
1873 {
1874   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1875   cgraph_node *node = get (decl);
1876   if (!node)
1877     return NULL;
1878   node = node->ultimate_alias_target ();
1879   if (node->decl != current_function_decl
1880       && !TREE_ASM_WRITTEN (node->decl))
1881     return NULL;
1882   return &node->ultimate_alias_target ()->rtl;
1883 }
1884
1885 /* Return a string describing the failure REASON.  */
1886
1887 const char*
1888 cgraph_inline_failed_string (cgraph_inline_failed_t reason)
1889 {
1890 #undef DEFCIFCODE
1891 #define DEFCIFCODE(code, type, string)  string,
1892
1893   static const char *cif_string_table[CIF_N_REASONS] = {
1894 #include "cif-code.def"
1895   };
1896
1897   /* Signedness of an enum type is implementation defined, so cast it
1898      to unsigned before testing. */
1899   gcc_assert ((unsigned) reason < CIF_N_REASONS);
1900   return cif_string_table[reason];
1901 }
1902
1903 /* Return a type describing the failure REASON.  */
1904
1905 cgraph_inline_failed_type_t
1906 cgraph_inline_failed_type (cgraph_inline_failed_t reason)
1907 {
1908 #undef DEFCIFCODE
1909 #define DEFCIFCODE(code, type, string)  type,
1910
1911   static cgraph_inline_failed_type_t cif_type_table[CIF_N_REASONS] = {
1912 #include "cif-code.def"
1913   };
1914
1915   /* Signedness of an enum type is implementation defined, so cast it
1916      to unsigned before testing. */
1917   gcc_assert ((unsigned) reason < CIF_N_REASONS);
1918   return cif_type_table[reason];
1919 }
1920
1921 /* Names used to print out the availability enum.  */
1922 const char * const cgraph_availability_names[] =
1923   {"unset", "not_available", "overwritable", "available", "local"};
1924
1925 /* Output flags of edge to a file F.  */
1926
1927 void
1928 cgraph_edge::dump_edge_flags (FILE *f)
1929 {
1930   if (speculative)
1931     fprintf (f, "(speculative) ");
1932   if (!inline_failed)
1933     fprintf (f, "(inlined) ");
1934   if (indirect_inlining_edge)
1935     fprintf (f, "(indirect_inlining) ");
1936   if (count)
1937     fprintf (f, "(%"PRId64"x) ", (int64_t)count);
1938   if (frequency)
1939     fprintf (f, "(%.2f per call) ", frequency / (double)CGRAPH_FREQ_BASE);
1940   if (can_throw_external)
1941     fprintf (f, "(can throw external) ");
1942 }
1943
1944 /* Dump call graph node to file F.  */
1945
1946 void
1947 cgraph_node::dump (FILE *f)
1948 {
1949   cgraph_edge *edge;
1950
1951   dump_base (f);
1952
1953   if (global.inlined_to)
1954     fprintf (f, "  Function %s/%i is inline copy in %s/%i\n",
1955              xstrdup_for_dump (name ()),
1956              order,
1957              xstrdup_for_dump (global.inlined_to->name ()),
1958              global.inlined_to->order);
1959   if (clone_of)
1960     fprintf (f, "  Clone of %s/%i\n",
1961              clone_of->asm_name (),
1962              clone_of->order);
1963   if (symtab->function_flags_ready)
1964     fprintf (f, "  Availability: %s\n",
1965              cgraph_availability_names [get_availability ()]);
1966
1967   if (profile_id)
1968     fprintf (f, "  Profile id: %i\n",
1969              profile_id);
1970   fprintf (f, "  First run: %i\n", tp_first_run);
1971   fprintf (f, "  Function flags:");
1972   if (count)
1973     fprintf (f, " executed %"PRId64"x",
1974              (int64_t)count);
1975   if (origin)
1976     fprintf (f, " nested in: %s", origin->asm_name ());
1977   if (gimple_has_body_p (decl))
1978     fprintf (f, " body");
1979   if (process)
1980     fprintf (f, " process");
1981   if (local.local)
1982     fprintf (f, " local");
1983   if (local.redefined_extern_inline)
1984     fprintf (f, " redefined_extern_inline");
1985   if (only_called_at_startup)
1986     fprintf (f, " only_called_at_startup");
1987   if (only_called_at_exit)
1988     fprintf (f, " only_called_at_exit");
1989   if (tm_clone)
1990     fprintf (f, " tm_clone");
1991   if (icf_merged)
1992     fprintf (f, " icf_merged");
1993   if (nonfreeing_fn)
1994     fprintf (f, " nonfreeing_fn");
1995   if (DECL_STATIC_CONSTRUCTOR (decl))
1996     fprintf (f," static_constructor (priority:%i)", get_init_priority ());
1997   if (DECL_STATIC_DESTRUCTOR (decl))
1998     fprintf (f," static_destructor (priority:%i)", get_fini_priority ());
1999   if (frequency == NODE_FREQUENCY_HOT)
2000     fprintf (f, " hot");
2001   if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
2002     fprintf (f, " unlikely_executed");
2003   if (frequency == NODE_FREQUENCY_EXECUTED_ONCE)
2004     fprintf (f, " executed_once");
2005   if (only_called_at_startup)
2006     fprintf (f, " only_called_at_startup");
2007   if (only_called_at_exit)
2008     fprintf (f, " only_called_at_exit");
2009   if (opt_for_fn (decl, optimize_size))
2010     fprintf (f, " optimize_size");
2011   if (parallelized_function)
2012     fprintf (f, " parallelized_function");
2013
2014   fprintf (f, "\n");
2015
2016   if (thunk.thunk_p)
2017     {
2018       fprintf (f, "  Thunk");
2019       if (thunk.alias)
2020         fprintf (f, "  of %s (asm: %s)",
2021                  lang_hooks.decl_printable_name (thunk.alias, 2),
2022                  IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk.alias)));
2023       fprintf (f, " fixed offset %i virtual value %i has "
2024                "virtual offset %i)\n",
2025                (int)thunk.fixed_offset,
2026                (int)thunk.virtual_value,
2027                (int)thunk.virtual_offset_p);
2028     }
2029   if (alias && thunk.alias
2030       && DECL_P (thunk.alias))
2031     {
2032       fprintf (f, "  Alias of %s",
2033                lang_hooks.decl_printable_name (thunk.alias, 2));
2034       if (DECL_ASSEMBLER_NAME_SET_P (thunk.alias))
2035         fprintf (f, " (asm: %s)",
2036                  IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk.alias)));
2037       fprintf (f, "\n");
2038     }
2039   
2040   fprintf (f, "  Called by: ");
2041
2042   for (edge = callers; edge; edge = edge->next_caller)
2043     {
2044       fprintf (f, "%s/%i ", edge->caller->asm_name (),
2045                edge->caller->order);
2046       edge->dump_edge_flags (f);
2047     }
2048
2049   fprintf (f, "\n  Calls: ");
2050   for (edge = callees; edge; edge = edge->next_callee)
2051     {
2052       fprintf (f, "%s/%i ", edge->callee->asm_name (),
2053                edge->callee->order);
2054       edge->dump_edge_flags (f);
2055     }
2056   fprintf (f, "\n");
2057
2058   for (edge = indirect_calls; edge; edge = edge->next_callee)
2059     {
2060       if (edge->indirect_info->polymorphic)
2061         {
2062           fprintf (f, "   Polymorphic indirect call of type ");
2063           print_generic_expr (f, edge->indirect_info->otr_type, TDF_SLIM);
2064           fprintf (f, " token:%i", (int) edge->indirect_info->otr_token);
2065         }
2066       else
2067         fprintf (f, "   Indirect call");
2068       edge->dump_edge_flags (f);
2069       if (edge->indirect_info->param_index != -1)
2070         {
2071           fprintf (f, " of param:%i", edge->indirect_info->param_index);
2072           if (edge->indirect_info->agg_contents)
2073            fprintf (f, " loaded from %s %s at offset %i",
2074                     edge->indirect_info->member_ptr ? "member ptr" : "aggregate",
2075                     edge->indirect_info->by_ref ? "passed by reference":"",
2076                     (int)edge->indirect_info->offset);
2077           if (edge->indirect_info->vptr_changed)
2078             fprintf (f, " (vptr maybe changed)");
2079         }
2080       fprintf (f, "\n");
2081       if (edge->indirect_info->polymorphic)
2082         edge->indirect_info->context.dump (f);
2083     }
2084
2085   if (instrumentation_clone)
2086     fprintf (f, "  Is instrumented version.\n");
2087   else if (instrumented_version)
2088     fprintf (f, "  Has instrumented version.\n");
2089 }
2090
2091 /* Dump call graph node NODE to stderr.  */
2092
2093 DEBUG_FUNCTION void
2094 cgraph_node::debug (void)
2095 {
2096   dump (stderr);
2097 }
2098
2099 /* Dump the callgraph to file F.  */
2100
2101 void
2102 cgraph_node::dump_cgraph (FILE *f)
2103 {
2104   cgraph_node *node;
2105
2106   fprintf (f, "callgraph:\n\n");
2107   FOR_EACH_FUNCTION (node)
2108     node->dump (f);
2109 }
2110
2111 /* Return true when the DECL can possibly be inlined.  */
2112
2113 bool
2114 cgraph_function_possibly_inlined_p (tree decl)
2115 {
2116   if (!symtab->global_info_ready)
2117     return !DECL_UNINLINABLE (decl);
2118   return DECL_POSSIBLY_INLINED (decl);
2119 }
2120
2121 /* cgraph_node is no longer nested function; update cgraph accordingly.  */
2122 void
2123 cgraph_node::unnest (void)
2124 {
2125   cgraph_node **node2 = &origin->nested;
2126   gcc_assert (origin);
2127
2128   while (*node2 != this)
2129     node2 = &(*node2)->next_nested;
2130   *node2 = next_nested;
2131   origin = NULL;
2132 }
2133
2134 /* Return function availability.  See cgraph.h for description of individual
2135    return values.  */
2136 enum availability
2137 cgraph_node::get_availability (void)
2138 {
2139   enum availability avail;
2140   if (!analyzed)
2141     avail = AVAIL_NOT_AVAILABLE;
2142   else if (local.local)
2143     avail = AVAIL_LOCAL;
2144   else if (alias && weakref)
2145     ultimate_alias_target (&avail);
2146   else if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl)))
2147     avail = AVAIL_INTERPOSABLE;
2148   else if (!externally_visible)
2149     avail = AVAIL_AVAILABLE;
2150   /* Inline functions are safe to be analyzed even if their symbol can
2151      be overwritten at runtime.  It is not meaningful to enforce any sane
2152      behaviour on replacing inline function by different body.  */
2153   else if (DECL_DECLARED_INLINE_P (decl))
2154     avail = AVAIL_AVAILABLE;
2155
2156   /* If the function can be overwritten, return OVERWRITABLE.  Take
2157      care at least of two notable extensions - the COMDAT functions
2158      used to share template instantiations in C++ (this is symmetric
2159      to code cp_cannot_inline_tree_fn and probably shall be shared and
2160      the inlinability hooks completely eliminated).
2161
2162      ??? Does the C++ one definition rule allow us to always return
2163      AVAIL_AVAILABLE here?  That would be good reason to preserve this
2164      bit.  */
2165
2166   else if (decl_replaceable_p (decl) && !DECL_EXTERNAL (decl))
2167     avail = AVAIL_INTERPOSABLE;
2168   else avail = AVAIL_AVAILABLE;
2169
2170   return avail;
2171 }
2172
2173 /* Worker for cgraph_node_can_be_local_p.  */
2174 static bool
2175 cgraph_node_cannot_be_local_p_1 (cgraph_node *node, void *)
2176 {
2177   return !(!node->force_output
2178            && ((DECL_COMDAT (node->decl)
2179                 && !node->forced_by_abi
2180                 && !node->used_from_object_file_p ()
2181                 && !node->same_comdat_group)
2182                || !node->externally_visible));
2183 }
2184
2185 /* Return true if cgraph_node can be made local for API change.
2186    Extern inline functions and C++ COMDAT functions can be made local
2187    at the expense of possible code size growth if function is used in multiple
2188    compilation units.  */
2189 bool
2190 cgraph_node::can_be_local_p (void)
2191 {
2192   return (!address_taken
2193           && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1,
2194                                                 NULL, true));
2195 }
2196
2197 /* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
2198    When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
2199    skipped.  When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
2200    skipped.  */
2201 bool
2202 cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback)
2203                                                    (cgraph_node *, void *),
2204                                                  void *data,
2205                                                  bool include_overwritable,
2206                                                  bool exclude_virtual_thunks)
2207 {
2208   cgraph_edge *e;
2209   ipa_ref *ref;
2210
2211   if (callback (this, data))
2212     return true;
2213   FOR_EACH_ALIAS (this, ref)
2214     {
2215       cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
2216       if (include_overwritable
2217           || alias->get_availability () > AVAIL_INTERPOSABLE)
2218         if (alias->call_for_symbol_thunks_and_aliases (callback, data,
2219                                                      include_overwritable,
2220                                                      exclude_virtual_thunks))
2221           return true;
2222     }
2223   for (e = callers; e; e = e->next_caller)
2224     if (e->caller->thunk.thunk_p
2225         && (include_overwritable
2226             || e->caller->get_availability () > AVAIL_INTERPOSABLE)
2227         && !(exclude_virtual_thunks
2228              && e->caller->thunk.virtual_offset_p))
2229       if (e->caller->call_for_symbol_thunks_and_aliases (callback, data,
2230                                                        include_overwritable,
2231                                                        exclude_virtual_thunks))
2232         return true;
2233
2234   return false;
2235 }
2236
2237 /* Worker to bring NODE local.  */
2238
2239 bool
2240 cgraph_node::make_local (cgraph_node *node, void *)
2241 {
2242   gcc_checking_assert (node->can_be_local_p ());
2243   if (DECL_COMDAT (node->decl) || DECL_EXTERNAL (node->decl))
2244     {
2245       node->make_decl_local ();
2246       node->set_section (NULL);
2247       node->set_comdat_group (NULL);
2248       node->externally_visible = false;
2249       node->forced_by_abi = false;
2250       node->local.local = true;
2251       node->set_section (NULL);
2252       node->unique_name = (node->resolution == LDPR_PREVAILING_DEF_IRONLY
2253                                   || node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP);
2254       node->resolution = LDPR_PREVAILING_DEF_IRONLY;
2255       gcc_assert (node->get_availability () == AVAIL_LOCAL);
2256     }
2257   return false;
2258 }
2259
2260 /* Bring cgraph node local.  */
2261
2262 void
2263 cgraph_node::make_local (void)
2264 {
2265   call_for_symbol_thunks_and_aliases (cgraph_node::make_local, NULL, true);
2266 }
2267
2268 /* Worker to set nothrow flag.  */
2269
2270 static bool
2271 cgraph_set_nothrow_flag_1 (cgraph_node *node, void *data)
2272 {
2273   cgraph_edge *e;
2274
2275   TREE_NOTHROW (node->decl) = data != NULL;
2276
2277   if (data != NULL)
2278     for (e = node->callers; e; e = e->next_caller)
2279       e->can_throw_external = false;
2280   return false;
2281 }
2282
2283 /* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
2284    if any to NOTHROW.  */
2285
2286 void
2287 cgraph_node::set_nothrow_flag (bool nothrow)
2288 {
2289   call_for_symbol_thunks_and_aliases (cgraph_set_nothrow_flag_1,
2290                                     (void *)(size_t)nothrow, false);
2291 }
2292
2293 /* Worker to set const flag.  */
2294
2295 static bool
2296 cgraph_set_const_flag_1 (cgraph_node *node, void *data)
2297 {
2298   /* Static constructors and destructors without a side effect can be
2299      optimized out.  */
2300   if (data && !((size_t)data & 2))
2301     {
2302       if (DECL_STATIC_CONSTRUCTOR (node->decl))
2303         DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
2304       if (DECL_STATIC_DESTRUCTOR (node->decl))
2305         DECL_STATIC_DESTRUCTOR (node->decl) = 0;
2306     }
2307   TREE_READONLY (node->decl) = data != NULL;
2308   DECL_LOOPING_CONST_OR_PURE_P (node->decl) = ((size_t)data & 2) != 0;
2309   return false;
2310 }
2311
2312 /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node
2313    if any to READONLY.  */
2314
2315 void
2316 cgraph_node::set_const_flag (bool readonly, bool looping)
2317 {
2318   call_for_symbol_thunks_and_aliases (cgraph_set_const_flag_1,
2319                                     (void *)(size_t)(readonly + (int)looping * 2),
2320                                     false, true);
2321 }
2322
2323 /* Worker to set pure flag.  */
2324
2325 static bool
2326 cgraph_set_pure_flag_1 (cgraph_node *node, void *data)
2327 {
2328   /* Static constructors and destructors without a side effect can be
2329      optimized out.  */
2330   if (data && !((size_t)data & 2))
2331     {
2332       if (DECL_STATIC_CONSTRUCTOR (node->decl))
2333         DECL_STATIC_CONSTRUCTOR (node->decl) = 0;
2334       if (DECL_STATIC_DESTRUCTOR (node->decl))
2335         DECL_STATIC_DESTRUCTOR (node->decl) = 0;
2336     }
2337   DECL_PURE_P (node->decl) = data != NULL;
2338   DECL_LOOPING_CONST_OR_PURE_P (node->decl) = ((size_t)data & 2) != 0;
2339   return false;
2340 }
2341
2342 /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
2343    if any to PURE.  */
2344
2345 void
2346 cgraph_node::set_pure_flag (bool pure, bool looping)
2347 {
2348   call_for_symbol_thunks_and_aliases (cgraph_set_pure_flag_1,
2349                                     (void *)(size_t)(pure + (int)looping * 2),
2350                                     false, true);
2351 }
2352
2353 /* Return true when cgraph_node can not return or throw and thus
2354    it is safe to ignore its side effects for IPA analysis.  */
2355
2356 bool
2357 cgraph_node::cannot_return_p (void)
2358 {
2359   int flags = flags_from_decl_or_type (decl);
2360   if (!opt_for_fn (decl, flag_exceptions))
2361     return (flags & ECF_NORETURN) != 0;
2362   else
2363     return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2364              == (ECF_NORETURN | ECF_NOTHROW));
2365 }
2366
2367 /* Return true when call of edge can not lead to return from caller
2368    and thus it is safe to ignore its side effects for IPA analysis
2369    when computing side effects of the caller.
2370    FIXME: We could actually mark all edges that have no reaching
2371    patch to the exit block or throw to get better results.  */
2372 bool
2373 cgraph_edge::cannot_lead_to_return_p (void)
2374 {
2375   if (caller->cannot_return_p ())
2376     return true;
2377   if (indirect_unknown_callee)
2378     {
2379       int flags = indirect_info->ecf_flags;
2380       if (!opt_for_fn (caller->decl, flag_exceptions))
2381         return (flags & ECF_NORETURN) != 0;
2382       else
2383         return ((flags & (ECF_NORETURN | ECF_NOTHROW))
2384                  == (ECF_NORETURN | ECF_NOTHROW));
2385     }
2386   else
2387     return callee->cannot_return_p ();
2388 }
2389
2390 /* Return true if the call can be hot.  */
2391
2392 bool
2393 cgraph_edge::maybe_hot_p (void)
2394 {
2395   /* TODO: Export profile_status from cfun->cfg to cgraph_node.  */
2396   if (profile_info
2397       && opt_for_fn (caller->decl, flag_branch_probabilities)
2398       && !maybe_hot_count_p (NULL, count))
2399     return false;
2400   if (caller->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
2401       || (callee
2402           && callee->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED))
2403     return false;
2404   if (caller->frequency > NODE_FREQUENCY_UNLIKELY_EXECUTED
2405       && (callee
2406           && callee->frequency <= NODE_FREQUENCY_EXECUTED_ONCE))
2407     return false;
2408   if (opt_for_fn (caller->decl, optimize_size))
2409     return false;
2410   if (caller->frequency == NODE_FREQUENCY_HOT)
2411     return true;
2412   if (caller->frequency == NODE_FREQUENCY_EXECUTED_ONCE
2413       && frequency < CGRAPH_FREQ_BASE * 3 / 2)
2414     return false;
2415   if (opt_for_fn (caller->decl, flag_guess_branch_prob))
2416     {
2417       if (PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION) == 0
2418           || frequency <= (CGRAPH_FREQ_BASE
2419                            / PARAM_VALUE (HOT_BB_FREQUENCY_FRACTION)))
2420         return false;
2421     }
2422   return true;
2423 }
2424
2425 /* Worker for cgraph_can_remove_if_no_direct_calls_p.  */
2426
2427 static bool
2428 nonremovable_p (cgraph_node *node, void *)
2429 {
2430   return !node->can_remove_if_no_direct_calls_and_refs_p ();
2431 }
2432
2433 /* Return true if whole comdat group can be removed if there are no direct
2434    calls to THIS.  */
2435
2436 bool
2437 cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline)
2438 {
2439   struct ipa_ref *ref;
2440
2441   /* For local symbols or non-comdat group it is the same as 
2442      can_remove_if_no_direct_calls_p.  */
2443   if (!externally_visible || !same_comdat_group)
2444     {
2445       if (DECL_EXTERNAL (decl))
2446         return true;
2447       if (address_taken)
2448         return false;
2449       return !call_for_symbol_and_aliases (nonremovable_p, NULL, true);
2450     }
2451
2452   if (will_inline && address_taken)
2453     return false;
2454
2455   /* Otheriwse check if we can remove the symbol itself and then verify
2456      that only uses of the comdat groups are direct call to THIS
2457      or its aliases.   */
2458   if (!can_remove_if_no_direct_calls_and_refs_p ())
2459     return false;
2460
2461   /* Check that all refs come from within the comdat group.  */
2462   for (int i = 0; iterate_referring (i, ref); i++)
2463     if (ref->referring->get_comdat_group () != get_comdat_group ())
2464       return false;
2465
2466   struct cgraph_node *target = ultimate_alias_target ();
2467   for (cgraph_node *next = dyn_cast<cgraph_node *> (same_comdat_group);
2468        next != this; next = dyn_cast<cgraph_node *> (next->same_comdat_group))
2469     {
2470       if (!externally_visible)
2471         continue;
2472       if (!next->alias
2473           && !next->can_remove_if_no_direct_calls_and_refs_p ())
2474         return false;
2475
2476       /* If we see different symbol than THIS, be sure to check calls.  */
2477       if (next->ultimate_alias_target () != target)
2478         for (cgraph_edge *e = next->callers; e; e = e->next_caller)
2479           if (e->caller->get_comdat_group () != get_comdat_group ()
2480               || will_inline)
2481             return false;
2482
2483       /* If function is not being inlined, we care only about
2484          references outside of the comdat group.  */
2485       if (!will_inline)
2486         for (int i = 0; next->iterate_referring (i, ref); i++)
2487           if (ref->referring->get_comdat_group () != get_comdat_group ())
2488             return false;
2489     }
2490   return true;
2491 }
2492
2493 /* Return true when function cgraph_node can be expected to be removed
2494    from program when direct calls in this compilation unit are removed.
2495
2496    As a special case COMDAT functions are
2497    cgraph_can_remove_if_no_direct_calls_p while the are not
2498    cgraph_only_called_directly_p (it is possible they are called from other
2499    unit)
2500
2501    This function behaves as cgraph_only_called_directly_p because eliminating
2502    all uses of COMDAT function does not make it necessarily disappear from
2503    the program unless we are compiling whole program or we do LTO.  In this
2504    case we know we win since dynamic linking will not really discard the
2505    linkonce section.  */
2506
2507 bool
2508 cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
2509          (bool will_inline)
2510 {
2511   gcc_assert (!global.inlined_to);
2512   if (DECL_EXTERNAL (decl))
2513     return true;
2514
2515   if (!in_lto_p && !flag_whole_program)
2516     {
2517       /* If the symbol is in comdat group, we need to verify that whole comdat
2518          group becomes unreachable.  Technically we could skip references from
2519          within the group, too.  */
2520       if (!only_called_directly_p ())
2521         return false;
2522       if (same_comdat_group && externally_visible)
2523         {
2524           struct cgraph_node *target = ultimate_alias_target ();
2525
2526           if (will_inline && address_taken)
2527             return true;
2528           for (cgraph_node *next = dyn_cast<cgraph_node *> (same_comdat_group);
2529                next != this;
2530                next = dyn_cast<cgraph_node *> (next->same_comdat_group))
2531             {
2532               if (!externally_visible)
2533                 continue;
2534               if (!next->alias
2535                   && !next->only_called_directly_p ())
2536                 return false;
2537
2538               /* If we see different symbol than THIS,
2539                  be sure to check calls.  */
2540               if (next->ultimate_alias_target () != target)
2541                 for (cgraph_edge *e = next->callers; e; e = e->next_caller)
2542                   if (e->caller->get_comdat_group () != get_comdat_group ()
2543                       || will_inline)
2544                     return false;
2545             }
2546         }
2547       return true;
2548     }
2549   else
2550     return can_remove_if_no_direct_calls_p (will_inline);
2551 }
2552
2553
2554 /* Worker for cgraph_only_called_directly_p.  */
2555
2556 static bool
2557 cgraph_not_only_called_directly_p_1 (cgraph_node *node, void *)
2558 {
2559   return !node->only_called_directly_or_aliased_p ();
2560 }
2561
2562 /* Return true when function cgraph_node and all its aliases are only called
2563    directly.
2564    i.e. it is not externally visible, address was not taken and
2565    it is not used in any other non-standard way.  */
2566
2567 bool
2568 cgraph_node::only_called_directly_p (void)
2569 {
2570   gcc_assert (ultimate_alias_target () == this);
2571   return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1,
2572                                        NULL, true);
2573 }
2574
2575
2576 /* Collect all callers of NODE.  Worker for collect_callers_of_node.  */
2577
2578 static bool
2579 collect_callers_of_node_1 (cgraph_node *node, void *data)
2580 {
2581   vec<cgraph_edge *> *redirect_callers = (vec<cgraph_edge *> *)data;
2582   cgraph_edge *cs;
2583   enum availability avail;
2584   node->ultimate_alias_target (&avail);
2585
2586   if (avail > AVAIL_INTERPOSABLE)
2587     for (cs = node->callers; cs != NULL; cs = cs->next_caller)
2588       if (!cs->indirect_inlining_edge)
2589         redirect_callers->safe_push (cs);
2590   return false;
2591 }
2592
2593 /* Collect all callers of cgraph_node and its aliases that are known to lead to
2594    cgraph_node (i.e. are not overwritable).  */
2595
2596 vec<cgraph_edge *>
2597 cgraph_node::collect_callers (void)
2598 {
2599   vec<cgraph_edge *> redirect_callers = vNULL;
2600   call_for_symbol_thunks_and_aliases (collect_callers_of_node_1,
2601                                     &redirect_callers, false);
2602   return redirect_callers;
2603 }
2604
2605 /* Return TRUE if NODE2 a clone of NODE or is equivalent to it.  */
2606
2607 static bool
2608 clone_of_p (cgraph_node *node, cgraph_node *node2)
2609 {
2610   bool skipped_thunk = false;
2611   node = node->ultimate_alias_target ();
2612   node2 = node2->ultimate_alias_target ();
2613
2614   /* There are no virtual clones of thunks so check former_clone_of or if we
2615      might have skipped thunks because this adjustments are no longer
2616      necessary.  */
2617   while (node->thunk.thunk_p)
2618     {
2619       if (node2->former_clone_of == node->decl)
2620         return true;
2621       if (!node->thunk.this_adjusting)
2622         return false;
2623       node = node->callees->callee->ultimate_alias_target ();
2624       skipped_thunk = true;
2625     }
2626
2627   if (skipped_thunk)
2628     {
2629       if (!node2->clone.args_to_skip
2630           || !bitmap_bit_p (node2->clone.args_to_skip, 0))
2631         return false;
2632       if (node2->former_clone_of == node->decl)
2633         return true;
2634       else if (!node2->clone_of)
2635         return false;
2636     }
2637
2638   while (node != node2 && node2)
2639     node2 = node2->clone_of;
2640   return node2 != NULL;
2641 }
2642
2643 /* Verify edge count and frequency.  */
2644
2645 bool
2646 cgraph_edge::verify_count_and_frequency ()
2647 {
2648   bool error_found = false;
2649   if (count < 0)
2650     {
2651       error ("caller edge count is negative");
2652       error_found = true;
2653     }
2654   if (frequency < 0)
2655     {
2656       error ("caller edge frequency is negative");
2657       error_found = true;
2658     }
2659   if (frequency > CGRAPH_FREQ_MAX)
2660     {
2661       error ("caller edge frequency is too large");
2662       error_found = true;
2663     }
2664   if (gimple_has_body_p (caller->decl)
2665       && !caller->global.inlined_to
2666       && !speculative
2667       /* FIXME: Inline-analysis sets frequency to 0 when edge is optimized out.
2668          Remove this once edges are actually removed from the function at that time.  */
2669       && (frequency
2670           || (inline_edge_summary_vec.exists ()
2671               && ((inline_edge_summary_vec.length () <= (unsigned) uid)
2672                   || !inline_edge_summary (this)->predicate)))
2673       && (frequency
2674           != compute_call_stmt_bb_frequency (caller->decl,
2675                                              gimple_bb (call_stmt))))
2676     {
2677       error ("caller edge frequency %i does not match BB frequency %i",
2678              frequency,
2679              compute_call_stmt_bb_frequency (caller->decl,
2680                                              gimple_bb (call_stmt)));
2681       error_found = true;
2682     }
2683   return error_found;
2684 }
2685
2686 /* Switch to THIS_CFUN if needed and print STMT to stderr.  */
2687 static void
2688 cgraph_debug_gimple_stmt (function *this_cfun, gimple stmt)
2689 {
2690   bool fndecl_was_null = false;
2691   /* debug_gimple_stmt needs correct cfun */
2692   if (cfun != this_cfun)
2693     set_cfun (this_cfun);
2694   /* ...and an actual current_function_decl */
2695   if (!current_function_decl)
2696     {
2697       current_function_decl = this_cfun->decl;
2698       fndecl_was_null = true;
2699     }
2700   debug_gimple_stmt (stmt);
2701   if (fndecl_was_null)
2702     current_function_decl = NULL;
2703 }
2704
2705 /* Verify that call graph edge corresponds to DECL from the associated
2706    statement.  Return true if the verification should fail.  */
2707
2708 bool
2709 cgraph_edge::verify_corresponds_to_fndecl (tree decl)
2710 {
2711   cgraph_node *node;
2712
2713   if (!decl || callee->global.inlined_to)
2714     return false;
2715   if (symtab->state == LTO_STREAMING)
2716     return false;
2717   node = cgraph_node::get (decl);
2718
2719   /* We do not know if a node from a different partition is an alias or what it
2720      aliases and therefore cannot do the former_clone_of check reliably.  When
2721      body_removed is set, we have lost all information about what was alias or
2722      thunk of and also cannot proceed.  */
2723   if (!node
2724       || node->body_removed
2725       || node->in_other_partition
2726       || callee->icf_merged
2727       || callee->in_other_partition)
2728     return false;
2729
2730   node = node->ultimate_alias_target ();
2731
2732   /* Optimizers can redirect unreachable calls or calls triggering undefined
2733      behaviour to builtin_unreachable.  */
2734   if (DECL_BUILT_IN_CLASS (callee->decl) == BUILT_IN_NORMAL
2735       && DECL_FUNCTION_CODE (callee->decl) == BUILT_IN_UNREACHABLE)
2736     return false;
2737
2738   if (callee->former_clone_of != node->decl
2739       && (node != callee->ultimate_alias_target ())
2740       && !clone_of_p (node, callee))
2741     return true;
2742   else
2743     return false;
2744 }
2745
2746 /* Verify cgraph nodes of given cgraph node.  */
2747 DEBUG_FUNCTION void
2748 cgraph_node::verify_node (void)
2749 {
2750   cgraph_edge *e;
2751   function *this_cfun = DECL_STRUCT_FUNCTION (decl);
2752   basic_block this_block;
2753   gimple_stmt_iterator gsi;
2754   bool error_found = false;
2755
2756   if (seen_error ())
2757     return;
2758
2759   timevar_push (TV_CGRAPH_VERIFY);
2760   error_found |= verify_base ();
2761   for (e = callees; e; e = e->next_callee)
2762     if (e->aux)
2763       {
2764         error ("aux field set for edge %s->%s",
2765                identifier_to_locale (e->caller->name ()),
2766                identifier_to_locale (e->callee->name ()));
2767         error_found = true;
2768       }
2769   if (count < 0)
2770     {
2771       error ("execution count is negative");
2772       error_found = true;
2773     }
2774   if (global.inlined_to && same_comdat_group)
2775     {
2776       error ("inline clone in same comdat group list");
2777       error_found = true;
2778     }
2779   if (!definition && !in_other_partition && local.local)
2780     {
2781       error ("local symbols must be defined");
2782       error_found = true;
2783     }
2784   if (global.inlined_to && externally_visible)
2785     {
2786       error ("externally visible inline clone");
2787       error_found = true;
2788     }
2789   if (global.inlined_to && address_taken)
2790     {
2791       error ("inline clone with address taken");
2792       error_found = true;
2793     }
2794   if (global.inlined_to && force_output)
2795     {
2796       error ("inline clone is forced to output");
2797       error_found = true;
2798     }
2799   for (e = indirect_calls; e; e = e->next_callee)
2800     {
2801       if (e->aux)
2802         {
2803           error ("aux field set for indirect edge from %s",
2804                  identifier_to_locale (e->caller->name ()));
2805           error_found = true;
2806         }
2807       if (!e->indirect_unknown_callee
2808           || !e->indirect_info)
2809         {
2810           error ("An indirect edge from %s is not marked as indirect or has "
2811                  "associated indirect_info, the corresponding statement is: ",
2812                  identifier_to_locale (e->caller->name ()));
2813           cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
2814           error_found = true;
2815         }
2816     }
2817   bool check_comdat = comdat_local_p ();
2818   for (e = callers; e; e = e->next_caller)
2819     {
2820       if (e->verify_count_and_frequency ())
2821         error_found = true;
2822       if (check_comdat
2823           && !in_same_comdat_group_p (e->caller))
2824         {
2825           error ("comdat-local function called by %s outside its comdat",
2826                  identifier_to_locale (e->caller->name ()));
2827           error_found = true;
2828         }
2829       if (!e->inline_failed)
2830         {
2831           if (global.inlined_to
2832               != (e->caller->global.inlined_to
2833                   ? e->caller->global.inlined_to : e->caller))
2834             {
2835               error ("inlined_to pointer is wrong");
2836               error_found = true;
2837             }
2838           if (callers->next_caller)
2839             {
2840               error ("multiple inline callers");
2841               error_found = true;
2842             }
2843         }
2844       else
2845         if (global.inlined_to)
2846           {
2847             error ("inlined_to pointer set for noninline callers");
2848             error_found = true;
2849           }
2850     }
2851   for (e = indirect_calls; e; e = e->next_callee)
2852     if (e->verify_count_and_frequency ())
2853       error_found = true;
2854   if (!callers && global.inlined_to)
2855     {
2856       error ("inlined_to pointer is set but no predecessors found");
2857       error_found = true;
2858     }
2859   if (global.inlined_to == this)
2860     {
2861       error ("inlined_to pointer refers to itself");
2862       error_found = true;
2863     }
2864
2865   if (clone_of)
2866     {
2867       cgraph_node *n;
2868       for (n = clone_of->clones; n; n = n->next_sibling_clone)
2869         if (n == this)
2870           break;
2871       if (!n)
2872         {
2873           error ("cgraph_node has wrong clone_of");
2874           error_found = true;
2875         }
2876     }
2877   if (clones)
2878     {
2879       cgraph_node *n;
2880       for (n = clones; n; n = n->next_sibling_clone)
2881         if (n->clone_of != this)
2882           break;
2883       if (n)
2884         {
2885           error ("cgraph_node has wrong clone list");
2886           error_found = true;
2887         }
2888     }
2889   if ((prev_sibling_clone || next_sibling_clone) && !clone_of)
2890     {
2891        error ("cgraph_node is in clone list but it is not clone");
2892        error_found = true;
2893     }
2894   if (!prev_sibling_clone && clone_of && clone_of->clones != this)
2895     {
2896       error ("cgraph_node has wrong prev_clone pointer");
2897       error_found = true;
2898     }
2899   if (prev_sibling_clone && prev_sibling_clone->next_sibling_clone != this)
2900     {
2901       error ("double linked list of clones corrupted");
2902       error_found = true;
2903     }
2904
2905   if (analyzed && alias)
2906     {
2907       bool ref_found = false;
2908       int i;
2909       ipa_ref *ref = NULL;
2910
2911       if (callees)
2912         {
2913           error ("Alias has call edges");
2914           error_found = true;
2915         }
2916       for (i = 0; iterate_reference (i, ref); i++)
2917         if (ref->use == IPA_REF_CHKP)
2918           ;
2919         else if (ref->use != IPA_REF_ALIAS)
2920           {
2921             error ("Alias has non-alias reference");
2922             error_found = true;
2923           }
2924         else if (ref_found)
2925           {
2926             error ("Alias has more than one alias reference");
2927             error_found = true;
2928           }
2929         else
2930           ref_found = true;
2931         if (!ref_found)
2932           {
2933             error ("Analyzed alias has no reference");
2934             error_found = true;
2935           }
2936     }
2937
2938   /* Check instrumented version reference.  */
2939   if (instrumented_version
2940       && instrumented_version->instrumented_version != this)
2941     {
2942       error ("Instrumentation clone does not reference original node");
2943       error_found = true;
2944     }
2945
2946   /* Cannot have orig_decl for not instrumented nodes.  */
2947   if (!instrumentation_clone && orig_decl)
2948     {
2949       error ("Not instrumented node has non-NULL original declaration");
2950       error_found = true;
2951     }
2952
2953   /* If original not instrumented node still exists then we may check
2954      original declaration is set properly.  */
2955   if (instrumented_version
2956       && orig_decl
2957       && orig_decl != instrumented_version->decl)
2958     {
2959       error ("Instrumented node has wrong original declaration");
2960       error_found = true;
2961     }
2962
2963   /* Check all nodes have chkp reference to their instrumented versions.  */
2964   if (analyzed
2965       && instrumented_version
2966       && !instrumentation_clone)
2967     {
2968       bool ref_found = false;
2969       int i;
2970       struct ipa_ref *ref;
2971
2972       for (i = 0; iterate_reference (i, ref); i++)
2973         if (ref->use == IPA_REF_CHKP)
2974           {
2975             if (ref_found)
2976               {
2977                 error ("Node has more than one chkp reference");
2978                 error_found = true;
2979               }
2980             if (ref->referred != instrumented_version)
2981               {
2982                 error ("Wrong node is referenced with chkp reference");
2983                 error_found = true;
2984               }
2985             ref_found = true;
2986           }
2987
2988       if (!ref_found)
2989         {
2990           error ("Analyzed node has no reference to instrumented version");
2991           error_found = true;
2992         }
2993     }
2994
2995   if (analyzed && thunk.thunk_p)
2996     {
2997       if (!callees)
2998         {
2999           error ("No edge out of thunk node");
3000           error_found = true;
3001         }
3002       else if (callees->next_callee)
3003         {
3004           error ("More than one edge out of thunk node");
3005           error_found = true;
3006         }
3007       if (gimple_has_body_p (decl))
3008         {
3009           error ("Thunk is not supposed to have body");
3010           error_found = true;
3011         }
3012       if (thunk.add_pointer_bounds_args
3013           && !instrumented_version->semantically_equivalent_p (callees->callee))
3014         {
3015           error ("Instrumentation thunk has wrong edge callee");
3016           error_found = true;
3017         }
3018     }
3019   else if (analyzed && gimple_has_body_p (decl)
3020            && !TREE_ASM_WRITTEN (decl)
3021            && (!DECL_EXTERNAL (decl) || global.inlined_to)
3022            && !flag_wpa)
3023     {
3024       if (this_cfun->cfg)
3025         {
3026           hash_set<gimple> stmts;
3027           int i;
3028           ipa_ref *ref = NULL;
3029
3030           /* Reach the trees by walking over the CFG, and note the
3031              enclosing basic-blocks in the call edges.  */
3032           FOR_EACH_BB_FN (this_block, this_cfun)
3033             {
3034               for (gsi = gsi_start_phis (this_block);
3035                    !gsi_end_p (gsi); gsi_next (&gsi))
3036                 stmts.add (gsi_stmt (gsi));
3037               for (gsi = gsi_start_bb (this_block);
3038                    !gsi_end_p (gsi);
3039                    gsi_next (&gsi))
3040                 {
3041                   gimple stmt = gsi_stmt (gsi);
3042                   stmts.add (stmt);
3043                   if (is_gimple_call (stmt))
3044                     {
3045                       cgraph_edge *e = get_edge (stmt);
3046                       tree decl = gimple_call_fndecl (stmt);
3047                       if (e)
3048                         {
3049                           if (e->aux)
3050                             {
3051                               error ("shared call_stmt:");
3052                               cgraph_debug_gimple_stmt (this_cfun, stmt);
3053                               error_found = true;
3054                             }
3055                           if (!e->indirect_unknown_callee)
3056                             {
3057                               if (e->verify_corresponds_to_fndecl (decl))
3058                                 {
3059                                   error ("edge points to wrong declaration:");
3060                                   debug_tree (e->callee->decl);
3061                                   fprintf (stderr," Instead of:");
3062                                   debug_tree (decl);
3063                                   error_found = true;
3064                                 }
3065                             }
3066                           else if (decl)
3067                             {
3068                               error ("an indirect edge with unknown callee "
3069                                      "corresponding to a call_stmt with "
3070                                      "a known declaration:");
3071                               error_found = true;
3072                               cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
3073                             }
3074                           e->aux = (void *)1;
3075                         }
3076                       else if (decl)
3077                         {
3078                           error ("missing callgraph edge for call stmt:");
3079                           cgraph_debug_gimple_stmt (this_cfun, stmt);
3080                           error_found = true;
3081                         }
3082                     }
3083                 }
3084               }
3085             for (i = 0; iterate_reference (i, ref); i++)
3086               if (ref->stmt && !stmts.contains (ref->stmt))
3087                 {
3088                   error ("reference to dead statement");
3089                   cgraph_debug_gimple_stmt (this_cfun, ref->stmt);
3090                   error_found = true;
3091                 }
3092         }
3093       else
3094         /* No CFG available?!  */
3095         gcc_unreachable ();
3096
3097       for (e = callees; e; e = e->next_callee)
3098         {
3099           if (!e->aux)
3100             {
3101               error ("edge %s->%s has no corresponding call_stmt",
3102                      identifier_to_locale (e->caller->name ()),
3103                      identifier_to_locale (e->callee->name ()));
3104               cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
3105               error_found = true;
3106             }
3107           e->aux = 0;
3108         }
3109       for (e = indirect_calls; e; e = e->next_callee)
3110         {
3111           if (!e->aux && !e->speculative)
3112             {
3113               error ("an indirect edge from %s has no corresponding call_stmt",
3114                      identifier_to_locale (e->caller->name ()));
3115               cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
3116               error_found = true;
3117             }
3118           e->aux = 0;
3119         }
3120     }
3121   if (error_found)
3122     {
3123       dump (stderr);
3124       internal_error ("verify_cgraph_node failed");
3125     }
3126   timevar_pop (TV_CGRAPH_VERIFY);
3127 }
3128
3129 /* Verify whole cgraph structure.  */
3130 DEBUG_FUNCTION void
3131 cgraph_node::verify_cgraph_nodes (void)
3132 {
3133   cgraph_node *node;
3134
3135   if (seen_error ())
3136     return;
3137
3138   FOR_EACH_FUNCTION (node)
3139     node->verify ();
3140 }
3141
3142 /* Walk the alias chain to return the function cgraph_node is alias of.
3143    Walk through thunks, too.
3144    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
3145
3146 cgraph_node *
3147 cgraph_node::function_symbol (enum availability *availability)
3148 {
3149   cgraph_node *node = ultimate_alias_target (availability);
3150
3151   while (node->thunk.thunk_p)
3152     {
3153       node = node->callees->callee;
3154       if (availability)
3155         {
3156           enum availability a;
3157           a = node->get_availability ();
3158           if (a < *availability)
3159             *availability = a;
3160         }
3161       node = node->ultimate_alias_target (availability);
3162     }
3163   return node;
3164 }
3165
3166 /* Walk the alias chain to return the function cgraph_node is alias of.
3167    Walk through non virtual thunks, too.  Thus we return either a function
3168    or a virtual thunk node.
3169    When AVAILABILITY is non-NULL, get minimal availability in the chain.  */
3170
3171 cgraph_node *
3172 cgraph_node::function_or_virtual_thunk_symbol
3173                                 (enum availability *availability)
3174 {
3175   cgraph_node *node = ultimate_alias_target (availability);
3176
3177   while (node->thunk.thunk_p && !node->thunk.virtual_offset_p)
3178     {
3179       node = node->callees->callee;
3180       if (availability)
3181         {
3182           enum availability a;
3183           a = node->get_availability ();
3184           if (a < *availability)
3185             *availability = a;
3186         }
3187       node = node->ultimate_alias_target (availability);
3188     }
3189   return node;
3190 }
3191
3192 /* When doing LTO, read cgraph_node's body from disk if it is not already
3193    present.  */
3194
3195 bool
3196 cgraph_node::get_untransformed_body (void)
3197 {
3198   lto_file_decl_data *file_data;
3199   const char *data, *name;
3200   size_t len;
3201   tree decl = this->decl;
3202
3203   if (DECL_RESULT (decl))
3204     return false;
3205
3206   gcc_assert (in_lto_p);
3207
3208   timevar_push (TV_IPA_LTO_GIMPLE_IN);
3209
3210   file_data = lto_file_data;
3211   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
3212
3213   /* We may have renamed the declaration, e.g., a static function.  */
3214   name = lto_get_decl_name_mapping (file_data, name);
3215
3216   data = lto_get_section_data (file_data, LTO_section_function_body,
3217                                name, &len);
3218   if (!data)
3219     fatal_error (input_location, "%s: section %s is missing",
3220                  file_data->file_name,
3221                  name);
3222
3223   gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
3224
3225   lto_input_function_body (file_data, this, data);
3226   lto_stats.num_function_bodies++;
3227   lto_free_section_data (file_data, LTO_section_function_body, name,
3228                          data, len);
3229   lto_free_function_in_decl_state_for_node (this);
3230   /* Keep lto file data so ipa-inline-analysis knows about cross module
3231      inlining.  */
3232
3233   timevar_pop (TV_IPA_LTO_GIMPLE_IN);
3234
3235   return true;
3236 }
3237
3238 /* Prepare function body.  When doing LTO, read cgraph_node's body from disk 
3239    if it is not already present.  When some IPA transformations are scheduled,
3240    apply them.  */
3241
3242 bool
3243 cgraph_node::get_body (void)
3244 {
3245   bool updated;
3246
3247   updated = get_untransformed_body ();
3248
3249   /* Getting transformed body makes no sense for inline clones;
3250      we should never use this on real clones becuase they are materialized
3251      early.
3252      TODO: Materializing clones here will likely lead to smaller LTRANS
3253      footprint. */
3254   gcc_assert (!global.inlined_to && !clone_of);
3255   if (ipa_transforms_to_apply.exists ())
3256     {
3257       opt_pass *saved_current_pass = current_pass;
3258       FILE *saved_dump_file = dump_file;
3259       int saved_dump_flags = dump_flags;
3260
3261       push_cfun (DECL_STRUCT_FUNCTION (decl));
3262       execute_all_ipa_transforms ();
3263       cgraph_edge::rebuild_edges ();
3264       free_dominance_info (CDI_DOMINATORS);
3265       free_dominance_info (CDI_POST_DOMINATORS);
3266       pop_cfun ();
3267       updated = true;
3268
3269       current_pass = saved_current_pass;
3270       dump_file = saved_dump_file;
3271       dump_flags = saved_dump_flags;
3272     }
3273   return updated;
3274 }
3275
3276 /* Return the DECL_STRUCT_FUNCTION of the function.  */
3277
3278 struct function *
3279 cgraph_node::get_fun (void)
3280 {
3281   cgraph_node *node = this;
3282   struct function *fun = DECL_STRUCT_FUNCTION (node->decl);
3283
3284   while (!fun && node->clone_of)
3285     {
3286       node = node->clone_of;
3287       fun = DECL_STRUCT_FUNCTION (node->decl);
3288     }
3289
3290   return fun;
3291 }
3292
3293 /* Verify if the type of the argument matches that of the function
3294    declaration.  If we cannot verify this or there is a mismatch,
3295    return false.  */
3296
3297 static bool
3298 gimple_check_call_args (gimple stmt, tree fndecl, bool args_count_match)
3299 {
3300   tree parms, p;
3301   unsigned int i, nargs;
3302
3303   /* Calls to internal functions always match their signature.  */
3304   if (gimple_call_internal_p (stmt))
3305     return true;
3306
3307   nargs = gimple_call_num_args (stmt);
3308
3309   /* Get argument types for verification.  */
3310   if (fndecl)
3311     parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
3312   else
3313     parms = TYPE_ARG_TYPES (gimple_call_fntype (stmt));
3314
3315   /* Verify if the type of the argument matches that of the function
3316      declaration.  If we cannot verify this or there is a mismatch,
3317      return false.  */
3318   if (fndecl && DECL_ARGUMENTS (fndecl))
3319     {
3320       for (i = 0, p = DECL_ARGUMENTS (fndecl);
3321            i < nargs;
3322            i++, p = DECL_CHAIN (p))
3323         {
3324           tree arg;
3325           /* We cannot distinguish a varargs function from the case
3326              of excess parameters, still deferring the inlining decision
3327              to the callee is possible.  */
3328           if (!p)
3329             break;
3330           arg = gimple_call_arg (stmt, i);
3331           if (p == error_mark_node
3332               || DECL_ARG_TYPE (p) == error_mark_node
3333               || arg == error_mark_node
3334               || (!types_compatible_p (DECL_ARG_TYPE (p), TREE_TYPE (arg))
3335                   && !fold_convertible_p (DECL_ARG_TYPE (p), arg)))
3336             return false;
3337         }
3338       if (args_count_match && p)
3339         return false;
3340     }
3341   else if (parms)
3342     {
3343       for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
3344         {
3345           tree arg;
3346           /* If this is a varargs function defer inlining decision
3347              to callee.  */
3348           if (!p)
3349             break;
3350           arg = gimple_call_arg (stmt, i);
3351           if (TREE_VALUE (p) == error_mark_node
3352               || arg == error_mark_node
3353               || TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
3354               || (!types_compatible_p (TREE_VALUE (p), TREE_TYPE (arg))
3355                   && !fold_convertible_p (TREE_VALUE (p), arg)))
3356             return false;
3357         }
3358     }
3359   else
3360     {
3361       if (nargs != 0)
3362         return false;
3363     }
3364   return true;
3365 }
3366
3367 /* Verify if the type of the argument and lhs of CALL_STMT matches
3368    that of the function declaration CALLEE. If ARGS_COUNT_MATCH is
3369    true, the arg count needs to be the same.
3370    If we cannot verify this or there is a mismatch, return false.  */
3371
3372 bool
3373 gimple_check_call_matching_types (gimple call_stmt, tree callee,
3374                                   bool args_count_match)
3375 {
3376   tree lhs;
3377
3378   if ((DECL_RESULT (callee)
3379        && !DECL_BY_REFERENCE (DECL_RESULT (callee))
3380        && (lhs = gimple_call_lhs (call_stmt)) != NULL_TREE
3381        && !useless_type_conversion_p (TREE_TYPE (DECL_RESULT (callee)),
3382                                       TREE_TYPE (lhs))
3383        && !fold_convertible_p (TREE_TYPE (DECL_RESULT (callee)), lhs))
3384       || !gimple_check_call_args (call_stmt, callee, args_count_match))
3385     return false;
3386   return true;
3387 }
3388
3389 /* Reset all state within cgraph.c so that we can rerun the compiler
3390    within the same process.  For use by toplev::finalize.  */
3391
3392 void
3393 cgraph_c_finalize (void)
3394 {
3395   symtab = NULL;
3396
3397   x_cgraph_nodes_queue = NULL;
3398
3399   cgraph_fnver_htab = NULL;
3400   version_info_node = NULL;
3401 }
3402
3403 /* A wroker for call_for_symbol_and_aliases.  */
3404
3405 bool
3406 cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
3407                                                               void *),
3408                                             void *data,
3409                                             bool include_overwritable)
3410 {
3411   ipa_ref *ref;
3412   FOR_EACH_ALIAS (this, ref)
3413     {
3414       cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
3415       if (include_overwritable
3416           || alias->get_availability () > AVAIL_INTERPOSABLE)
3417         if (alias->call_for_symbol_and_aliases (callback, data,
3418                                                 include_overwritable))
3419           return true;
3420     }
3421   return false;
3422 }
3423
3424 /* Return true if NODE has thunk.  */
3425
3426 bool
3427 cgraph_node::has_thunk_p (cgraph_node *node, void *)
3428 {
3429   for (cgraph_edge *e = node->callers; e; e = e->next_caller)
3430     if (e->caller->thunk.thunk_p)
3431       return true;
3432   return false;
3433 }
3434
3435 #include "gt-cgraph.h"