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