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