Bug Summary

File:build/gcc/cgraph.c
Warning:line 1676, column 6
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name cgraph.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-IyFEAW.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.c

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.c

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

/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h

1/* Gimple IR definitions.
2
3 Copyright (C) 2007-2021 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#ifndef GCC_GIMPLE_H
23#define GCC_GIMPLE_H
24
25#include "tree-ssa-alias.h"
26#include "gimple-expr.h"
27
28typedef gimple *gimple_seq_node;
29
30enum gimple_code {
31#define DEFGSCODE(SYM, STRING, STRUCT) SYM,
32#include "gimple.def"
33#undef DEFGSCODE
34 LAST_AND_UNUSED_GIMPLE_CODE
35};
36
37extern const char *const gimple_code_name[];
38extern const unsigned char gimple_rhs_class_table[];
39
40/* Strip the outermost pointer, from tr1/type_traits. */
41template<typename T> struct remove_pointer { typedef T type; };
42template<typename T> struct remove_pointer<T *> { typedef T type; };
43
44/* Error out if a gimple tuple is addressed incorrectly. */
45#if defined ENABLE_GIMPLE_CHECKING1
46#define gcc_gimple_checking_assert(EXPR)((void)(!(EXPR) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h"
, 46, __FUNCTION__), 0 : 0))
gcc_assert (EXPR)((void)(!(EXPR) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h"
, 46, __FUNCTION__), 0 : 0))
47extern void gimple_check_failed (const gimple *, const char *, int, \
48 const char *, enum gimple_code, \
49 enum tree_code) ATTRIBUTE_NORETURN__attribute__ ((__noreturn__)) \
50 ATTRIBUTE_COLD;
51
52#define GIMPLE_CHECK(GS, CODE)do { const gimple *__gs = (GS); if (gimple_code (__gs) != (CODE
)) gimple_check_failed (__gs, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h"
, 52, __FUNCTION__, (CODE), ERROR_MARK); } while (0)
\
53 do { \
54 const gimple *__gs = (GS); \
55 if (gimple_code (__gs) != (CODE)) \
56 gimple_check_failed (__gs, __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h", __LINE__56, __FUNCTION__, \
57 (CODE), ERROR_MARK); \
58 } while (0)
59template <typename T>
60static inline T
61GIMPLE_CHECK2(const gimple *gs,
62#if __GNUC__4 > 4 || (__GNUC__4 == 4 && __GNUC_MINOR__2 >= 8)
63 const char *file = __builtin_FILE (),
64 int line = __builtin_LINE (),
65 const char *fun = __builtin_FUNCTION ())
66#else
67 const char *file = __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h",
68 int line = __LINE__68,
69 const char *fun = NULL__null)
70#endif
71{
72 T ret = dyn_cast <T> (gs);
73 if (!ret)
74 gimple_check_failed (gs, file, line, fun,
75 remove_pointer<T>::type::code_, ERROR_MARK);
76 return ret;
77}
78template <typename T>
79static inline T
80GIMPLE_CHECK2(gimple *gs,
81#if __GNUC__4 > 4 || (__GNUC__4 == 4 && __GNUC_MINOR__2 >= 8)
82 const char *file = __builtin_FILE (),
83 int line = __builtin_LINE (),
84 const char *fun = __builtin_FUNCTION ())
85#else
86 const char *file = __FILE__"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h",
87 int line = __LINE__87,
88 const char *fun = NULL__null)
89#endif
90{
91 T ret = dyn_cast <T> (gs);
92 if (!ret)
93 gimple_check_failed (gs, file, line, fun,
94 remove_pointer<T>::type::code_, ERROR_MARK);
95 return ret;
96}
97#else /* not ENABLE_GIMPLE_CHECKING */
98#define gcc_gimple_checking_assert(EXPR)((void)(!(EXPR) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h"
, 98, __FUNCTION__), 0 : 0))
((void)(0 && (EXPR)))
99#define GIMPLE_CHECK(GS, CODE)do { const gimple *__gs = (GS); if (gimple_code (__gs) != (CODE
)) gimple_check_failed (__gs, "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h"
, 99, __FUNCTION__, (CODE), ERROR_MARK); } while (0)
(void)0
100template <typename T>
101static inline T
102GIMPLE_CHECK2(gimple *gs)
103{
104 return as_a <T> (gs);
105}
106template <typename T>
107static inline T
108GIMPLE_CHECK2(const gimple *gs)
109{
110 return as_a <T> (gs);
111}
112#endif
113
114/* Class of GIMPLE expressions suitable for the RHS of assignments. See
115 get_gimple_rhs_class. */
116enum gimple_rhs_class
117{
118 GIMPLE_INVALID_RHS, /* The expression cannot be used on the RHS. */
119 GIMPLE_TERNARY_RHS, /* The expression is a ternary operation. */
120 GIMPLE_BINARY_RHS, /* The expression is a binary operation. */
121 GIMPLE_UNARY_RHS, /* The expression is a unary operation. */
122 GIMPLE_SINGLE_RHS /* The expression is a single object (an SSA
123 name, a _DECL, a _REF, etc. */
124};
125
126/* Specific flags for individual GIMPLE statements. These flags are
127 always stored in gimple.subcode and they may only be
128 defined for statement codes that do not use subcodes.
129
130 Values for the masks can overlap as long as the overlapping values
131 are never used in the same statement class.
132
133 The maximum mask value that can be defined is 1 << 15 (i.e., each
134 statement code can hold up to 16 bitflags).
135
136 Keep this list sorted. */
137enum gf_mask {
138 GF_ASM_INPUT = 1 << 0,
139 GF_ASM_VOLATILE = 1 << 1,
140 GF_ASM_INLINE = 1 << 2,
141 GF_CALL_FROM_THUNK = 1 << 0,
142 GF_CALL_RETURN_SLOT_OPT = 1 << 1,
143 GF_CALL_TAILCALL = 1 << 2,
144 GF_CALL_VA_ARG_PACK = 1 << 3,
145 GF_CALL_NOTHROW = 1 << 4,
146 GF_CALL_ALLOCA_FOR_VAR = 1 << 5,
147 GF_CALL_INTERNAL = 1 << 6,
148 GF_CALL_CTRL_ALTERING = 1 << 7,
149 GF_CALL_MUST_TAIL_CALL = 1 << 9,
150 GF_CALL_BY_DESCRIPTOR = 1 << 10,
151 GF_CALL_NOCF_CHECK = 1 << 11,
152 GF_CALL_FROM_NEW_OR_DELETE = 1 << 12,
153 GF_OMP_PARALLEL_COMBINED = 1 << 0,
154 GF_OMP_TASK_TASKLOOP = 1 << 0,
155 GF_OMP_TASK_TASKWAIT = 1 << 1,
156 GF_OMP_FOR_KIND_MASK = (1 << 3) - 1,
157 GF_OMP_FOR_KIND_FOR = 0,
158 GF_OMP_FOR_KIND_DISTRIBUTE = 1,
159 GF_OMP_FOR_KIND_TASKLOOP = 2,
160 GF_OMP_FOR_KIND_OACC_LOOP = 4,
161 GF_OMP_FOR_KIND_SIMD = 5,
162 GF_OMP_FOR_COMBINED = 1 << 3,
163 GF_OMP_FOR_COMBINED_INTO = 1 << 4,
164 GF_OMP_TARGET_KIND_MASK = (1 << 4) - 1,
165 GF_OMP_TARGET_KIND_REGION = 0,
166 GF_OMP_TARGET_KIND_DATA = 1,
167 GF_OMP_TARGET_KIND_UPDATE = 2,
168 GF_OMP_TARGET_KIND_ENTER_DATA = 3,
169 GF_OMP_TARGET_KIND_EXIT_DATA = 4,
170 GF_OMP_TARGET_KIND_OACC_PARALLEL = 5,
171 GF_OMP_TARGET_KIND_OACC_KERNELS = 6,
172 GF_OMP_TARGET_KIND_OACC_SERIAL = 7,
173 GF_OMP_TARGET_KIND_OACC_DATA = 8,
174 GF_OMP_TARGET_KIND_OACC_UPDATE = 9,
175 GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA = 10,
176 GF_OMP_TARGET_KIND_OACC_DECLARE = 11,
177 GF_OMP_TARGET_KIND_OACC_HOST_DATA = 12,
178 /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
179 decomposed part, parallelized. */
180 GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED = 13,
181 /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
182 decomposed part, "gang-single". */
183 GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE = 14,
184 /* A 'GF_OMP_TARGET_KIND_OACC_DATA' representing an OpenACC 'kernels'
185 decomposed parts' 'data' construct. */
186 GF_OMP_TARGET_KIND_OACC_DATA_KERNELS = 15,
187 GF_OMP_TEAMS_HOST = 1 << 0,
188
189 /* True on an GIMPLE_OMP_RETURN statement if the return does not require
190 a thread synchronization via some sort of barrier. The exact barrier
191 that would otherwise be emitted is dependent on the OMP statement with
192 which this return is associated. */
193 GF_OMP_RETURN_NOWAIT = 1 << 0,
194
195 GF_OMP_SECTION_LAST = 1 << 0,
196 GF_OMP_ATOMIC_MEMORY_ORDER = (1 << 3) - 1,
197 GF_OMP_ATOMIC_NEED_VALUE = 1 << 3,
198 GF_PREDICT_TAKEN = 1 << 15
199};
200
201/* This subcode tells apart different kinds of stmts that are not used
202 for codegen, but rather to retain debug information. */
203enum gimple_debug_subcode {
204 GIMPLE_DEBUG_BIND = 0,
205 GIMPLE_DEBUG_SOURCE_BIND = 1,
206 GIMPLE_DEBUG_BEGIN_STMT = 2,
207 GIMPLE_DEBUG_INLINE_ENTRY = 3
208};
209
210/* Masks for selecting a pass local flag (PLF) to work on. These
211 masks are used by gimple_set_plf and gimple_plf. */
212enum plf_mask {
213 GF_PLF_1 = 1 << 0,
214 GF_PLF_2 = 1 << 1
215};
216
217/* Data structure definitions for GIMPLE tuples. NOTE: word markers
218 are for 64 bit hosts. */
219
220struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
221 chain_next ("%h.next"), variable_size))
222 gimple
223{
224 /* [ WORD 1 ]
225 Main identifying code for a tuple. */
226 ENUM_BITFIELD(gimple_code)enum gimple_code code : 8;
227
228 /* Nonzero if a warning should not be emitted on this tuple. */
229 unsigned int no_warning : 1;
230
231 /* Nonzero if this tuple has been visited. Passes are responsible
232 for clearing this bit before using it. */
233 unsigned int visited : 1;
234
235 /* Nonzero if this tuple represents a non-temporal move. */
236 unsigned int nontemporal_move : 1;
237
238 /* Pass local flags. These flags are free for any pass to use as
239 they see fit. Passes should not assume that these flags contain
240 any useful value when the pass starts. Any initial state that
241 the pass requires should be set on entry to the pass. See
242 gimple_set_plf and gimple_plf for usage. */
243 unsigned int plf : 2;
244
245 /* Nonzero if this statement has been modified and needs to have its
246 operands rescanned. */
247 unsigned modified : 1;
248
249 /* Nonzero if this statement contains volatile operands. */
250 unsigned has_volatile_ops : 1;
251
252 /* Padding to get subcode to 16 bit alignment. */
253 unsigned pad : 1;
254
255 /* The SUBCODE field can be used for tuple-specific flags for tuples
256 that do not require subcodes. Note that SUBCODE should be at
257 least as wide as tree codes, as several tuples store tree codes
258 in there. */
259 unsigned int subcode : 16;
260
261 /* UID of this statement. This is used by passes that want to
262 assign IDs to statements. It must be assigned and used by each
263 pass. By default it should be assumed to contain garbage. */
264 unsigned uid;
265
266 /* [ WORD 2 ]
267 Locus information for debug info. */
268 location_t location;
269
270 /* Number of operands in this tuple. */
271 unsigned num_ops;
272
273 /* [ WORD 3 ]
274 Basic block holding this statement. */
275 basic_block bb;
276
277 /* [ WORD 4-5 ]
278 Linked lists of gimple statements. The next pointers form
279 a NULL terminated list, the prev pointers are a cyclic list.
280 A gimple statement is hence also a double-ended list of
281 statements, with the pointer itself being the first element,
282 and the prev pointer being the last. */
283 gimple *next;
284 gimple *GTY((skip)) prev;
285};
286
287
288/* Base structure for tuples with operands. */
289
290/* This gimple subclass has no tag value. */
291struct GTY(())
292 gimple_statement_with_ops_base : public gimple
293{
294 /* [ WORD 1-6 ] : base class */
295
296 /* [ WORD 7 ]
297 SSA operand vectors. NOTE: It should be possible to
298 amalgamate these vectors with the operand vector OP. However,
299 the SSA operand vectors are organized differently and contain
300 more information (like immediate use chaining). */
301 struct use_optype_d GTY((skip (""))) *use_ops;
302};
303
304
305/* Statements that take register operands. */
306
307struct GTY((tag("GSS_WITH_OPS")))
308 gimple_statement_with_ops : public gimple_statement_with_ops_base
309{
310 /* [ WORD 1-7 ] : base class */
311
312 /* [ WORD 8 ]
313 Operand vector. NOTE! This must always be the last field
314 of this structure. In particular, this means that this
315 structure cannot be embedded inside another one. */
316 tree GTY((length ("%h.num_ops"))) op[1];
317};
318
319
320/* Base for statements that take both memory and register operands. */
321
322struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
323 gimple_statement_with_memory_ops_base : public gimple_statement_with_ops_base
324{
325 /* [ WORD 1-7 ] : base class */
326
327 /* [ WORD 8-9 ]
328 Virtual operands for this statement. The GC will pick them
329 up via the ssa_names array. */
330 tree GTY((skip (""))) vdef;
331 tree GTY((skip (""))) vuse;
332};
333
334
335/* Statements that take both memory and register operands. */
336
337struct GTY((tag("GSS_WITH_MEM_OPS")))
338 gimple_statement_with_memory_ops :
339 public gimple_statement_with_memory_ops_base
340{
341 /* [ WORD 1-9 ] : base class */
342
343 /* [ WORD 10 ]
344 Operand vector. NOTE! This must always be the last field
345 of this structure. In particular, this means that this
346 structure cannot be embedded inside another one. */
347 tree GTY((length ("%h.num_ops"))) op[1];
348};
349
350
351/* Call statements that take both memory and register operands. */
352
353struct GTY((tag("GSS_CALL")))
354 gcall : public gimple_statement_with_memory_ops_base
355{
356 /* [ WORD 1-9 ] : base class */
357
358 /* [ WORD 10-13 ] */
359 struct pt_solution call_used;
360 struct pt_solution call_clobbered;
361
362 /* [ WORD 14 ] */
363 union GTY ((desc ("%1.subcode & GF_CALL_INTERNAL"))) {
364 tree GTY ((tag ("0"))) fntype;
365 enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn;
366 } u;
367
368 /* [ WORD 15 ]
369 Operand vector. NOTE! This must always be the last field
370 of this structure. In particular, this means that this
371 structure cannot be embedded inside another one. */
372 tree GTY((length ("%h.num_ops"))) op[1];
373
374 static const enum gimple_code code_ = GIMPLE_CALL;
375};
376
377
378/* OMP statements. */
379
380struct GTY((tag("GSS_OMP")))
381 gimple_statement_omp : public gimple
382{
383 /* [ WORD 1-6 ] : base class */
384
385 /* [ WORD 7 ] */
386 gimple_seq body;
387};
388
389
390/* GIMPLE_BIND */
391
392struct GTY((tag("GSS_BIND")))
393 gbind : public gimple
394{
395 /* [ WORD 1-6 ] : base class */
396
397 /* [ WORD 7 ]
398 Variables declared in this scope. */
399 tree vars;
400
401 /* [ WORD 8 ]
402 This is different than the BLOCK field in gimple,
403 which is analogous to TREE_BLOCK (i.e., the lexical block holding
404 this statement). This field is the equivalent of BIND_EXPR_BLOCK
405 in tree land (i.e., the lexical scope defined by this bind). See
406 gimple-low.c. */
407 tree block;
408
409 /* [ WORD 9 ] */
410 gimple_seq body;
411};
412
413
414/* GIMPLE_CATCH */
415
416struct GTY((tag("GSS_CATCH")))
417 gcatch : public gimple
418{
419 /* [ WORD 1-6 ] : base class */
420
421 /* [ WORD 7 ] */
422 tree types;
423
424 /* [ WORD 8 ] */
425 gimple_seq handler;
426};
427
428
429/* GIMPLE_EH_FILTER */
430
431struct GTY((tag("GSS_EH_FILTER")))
432 geh_filter : public gimple
433{
434 /* [ WORD 1-6 ] : base class */
435
436 /* [ WORD 7 ]
437 Filter types. */
438 tree types;
439
440 /* [ WORD 8 ]
441 Failure actions. */
442 gimple_seq failure;
443};
444
445/* GIMPLE_EH_ELSE */
446
447struct GTY((tag("GSS_EH_ELSE")))
448 geh_else : public gimple
449{
450 /* [ WORD 1-6 ] : base class */
451
452 /* [ WORD 7,8 ] */
453 gimple_seq n_body, e_body;
454};
455
456/* GIMPLE_EH_MUST_NOT_THROW */
457
458struct GTY((tag("GSS_EH_MNT")))
459 geh_mnt : public gimple
460{
461 /* [ WORD 1-6 ] : base class */
462
463 /* [ WORD 7 ] Abort function decl. */
464 tree fndecl;
465};
466
467/* GIMPLE_PHI */
468
469struct GTY((tag("GSS_PHI")))
470 gphi : public gimple
471{
472 /* [ WORD 1-6 ] : base class */
473
474 /* [ WORD 7 ] */
475 unsigned capacity;
476 unsigned nargs;
477
478 /* [ WORD 8 ] */
479 tree result;
480
481 /* [ WORD 9 ] */
482 struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
483};
484
485
486/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
487
488struct GTY((tag("GSS_EH_CTRL")))
489 gimple_statement_eh_ctrl : public gimple
490{
491 /* [ WORD 1-6 ] : base class */
492
493 /* [ WORD 7 ]
494 Exception region number. */
495 int region;
496};
497
498struct GTY((tag("GSS_EH_CTRL")))
499 gresx : public gimple_statement_eh_ctrl
500{
501 /* No extra fields; adds invariant:
502 stmt->code == GIMPLE_RESX. */
503};
504
505struct GTY((tag("GSS_EH_CTRL")))
506 geh_dispatch : public gimple_statement_eh_ctrl
507{
508 /* No extra fields; adds invariant:
509 stmt->code == GIMPLE_EH_DISPATH. */
510};
511
512
513/* GIMPLE_TRY */
514
515struct GTY((tag("GSS_TRY")))
516 gtry : public gimple
517{
518 /* [ WORD 1-6 ] : base class */
519
520 /* [ WORD 7 ]
521 Expression to evaluate. */
522 gimple_seq eval;
523
524 /* [ WORD 8 ]
525 Cleanup expression. */
526 gimple_seq cleanup;
527};
528
529/* Kind of GIMPLE_TRY statements. */
530enum gimple_try_flags
531{
532 /* A try/catch. */
533 GIMPLE_TRY_CATCH = 1 << 0,
534
535 /* A try/finally. */
536 GIMPLE_TRY_FINALLY = 1 << 1,
537 GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY,
538
539 /* Analogous to TRY_CATCH_IS_CLEANUP. */
540 GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2
541};
542
543/* GIMPLE_WITH_CLEANUP_EXPR */
544
545struct GTY((tag("GSS_WCE")))
546 gimple_statement_wce : public gimple
547{
548 /* [ WORD 1-6 ] : base class */
549
550 /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be
551 executed if an exception is thrown, not on normal exit of its
552 scope. This flag is analogous to the CLEANUP_EH_ONLY flag
553 in TARGET_EXPRs. */
554
555 /* [ WORD 7 ]
556 Cleanup expression. */
557 gimple_seq cleanup;
558};
559
560
561/* GIMPLE_ASM */
562
563struct GTY((tag("GSS_ASM")))
564 gasm : public gimple_statement_with_memory_ops_base
565{
566 /* [ WORD 1-9 ] : base class */
567
568 /* [ WORD 10 ]
569 __asm__ statement. */
570 const char *string;
571
572 /* [ WORD 11 ]
573 Number of inputs, outputs, clobbers, labels. */
574 unsigned char ni;
575 unsigned char no;
576 unsigned char nc;
577 unsigned char nl;
578
579 /* [ WORD 12 ]
580 Operand vector. NOTE! This must always be the last field
581 of this structure. In particular, this means that this
582 structure cannot be embedded inside another one. */
583 tree GTY((length ("%h.num_ops"))) op[1];
584};
585
586/* GIMPLE_OMP_CRITICAL */
587
588struct GTY((tag("GSS_OMP_CRITICAL")))
589 gomp_critical : public gimple_statement_omp
590{
591 /* [ WORD 1-7 ] : base class */
592
593 /* [ WORD 8 ] */
594 tree clauses;
595
596 /* [ WORD 9 ]
597 Critical section name. */
598 tree name;
599};
600
601
602struct GTY(()) gimple_omp_for_iter {
603 /* Condition code. */
604 enum tree_code cond;
605
606 /* Index variable. */
607 tree index;
608
609 /* Initial value. */
610 tree initial;
611
612 /* Final value. */
613 tree final;
614
615 /* Increment. */
616 tree incr;
617};
618
619/* GIMPLE_OMP_FOR */
620
621struct GTY((tag("GSS_OMP_FOR")))
622 gomp_for : public gimple_statement_omp
623{
624 /* [ WORD 1-7 ] : base class */
625
626 /* [ WORD 8 ] */
627 tree clauses;
628
629 /* [ WORD 9 ]
630 Number of elements in iter array. */
631 size_t collapse;
632
633 /* [ WORD 10 ] */
634 struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter;
635
636 /* [ WORD 11 ]
637 Pre-body evaluated before the loop body begins. */
638 gimple_seq pre_body;
639};
640
641
642/* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET, GIMPLE_OMP_TASK, GIMPLE_OMP_TEAMS */
643
644struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
645 gimple_statement_omp_parallel_layout : public gimple_statement_omp
646{
647 /* [ WORD 1-7 ] : base class */
648
649 /* [ WORD 8 ]
650 Clauses. */
651 tree clauses;
652
653 /* [ WORD 9 ]
654 Child function holding the body of the parallel region. */
655 tree child_fn;
656
657 /* [ WORD 10 ]
658 Shared data argument. */
659 tree data_arg;
660};
661
662/* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
663struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
664 gimple_statement_omp_taskreg : public gimple_statement_omp_parallel_layout
665{
666 /* No extra fields; adds invariant:
667 stmt->code == GIMPLE_OMP_PARALLEL
668 || stmt->code == GIMPLE_OMP_TASK
669 || stmt->code == GIMPLE_OMP_TEAMS. */
670};
671
672/* GIMPLE_OMP_PARALLEL */
673struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
674 gomp_parallel : public gimple_statement_omp_taskreg
675{
676 /* No extra fields; adds invariant:
677 stmt->code == GIMPLE_OMP_PARALLEL. */
678};
679
680/* GIMPLE_OMP_TARGET */
681struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
682 gomp_target : public gimple_statement_omp_parallel_layout
683{
684 /* No extra fields; adds invariant:
685 stmt->code == GIMPLE_OMP_TARGET. */
686};
687
688/* GIMPLE_OMP_TASK */
689
690struct GTY((tag("GSS_OMP_TASK")))
691 gomp_task : public gimple_statement_omp_taskreg
692{
693 /* [ WORD 1-10 ] : base class */
694
695 /* [ WORD 11 ]
696 Child function holding firstprivate initialization if needed. */
697 tree copy_fn;
698
699 /* [ WORD 12-13 ]
700 Size and alignment in bytes of the argument data block. */
701 tree arg_size;
702 tree arg_align;
703};
704
705
706/* GIMPLE_OMP_SECTION */
707/* Uses struct gimple_statement_omp. */
708
709
710/* GIMPLE_OMP_SECTIONS */
711
712struct GTY((tag("GSS_OMP_SECTIONS")))
713 gomp_sections : public gimple_statement_omp
714{
715 /* [ WORD 1-7 ] : base class */
716
717 /* [ WORD 8 ] */
718 tree clauses;
719
720 /* [ WORD 9 ]
721 The control variable used for deciding which of the sections to
722 execute. */
723 tree control;
724};
725
726/* GIMPLE_OMP_CONTINUE.
727
728 Note: This does not inherit from gimple_statement_omp, because we
729 do not need the body field. */
730
731struct GTY((tag("GSS_OMP_CONTINUE")))
732 gomp_continue : public gimple
733{
734 /* [ WORD 1-6 ] : base class */
735
736 /* [ WORD 7 ] */
737 tree control_def;
738
739 /* [ WORD 8 ] */
740 tree control_use;
741};
742
743/* GIMPLE_OMP_SINGLE, GIMPLE_OMP_ORDERED, GIMPLE_OMP_TASKGROUP,
744 GIMPLE_OMP_SCAN. */
745
746struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
747 gimple_statement_omp_single_layout : public gimple_statement_omp
748{
749 /* [ WORD 1-7 ] : base class */
750
751 /* [ WORD 8 ] */
752 tree clauses;
753};
754
755struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
756 gomp_single : public gimple_statement_omp_single_layout
757{
758 /* No extra fields; adds invariant:
759 stmt->code == GIMPLE_OMP_SINGLE. */
760};
761
762struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
763 gomp_teams : public gimple_statement_omp_taskreg
764{
765 /* No extra fields; adds invariant:
766 stmt->code == GIMPLE_OMP_TEAMS. */
767};
768
769struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
770 gomp_ordered : public gimple_statement_omp_single_layout
771{
772 /* No extra fields; adds invariant:
773 stmt->code == GIMPLE_OMP_ORDERED. */
774};
775
776struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
777 gomp_scan : public gimple_statement_omp_single_layout
778{
779 /* No extra fields; adds invariant:
780 stmt->code == GIMPLE_OMP_SCAN. */
781};
782
783
784/* GIMPLE_OMP_ATOMIC_LOAD.
785 Note: This is based on gimple, not g_s_omp, because g_s_omp
786 contains a sequence, which we don't need here. */
787
788struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
789 gomp_atomic_load : public gimple
790{
791 /* [ WORD 1-6 ] : base class */
792
793 /* [ WORD 7-8 ] */
794 tree rhs, lhs;
795};
796
797/* GIMPLE_OMP_ATOMIC_STORE.
798 See note on GIMPLE_OMP_ATOMIC_LOAD. */
799
800struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
801 gimple_statement_omp_atomic_store_layout : public gimple
802{
803 /* [ WORD 1-6 ] : base class */
804
805 /* [ WORD 7 ] */
806 tree val;
807};
808
809struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
810 gomp_atomic_store :
811 public gimple_statement_omp_atomic_store_layout
812{
813 /* No extra fields; adds invariant:
814 stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
815};
816
817struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
818 gimple_statement_omp_return :
819 public gimple_statement_omp_atomic_store_layout
820{
821 /* No extra fields; adds invariant:
822 stmt->code == GIMPLE_OMP_RETURN. */
823};
824
825/* GIMPLE_TRANSACTION. */
826
827/* Bits to be stored in the GIMPLE_TRANSACTION subcode. */
828
829/* The __transaction_atomic was declared [[outer]] or it is
830 __transaction_relaxed. */
831#define GTMA_IS_OUTER(1u << 0) (1u << 0)
832#define GTMA_IS_RELAXED(1u << 1) (1u << 1)
833#define GTMA_DECLARATION_MASK((1u << 0) | (1u << 1)) (GTMA_IS_OUTER(1u << 0) | GTMA_IS_RELAXED(1u << 1))
834
835/* The transaction is seen to not have an abort. */
836#define GTMA_HAVE_ABORT(1u << 2) (1u << 2)
837/* The transaction is seen to have loads or stores. */
838#define GTMA_HAVE_LOAD(1u << 3) (1u << 3)
839#define GTMA_HAVE_STORE(1u << 4) (1u << 4)
840/* The transaction MAY enter serial irrevocable mode in its dynamic scope. */
841#define GTMA_MAY_ENTER_IRREVOCABLE(1u << 5) (1u << 5)
842/* The transaction WILL enter serial irrevocable mode.
843 An irrevocable block post-dominates the entire transaction, such
844 that all invocations of the transaction will go serial-irrevocable.
845 In such case, we don't bother instrumenting the transaction, and
846 tell the runtime that it should begin the transaction in
847 serial-irrevocable mode. */
848#define GTMA_DOES_GO_IRREVOCABLE(1u << 6) (1u << 6)
849/* The transaction contains no instrumentation code whatsover, most
850 likely because it is guaranteed to go irrevocable upon entry. */
851#define GTMA_HAS_NO_INSTRUMENTATION(1u << 7) (1u << 7)
852
853struct GTY((tag("GSS_TRANSACTION")))
854 gtransaction : public gimple_statement_with_memory_ops_base
855{
856 /* [ WORD 1-9 ] : base class */
857
858 /* [ WORD 10 ] */
859 gimple_seq body;
860
861 /* [ WORD 11-13 ] */
862 tree label_norm;
863 tree label_uninst;
864 tree label_over;
865};
866
867#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM,
868enum gimple_statement_structure_enum {
869#include "gsstruct.def"
870 LAST_GSS_ENUM
871};
872#undef DEFGSSTRUCT
873
874/* A statement with the invariant that
875 stmt->code == GIMPLE_COND
876 i.e. a conditional jump statement. */
877
878struct GTY((tag("GSS_WITH_OPS")))
879 gcond : public gimple_statement_with_ops
880{
881 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
882 static const enum gimple_code code_ = GIMPLE_COND;
883};
884
885/* A statement with the invariant that
886 stmt->code == GIMPLE_DEBUG
887 i.e. a debug statement. */
888
889struct GTY((tag("GSS_WITH_OPS")))
890 gdebug : public gimple_statement_with_ops
891{
892 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
893};
894
895/* A statement with the invariant that
896 stmt->code == GIMPLE_GOTO
897 i.e. a goto statement. */
898
899struct GTY((tag("GSS_WITH_OPS")))
900 ggoto : public gimple_statement_with_ops
901{
902 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
903};
904
905/* A statement with the invariant that
906 stmt->code == GIMPLE_LABEL
907 i.e. a label statement. */
908
909struct GTY((tag("GSS_WITH_OPS")))
910 glabel : public gimple_statement_with_ops
911{
912 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
913};
914
915/* A statement with the invariant that
916 stmt->code == GIMPLE_SWITCH
917 i.e. a switch statement. */
918
919struct GTY((tag("GSS_WITH_OPS")))
920 gswitch : public gimple_statement_with_ops
921{
922 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
923};
924
925/* A statement with the invariant that
926 stmt->code == GIMPLE_ASSIGN
927 i.e. an assignment statement. */
928
929struct GTY((tag("GSS_WITH_MEM_OPS")))
930 gassign : public gimple_statement_with_memory_ops
931{
932 static const enum gimple_code code_ = GIMPLE_ASSIGN;
933 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
934};
935
936/* A statement with the invariant that
937 stmt->code == GIMPLE_RETURN
938 i.e. a return statement. */
939
940struct GTY((tag("GSS_WITH_MEM_OPS")))
941 greturn : public gimple_statement_with_memory_ops
942{
943 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
944};
945
946template <>
947template <>
948inline bool
949is_a_helper <gasm *>::test (gimple *gs)
950{
951 return gs->code == GIMPLE_ASM;
952}
953
954template <>
955template <>
956inline bool
957is_a_helper <gassign *>::test (gimple *gs)
958{
959 return gs->code == GIMPLE_ASSIGN;
960}
961
962template <>
963template <>
964inline bool
965is_a_helper <const gassign *>::test (const gimple *gs)
966{
967 return gs->code == GIMPLE_ASSIGN;
968}
969
970template <>
971template <>
972inline bool
973is_a_helper <gbind *>::test (gimple *gs)
974{
975 return gs->code == GIMPLE_BIND;
976}
977
978template <>
979template <>
980inline bool
981is_a_helper <gcall *>::test (gimple *gs)
982{
983 return gs->code == GIMPLE_CALL;
984}
985
986template <>
987template <>
988inline bool
989is_a_helper <gcatch *>::test (gimple *gs)
990{
991 return gs->code == GIMPLE_CATCH;
992}
993
994template <>
995template <>
996inline bool
997is_a_helper <gcond *>::test (gimple *gs)
998{
999 return gs->code == GIMPLE_COND;
1000}
1001
1002template <>
1003template <>
1004inline bool
1005is_a_helper <const gcond *>::test (const gimple *gs)
1006{
1007 return gs->code == GIMPLE_COND;
1008}
1009
1010template <>
1011template <>
1012inline bool
1013is_a_helper <gdebug *>::test (gimple *gs)
1014{
1015 return gs->code == GIMPLE_DEBUG;
1016}
1017
1018template <>
1019template <>
1020inline bool
1021is_a_helper <const gdebug *>::test (const gimple *gs)
1022{
1023 return gs->code == GIMPLE_DEBUG;
1024}
1025
1026template <>
1027template <>
1028inline bool
1029is_a_helper <ggoto *>::test (gimple *gs)
1030{
1031 return gs->code == GIMPLE_GOTO;
1032}
1033
1034template <>
1035template <>
1036inline bool
1037is_a_helper <const ggoto *>::test (const gimple *gs)
1038{
1039 return gs->code == GIMPLE_GOTO;
1040}
1041
1042template <>
1043template <>
1044inline bool
1045is_a_helper <glabel *>::test (gimple *gs)
1046{
1047 return gs->code == GIMPLE_LABEL;
1048}
1049
1050template <>
1051template <>
1052inline bool
1053is_a_helper <const glabel *>::test (const gimple *gs)
1054{
1055 return gs->code == GIMPLE_LABEL;
1056}
1057
1058template <>
1059template <>
1060inline bool
1061is_a_helper <gresx *>::test (gimple *gs)
1062{
1063 return gs->code == GIMPLE_RESX;
1064}
1065
1066template <>
1067template <>
1068inline bool
1069is_a_helper <geh_dispatch *>::test (gimple *gs)
1070{
1071 return gs->code == GIMPLE_EH_DISPATCH;
1072}
1073
1074template <>
1075template <>
1076inline bool
1077is_a_helper <geh_else *>::test (gimple *gs)
1078{
1079 return gs->code == GIMPLE_EH_ELSE;
1080}
1081
1082template <>
1083template <>
1084inline bool
1085is_a_helper <const geh_else *>::test (const gimple *gs)
1086{
1087 return gs->code == GIMPLE_EH_ELSE;
1088}
1089
1090template <>
1091template <>
1092inline bool
1093is_a_helper <geh_filter *>::test (gimple *gs)
1094{
1095 return gs->code == GIMPLE_EH_FILTER;
1096}
1097
1098template <>
1099template <>
1100inline bool
1101is_a_helper <geh_mnt *>::test (gimple *gs)
1102{
1103 return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1104}
1105
1106template <>
1107template <>
1108inline bool
1109is_a_helper <const geh_mnt *>::test (const gimple *gs)
1110{
1111 return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1112}
1113
1114template <>
1115template <>
1116inline bool
1117is_a_helper <gomp_atomic_load *>::test (gimple *gs)
1118{
1119 return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1120}
1121
1122template <>
1123template <>
1124inline bool
1125is_a_helper <gomp_atomic_store *>::test (gimple *gs)
1126{
1127 return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1128}
1129
1130template <>
1131template <>
1132inline bool
1133is_a_helper <gimple_statement_omp_return *>::test (gimple *gs)
1134{
1135 return gs->code == GIMPLE_OMP_RETURN;
1136}
1137
1138template <>
1139template <>
1140inline bool
1141is_a_helper <gomp_continue *>::test (gimple *gs)
1142{
1143 return gs->code == GIMPLE_OMP_CONTINUE;
1144}
1145
1146template <>
1147template <>
1148inline bool
1149is_a_helper <gomp_critical *>::test (gimple *gs)
1150{
1151 return gs->code == GIMPLE_OMP_CRITICAL;
1152}
1153
1154template <>
1155template <>
1156inline bool
1157is_a_helper <gomp_ordered *>::test (gimple *gs)
1158{
1159 return gs->code == GIMPLE_OMP_ORDERED;
1160}
1161
1162template <>
1163template <>
1164inline bool
1165is_a_helper <gomp_scan *>::test (gimple *gs)
1166{
1167 return gs->code == GIMPLE_OMP_SCAN;
1168}
1169
1170template <>
1171template <>
1172inline bool
1173is_a_helper <gomp_for *>::test (gimple *gs)
1174{
1175 return gs->code == GIMPLE_OMP_FOR;
1176}
1177
1178template <>
1179template <>
1180inline bool
1181is_a_helper <gimple_statement_omp_taskreg *>::test (gimple *gs)
1182{
1183 return (gs->code == GIMPLE_OMP_PARALLEL
1184 || gs->code == GIMPLE_OMP_TASK
1185 || gs->code == GIMPLE_OMP_TEAMS);
1186}
1187
1188template <>
1189template <>
1190inline bool
1191is_a_helper <gomp_parallel *>::test (gimple *gs)
1192{
1193 return gs->code == GIMPLE_OMP_PARALLEL;
1194}
1195
1196template <>
1197template <>
1198inline bool
1199is_a_helper <gomp_target *>::test (gimple *gs)
1200{
1201 return gs->code == GIMPLE_OMP_TARGET;
1202}
1203
1204template <>
1205template <>
1206inline bool
1207is_a_helper <gomp_sections *>::test (gimple *gs)
1208{
1209 return gs->code == GIMPLE_OMP_SECTIONS;
1210}
1211
1212template <>
1213template <>
1214inline bool
1215is_a_helper <gomp_single *>::test (gimple *gs)
1216{
1217 return gs->code == GIMPLE_OMP_SINGLE;
1218}
1219
1220template <>
1221template <>
1222inline bool
1223is_a_helper <gomp_teams *>::test (gimple *gs)
1224{
1225 return gs->code == GIMPLE_OMP_TEAMS;
1226}
1227
1228template <>
1229template <>
1230inline bool
1231is_a_helper <gomp_task *>::test (gimple *gs)
1232{
1233 return gs->code == GIMPLE_OMP_TASK;
1234}
1235
1236template <>
1237template <>
1238inline bool
1239is_a_helper <gphi *>::test (gimple *gs)
1240{
1241 return gs->code == GIMPLE_PHI;
1242}
1243
1244template <>
1245template <>
1246inline bool
1247is_a_helper <greturn *>::test (gimple *gs)
1248{
1249 return gs->code == GIMPLE_RETURN;
1250}
1251
1252template <>
1253template <>
1254inline bool
1255is_a_helper <gswitch *>::test (gimple *gs)
1256{
1257 return gs->code == GIMPLE_SWITCH;
1258}
1259
1260template <>
1261template <>
1262inline bool
1263is_a_helper <const gswitch *>::test (const gimple *gs)
1264{
1265 return gs->code == GIMPLE_SWITCH;
1266}
1267
1268template <>
1269template <>
1270inline bool
1271is_a_helper <gtransaction *>::test (gimple *gs)
1272{
1273 return gs->code == GIMPLE_TRANSACTION;
1274}
1275
1276template <>
1277template <>
1278inline bool
1279is_a_helper <gtry *>::test (gimple *gs)
1280{
1281 return gs->code == GIMPLE_TRY;
1282}
1283
1284template <>
1285template <>
1286inline bool
1287is_a_helper <const gtry *>::test (const gimple *gs)
1288{
1289 return gs->code == GIMPLE_TRY;
1290}
1291
1292template <>
1293template <>
1294inline bool
1295is_a_helper <gimple_statement_wce *>::test (gimple *gs)
1296{
1297 return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
1298}
1299
1300template <>
1301template <>
1302inline bool
1303is_a_helper <const gasm *>::test (const gimple *gs)
1304{
1305 return gs->code == GIMPLE_ASM;
1306}
1307
1308template <>
1309template <>
1310inline bool
1311is_a_helper <const gbind *>::test (const gimple *gs)
1312{
1313 return gs->code == GIMPLE_BIND;
1314}
1315
1316template <>
1317template <>
1318inline bool
1319is_a_helper <const gcall *>::test (const gimple *gs)
1320{
1321 return gs->code == GIMPLE_CALL;
1322}
1323
1324template <>
1325template <>
1326inline bool
1327is_a_helper <const gcatch *>::test (const gimple *gs)
1328{
1329 return gs->code == GIMPLE_CATCH;
1330}
1331
1332template <>
1333template <>
1334inline bool
1335is_a_helper <const gresx *>::test (const gimple *gs)
1336{
1337 return gs->code == GIMPLE_RESX;
1338}
1339
1340template <>
1341template <>
1342inline bool
1343is_a_helper <const geh_dispatch *>::test (const gimple *gs)
1344{
1345 return gs->code == GIMPLE_EH_DISPATCH;
1346}
1347
1348template <>
1349template <>
1350inline bool
1351is_a_helper <const geh_filter *>::test (const gimple *gs)
1352{
1353 return gs->code == GIMPLE_EH_FILTER;
1354}
1355
1356template <>
1357template <>
1358inline bool
1359is_a_helper <const gomp_atomic_load *>::test (const gimple *gs)
1360{
1361 return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1362}
1363
1364template <>
1365template <>
1366inline bool
1367is_a_helper <const gomp_atomic_store *>::test (const gimple *gs)
1368{
1369 return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1370}
1371
1372template <>
1373template <>
1374inline bool
1375is_a_helper <const gimple_statement_omp_return *>::test (const gimple *gs)
1376{
1377 return gs->code == GIMPLE_OMP_RETURN;
1378}
1379
1380template <>
1381template <>
1382inline bool
1383is_a_helper <const gomp_continue *>::test (const gimple *gs)
1384{
1385 return gs->code == GIMPLE_OMP_CONTINUE;
1386}
1387
1388template <>
1389template <>
1390inline bool
1391is_a_helper <const gomp_critical *>::test (const gimple *gs)
1392{
1393 return gs->code == GIMPLE_OMP_CRITICAL;
1394}
1395
1396template <>
1397template <>
1398inline bool
1399is_a_helper <const gomp_ordered *>::test (const gimple *gs)
1400{
1401 return gs->code == GIMPLE_OMP_ORDERED;
1402}
1403
1404template <>
1405template <>
1406inline bool
1407is_a_helper <const gomp_scan *>::test (const gimple *gs)
1408{
1409 return gs->code == GIMPLE_OMP_SCAN;
1410}
1411
1412template <>
1413template <>
1414inline bool
1415is_a_helper <const gomp_for *>::test (const gimple *gs)
1416{
1417 return gs->code == GIMPLE_OMP_FOR;
1418}
1419
1420template <>
1421template <>
1422inline bool
1423is_a_helper <const gimple_statement_omp_taskreg *>::test (const gimple *gs)
1424{
1425 return (gs->code == GIMPLE_OMP_PARALLEL
1426 || gs->code == GIMPLE_OMP_TASK
1427 || gs->code == GIMPLE_OMP_TEAMS);
1428}
1429
1430template <>
1431template <>
1432inline bool
1433is_a_helper <const gomp_parallel *>::test (const gimple *gs)
1434{
1435 return gs->code == GIMPLE_OMP_PARALLEL;
1436}
1437
1438template <>
1439template <>
1440inline bool
1441is_a_helper <const gomp_target *>::test (const gimple *gs)
1442{
1443 return gs->code == GIMPLE_OMP_TARGET;
1444}
1445
1446template <>
1447template <>
1448inline bool
1449is_a_helper <const gomp_sections *>::test (const gimple *gs)
1450{
1451 return gs->code == GIMPLE_OMP_SECTIONS;
1452}
1453
1454template <>
1455template <>
1456inline bool
1457is_a_helper <const gomp_single *>::test (const gimple *gs)
1458{
1459 return gs->code == GIMPLE_OMP_SINGLE;
1460}
1461
1462template <>
1463template <>
1464inline bool
1465is_a_helper <const gomp_teams *>::test (const gimple *gs)
1466{
1467 return gs->code == GIMPLE_OMP_TEAMS;
1468}
1469
1470template <>
1471template <>
1472inline bool
1473is_a_helper <const gomp_task *>::test (const gimple *gs)
1474{
1475 return gs->code == GIMPLE_OMP_TASK;
1476}
1477
1478template <>
1479template <>
1480inline bool
1481is_a_helper <const gphi *>::test (const gimple *gs)
1482{
1483 return gs->code == GIMPLE_PHI;
1484}
1485
1486template <>
1487template <>
1488inline bool
1489is_a_helper <const greturn *>::test (const gimple *gs)
1490{
1491 return gs->code == GIMPLE_RETURN;
1492}
1493
1494template <>
1495template <>
1496inline bool
1497is_a_helper <const gtransaction *>::test (const gimple *gs)
1498{
1499 return gs->code == GIMPLE_TRANSACTION;
1500}
1501
1502/* Offset in bytes to the location of the operand vector.
1503 Zero if there is no operand vector for this tuple structure. */
1504extern size_t const gimple_ops_offset_[];
1505
1506/* Map GIMPLE codes to GSS codes. */
1507extern enum gimple_statement_structure_enum const gss_for_code_[];
1508
1509/* This variable holds the currently expanded gimple statement for purposes
1510 of comminucating the profile info to the builtin expanders. */
1511extern gimple *currently_expanding_gimple_stmt;
1512
1513size_t gimple_size (enum gimple_code code, unsigned num_ops = 0);
1514void gimple_init (gimple *g, enum gimple_code code, unsigned num_ops);
1515gimple *gimple_alloc (enum gimple_code, unsigned CXX_MEM_STAT_INFO);
1516greturn *gimple_build_return (tree);
1517void gimple_call_reset_alias_info (gcall *);
1518gcall *gimple_build_call_vec (tree, vec<tree> );
1519gcall *gimple_build_call (tree, unsigned, ...);
1520gcall *gimple_build_call_valist (tree, unsigned, va_list);
1521gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...);
1522gcall *gimple_build_call_internal_vec (enum internal_fn, vec<tree> );
1523gcall *gimple_build_call_from_tree (tree, tree);
1524gassign *gimple_build_assign (tree, tree CXX_MEM_STAT_INFO);
1525gassign *gimple_build_assign (tree, enum tree_code,
1526 tree, tree, tree CXX_MEM_STAT_INFO);
1527gassign *gimple_build_assign (tree, enum tree_code,
1528 tree, tree CXX_MEM_STAT_INFO);
1529gassign *gimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO);
1530gcond *gimple_build_cond (enum tree_code, tree, tree, tree, tree);
1531gcond *gimple_build_cond_from_tree (tree, tree, tree);
1532void gimple_cond_set_condition_from_tree (gcond *, tree);
1533glabel *gimple_build_label (tree label);
1534ggoto *gimple_build_goto (tree dest);
1535gimple *gimple_build_nop (void);
1536gbind *gimple_build_bind (tree, gimple_seq, tree);
1537gasm *gimple_build_asm_vec (const char *, vec<tree, va_gc> *,
1538 vec<tree, va_gc> *, vec<tree, va_gc> *,
1539 vec<tree, va_gc> *);
1540gcatch *gimple_build_catch (tree, gimple_seq);
1541geh_filter *gimple_build_eh_filter (tree, gimple_seq);
1542geh_mnt *gimple_build_eh_must_not_throw (tree);
1543geh_else *gimple_build_eh_else (gimple_seq, gimple_seq);
1544gtry *gimple_build_try (gimple_seq, gimple_seq,
1545 enum gimple_try_flags);
1546gimple *gimple_build_wce (gimple_seq);
1547gresx *gimple_build_resx (int);
1548gswitch *gimple_build_switch_nlabels (unsigned, tree, tree);
1549gswitch *gimple_build_switch (tree, tree, vec<tree> );
1550geh_dispatch *gimple_build_eh_dispatch (int);
1551gdebug *gimple_build_debug_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
1552gdebug *gimple_build_debug_source_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
1553gdebug *gimple_build_debug_begin_stmt (tree, location_t CXX_MEM_STAT_INFO);
1554gdebug *gimple_build_debug_inline_entry (tree, location_t CXX_MEM_STAT_INFO);
1555gomp_critical *gimple_build_omp_critical (gimple_seq, tree, tree);
1556gomp_for *gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq);
1557gomp_parallel *gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
1558gomp_task *gimple_build_omp_task (gimple_seq, tree, tree, tree, tree,
1559 tree, tree);
1560gimple *gimple_build_omp_section (gimple_seq);
1561gimple *gimple_build_omp_master (gimple_seq);
1562gimple *gimple_build_omp_taskgroup (gimple_seq, tree);
1563gomp_continue *gimple_build_omp_continue (tree, tree);
1564gomp_ordered *gimple_build_omp_ordered (gimple_seq, tree);
1565gimple *gimple_build_omp_return (bool);
1566gomp_scan *gimple_build_omp_scan (gimple_seq, tree);
1567gomp_sections *gimple_build_omp_sections (gimple_seq, tree);
1568gimple *gimple_build_omp_sections_switch (void);
1569gomp_single *gimple_build_omp_single (gimple_seq, tree);
1570gomp_target *gimple_build_omp_target (gimple_seq, int, tree);
1571gomp_teams *gimple_build_omp_teams (gimple_seq, tree);
1572gomp_atomic_load *gimple_build_omp_atomic_load (tree, tree,
1573 enum omp_memory_order);
1574gomp_atomic_store *gimple_build_omp_atomic_store (tree, enum omp_memory_order);
1575gtransaction *gimple_build_transaction (gimple_seq);
1576extern void gimple_seq_add_stmt (gimple_seq *, gimple *);
1577extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple *);
1578void gimple_seq_add_seq (gimple_seq *, gimple_seq);
1579void gimple_seq_add_seq_without_update (gimple_seq *, gimple_seq);
1580extern void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator,
1581 location_t);
1582extern void annotate_all_with_location (gimple_seq, location_t);
1583bool empty_body_p (gimple_seq);
1584gimple_seq gimple_seq_copy (gimple_seq);
1585bool gimple_call_same_target_p (const gimple *, const gimple *);
1586int gimple_call_flags (const gimple *);
1587int gimple_call_arg_flags (const gcall *, unsigned);
1588int gimple_call_return_flags (const gcall *);
1589bool gimple_call_nonnull_result_p (gcall *);
1590tree gimple_call_nonnull_arg (gcall *);
1591bool gimple_assign_copy_p (gimple *);
1592bool gimple_assign_ssa_name_copy_p (gimple *);
1593bool gimple_assign_unary_nop_p (gimple *);
1594void gimple_set_bb (gimple *, basic_block);
1595void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
1596void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
1597 tree, tree, tree);
1598tree gimple_get_lhs (const gimple *);
1599void gimple_set_lhs (gimple *, tree);
1600gimple *gimple_copy (gimple *);
1601void gimple_move_vops (gimple *, gimple *);
1602bool gimple_has_side_effects (const gimple *);
1603bool gimple_could_trap_p_1 (gimple *, bool, bool);
1604bool gimple_could_trap_p (gimple *);
1605bool gimple_assign_rhs_could_trap_p (gimple *);
1606extern void dump_gimple_statistics (void);
1607unsigned get_gimple_rhs_num_ops (enum tree_code);
1608extern tree canonicalize_cond_expr_cond (tree);
1609gcall *gimple_call_copy_skip_args (gcall *, bitmap);
1610extern bool gimple_compare_field_offset (tree, tree);
1611extern tree gimple_unsigned_type (tree);
1612extern tree gimple_signed_type (tree);
1613extern alias_set_type gimple_get_alias_set (tree);
1614extern bool gimple_ior_addresses_taken (bitmap, gimple *);
1615extern bool gimple_builtin_call_types_compatible_p (const gimple *, tree);
1616extern combined_fn gimple_call_combined_fn (const gimple *);
1617extern bool gimple_call_operator_delete_p (const gcall *);
1618extern bool gimple_call_builtin_p (const gimple *);
1619extern bool gimple_call_builtin_p (const gimple *, enum built_in_class);
1620extern bool gimple_call_builtin_p (const gimple *, enum built_in_function);
1621extern bool gimple_asm_clobbers_memory_p (const gasm *);
1622extern void dump_decl_set (FILE *, bitmap);
1623extern bool nonfreeing_call_p (gimple *);
1624extern bool nonbarrier_call_p (gimple *);
1625extern bool infer_nonnull_range (gimple *, tree);
1626extern bool infer_nonnull_range_by_dereference (gimple *, tree);
1627extern bool infer_nonnull_range_by_attribute (gimple *, tree);
1628extern void sort_case_labels (vec<tree>);
1629extern void preprocess_case_label_vec_for_gimple (vec<tree>, tree, tree *);
1630extern void gimple_seq_set_location (gimple_seq, location_t);
1631extern void gimple_seq_discard (gimple_seq);
1632extern void maybe_remove_unused_call_args (struct function *, gimple *);
1633extern bool gimple_inexpensive_call_p (gcall *);
1634extern bool stmt_can_terminate_bb_p (gimple *);
1635extern location_t gimple_or_expr_nonartificial_location (gimple *, tree);
1636
1637
1638/* Formal (expression) temporary table handling: multiple occurrences of
1639 the same scalar expression are evaluated into the same temporary. */
1640
1641typedef struct gimple_temp_hash_elt
1642{
1643 tree val; /* Key */
1644 tree temp; /* Value */
1645} elt_t;
1646
1647/* Get the number of the next statement uid to be allocated. */
1648static inline unsigned int
1649gimple_stmt_max_uid (struct function *fn)
1650{
1651 return fn->last_stmt_uid;
1652}
1653
1654/* Set the number of the next statement uid to be allocated. */
1655static inline void
1656set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
1657{
1658 fn->last_stmt_uid = maxid;
1659}
1660
1661/* Set the number of the next statement uid to be allocated. */
1662static inline unsigned int
1663inc_gimple_stmt_max_uid (struct function *fn)
1664{
1665 return fn->last_stmt_uid++;
1666}
1667
1668/* Return the first node in GIMPLE sequence S. */
1669
1670static inline gimple_seq_node
1671gimple_seq_first (gimple_seq s)
1672{
1673 return s;
1674}
1675
1676
1677/* Return the first statement in GIMPLE sequence S. */
1678
1679static inline gimple *
1680gimple_seq_first_stmt (gimple_seq s)
1681{
1682 gimple_seq_node n = gimple_seq_first (s);
1683 return n;
1684}
1685
1686/* Return the first statement in GIMPLE sequence S as a gbind *,
1687 verifying that it has code GIMPLE_BIND in a checked build. */
1688
1689static inline gbind *
1690gimple_seq_first_stmt_as_a_bind (gimple_seq s)
1691{
1692 gimple_seq_node n = gimple_seq_first (s);
1693 return as_a <gbind *> (n);
1694}
1695
1696
1697/* Return the last node in GIMPLE sequence S. */
1698
1699static inline gimple_seq_node
1700gimple_seq_last (gimple_seq s)
1701{
1702 return s ? s->prev : NULL__null;
1703}
1704
1705
1706/* Return the last statement in GIMPLE sequence S. */
1707
1708static inline gimple *
1709gimple_seq_last_stmt (gimple_seq s)
1710{
1711 gimple_seq_node n = gimple_seq_last (s);
1712 return n;
1713}
1714
1715
1716/* Set the last node in GIMPLE sequence *PS to LAST. */
1717
1718static inline void
1719gimple_seq_set_last (gimple_seq *ps, gimple_seq_node last)
1720{
1721 (*ps)->prev = last;
1722}
1723
1724
1725/* Set the first node in GIMPLE sequence *PS to FIRST. */
1726
1727static inline void
1728gimple_seq_set_first (gimple_seq *ps, gimple_seq_node first)
1729{
1730 *ps = first;
1731}
1732
1733
1734/* Return true if GIMPLE sequence S is empty. */
1735
1736static inline bool
1737gimple_seq_empty_p (gimple_seq s)
1738{
1739 return s == NULL__null;
1740}
1741
1742/* Allocate a new sequence and initialize its first element with STMT. */
1743
1744static inline gimple_seq
1745gimple_seq_alloc_with_stmt (gimple *stmt)
1746{
1747 gimple_seq seq = NULL__null;
1748 gimple_seq_add_stmt (&seq, stmt);
1749 return seq;
1750}
1751
1752
1753/* Returns the sequence of statements in BB. */
1754
1755static inline gimple_seq
1756bb_seq (const_basic_block bb)
1757{
1758 return (!(bb->flags & BB_RTL)) ? bb->il.gimple.seq : NULL__null;
1759}
1760
1761static inline gimple_seq *
1762bb_seq_addr (basic_block bb)
1763{
1764 return (!(bb->flags & BB_RTL)) ? &bb->il.gimple.seq : NULL__null;
1765}
1766
1767/* Sets the sequence of statements in BB to SEQ. */
1768
1769static inline void
1770set_bb_seq (basic_block bb, gimple_seq seq)
1771{
1772 gcc_checking_assert (!(bb->flags & BB_RTL))((void)(!(!(bb->flags & BB_RTL)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h"
, 1772, __FUNCTION__), 0 : 0))
;
1773 bb->il.gimple.seq = seq;
1774}
1775
1776
1777/* Return the code for GIMPLE statement G. */
1778
1779static inline enum gimple_code
1780gimple_code (const gimple *g)
1781{
1782 return g->code;
1783}
1784
1785
1786/* Return the GSS code used by a GIMPLE code. */
1787
1788static inline enum gimple_statement_structure_enum
1789gss_for_code (enum gimple_code code)
1790{
1791 gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE)((void)(!((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h"
, 1791, __FUNCTION__), 0 : 0))
;
1792 return gss_for_code_[code];
1793}
1794
1795
1796/* Return which GSS code is used by GS. */
1797
1798static inline enum gimple_statement_structure_enum
1799gimple_statement_structure (gimple *gs)
1800{
1801 return gss_for_code (gimple_code (gs));
1802}
1803
1804
1805/* Return true if statement G has sub-statements. This is only true for
1806 High GIMPLE statements. */
1807
1808static inline bool
1809gimple_has_substatements (gimple *g)
1810{
1811 switch (gimple_code (g))
1812 {
1813 case GIMPLE_BIND:
1814 case GIMPLE_CATCH:
1815 case GIMPLE_EH_FILTER:
1816 case GIMPLE_EH_ELSE:
1817 case GIMPLE_TRY:
1818 case GIMPLE_OMP_FOR:
1819 case GIMPLE_OMP_MASTER:
1820 case GIMPLE_OMP_TASKGROUP:
1821 case GIMPLE_OMP_ORDERED:
1822 case GIMPLE_OMP_SECTION:
1823 case GIMPLE_OMP_PARALLEL:
1824 case GIMPLE_OMP_TASK:
1825 case GIMPLE_OMP_SECTIONS:
1826 case GIMPLE_OMP_SINGLE:
1827 case GIMPLE_OMP_TARGET:
1828 case GIMPLE_OMP_TEAMS:
1829 case GIMPLE_OMP_CRITICAL:
1830 case GIMPLE_WITH_CLEANUP_EXPR:
1831 case GIMPLE_TRANSACTION:
1832 return true;
1833
1834 default:
1835 return false;
1836 }
1837}
1838
1839
1840/* Return the basic block holding statement G. */
1841
1842static inline basic_block
1843gimple_bb (const gimple *g)
1844{
1845 return g->bb;
1846}
1847
1848
1849/* Return the lexical scope block holding statement G. */
1850
1851static inline tree
1852gimple_block (const gimple *g)
1853{
1854 return LOCATION_BLOCK (g->location)((tree) ((IS_ADHOC_LOC (g->location)) ? get_data_from_adhoc_loc
(line_table, (g->location)) : __null))
;
1855}
1856
1857
1858/* Set BLOCK to be the lexical scope block holding statement G. */
1859
1860static inline void
1861gimple_set_block (gimple *g, tree block)
1862{
1863 g->location = set_block (g->location, block);
1864}
1865
1866
1867/* Return location information for statement G. */
1868
1869static inline location_t
1870gimple_location (const gimple *g)
1871{
1872 return g->location;
1873}
1874
1875/* Return location information for statement G if g is not NULL.
1876 Otherwise, UNKNOWN_LOCATION is returned. */
1877
1878static inline location_t
1879gimple_location_safe (const gimple *g)
1880{
1881 return g ? gimple_location (g) : UNKNOWN_LOCATION((location_t) 0);
1882}
1883
1884/* Set location information for statement G. */
1885
1886static inline void
1887gimple_set_location (gimple *g, location_t location)
1888{
1889 g->location = location;
1890}
1891
1892/* Return address of the location information for statement G. */
1893
1894static inline location_t *
1895gimple_location_ptr (gimple *g)
1896{
1897 return &g->location;
1898}
1899
1900
1901/* Return true if G contains location information. */
1902
1903static inline bool
1904gimple_has_location (const gimple *g)
1905{
1906 return LOCATION_LOCUS (gimple_location (g))((IS_ADHOC_LOC (gimple_location (g))) ? get_location_from_adhoc_loc
(line_table, gimple_location (g)) : (gimple_location (g)))
!= UNKNOWN_LOCATION((location_t) 0);
1907}
1908
1909
1910/* Return non-artificial location information for statement G. */
1911
1912static inline location_t
1913gimple_nonartificial_location (const gimple *g)
1914{
1915 location_t *ploc = NULL__null;
1916
1917 if (tree block = gimple_block (g))
1918 ploc = block_nonartificial_location (block);
1919
1920 return ploc ? *ploc : gimple_location (g);
1921}
1922
1923
1924/* Return the file name of the location of STMT. */
1925
1926static inline const char *
1927gimple_filename (const gimple *stmt)
1928{
1929 return LOCATION_FILE (gimple_location (stmt))((expand_location (gimple_location (stmt))).file);
1930}
1931
1932
1933/* Return the line number of the location of STMT. */
1934
1935static inline int
1936gimple_lineno (const gimple *stmt)
1937{
1938 return LOCATION_LINE (gimple_location (stmt))((expand_location (gimple_location (stmt))).line);
1939}
1940
1941
1942/* Determine whether SEQ is a singleton. */
1943
1944static inline bool
1945gimple_seq_singleton_p (gimple_seq seq)
1946{
1947 return ((gimple_seq_first (seq) != NULL__null)
1948 && (gimple_seq_first (seq) == gimple_seq_last (seq)));
1949}
1950
1951/* Return true if no warnings should be emitted for statement STMT. */
1952
1953static inline bool
1954gimple_no_warning_p (const gimple *stmt)
1955{
1956 return stmt->no_warning;
1957}
1958
1959/* Set the no_warning flag of STMT to NO_WARNING. */
1960
1961static inline void
1962gimple_set_no_warning (gimple *stmt, bool no_warning)
1963{
1964 stmt->no_warning = (unsigned) no_warning;
1965}
1966
1967/* Set the visited status on statement STMT to VISITED_P.
1968
1969 Please note that this 'visited' property of the gimple statement is
1970 supposed to be undefined at pass boundaries. This means that a
1971 given pass should not assume it contains any useful value when the
1972 pass starts and thus can set it to any value it sees fit.
1973
1974 You can learn more about the visited property of the gimple
1975 statement by reading the comments of the 'visited' data member of
1976 struct gimple.
1977 */
1978
1979static inline void
1980gimple_set_visited (gimple *stmt, bool visited_p)
1981{
1982 stmt->visited = (unsigned) visited_p;
1983}
1984
1985
1986/* Return the visited status for statement STMT.
1987
1988 Please note that this 'visited' property of the gimple statement is
1989 supposed to be undefined at pass boundaries. This means that a
1990 given pass should not assume it contains any useful value when the
1991 pass starts and thus can set it to any value it sees fit.
1992
1993 You can learn more about the visited property of the gimple
1994 statement by reading the comments of the 'visited' data member of
1995 struct gimple. */
1996
1997static inline bool
1998gimple_visited_p (gimple *stmt)
1999{
2000 return stmt->visited;
2001}
2002
2003
2004/* Set pass local flag PLF on statement STMT to VAL_P.
2005
2006 Please note that this PLF property of the gimple statement is
2007 supposed to be undefined at pass boundaries. This means that a
2008 given pass should not assume it contains any useful value when the
2009 pass starts and thus can set it to any value it sees fit.
2010
2011 You can learn more about the PLF property by reading the comment of
2012 the 'plf' data member of struct gimple_statement_structure. */
2013
2014static inline void
2015gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
2016{
2017 if (val_p)
2018 stmt->plf |= (unsigned int) plf;
2019 else
2020 stmt->plf &= ~((unsigned int) plf);
2021}
2022
2023
2024/* Return the value of pass local flag PLF on statement STMT.
2025
2026 Please note that this 'plf' property of the gimple statement is
2027 supposed to be undefined at pass boundaries. This means that a
2028 given pass should not assume it contains any useful value when the
2029 pass starts and thus can set it to any value it sees fit.
2030
2031 You can learn more about the plf property by reading the comment of
2032 the 'plf' data member of struct gimple_statement_structure. */
2033
2034static inline unsigned int
2035gimple_plf (gimple *stmt, enum plf_mask plf)
2036{
2037 return stmt->plf & ((unsigned int) plf);
2038}
2039
2040
2041/* Set the UID of statement.
2042
2043 Please note that this UID property is supposed to be undefined at
2044 pass boundaries. This means that a given pass should not assume it
2045 contains any useful value when the pass starts and thus can set it
2046 to any value it sees fit. */
2047
2048static inline void
2049gimple_set_uid (gimple *g, unsigned uid)
2050{
2051 g->uid = uid;
2052}
2053
2054
2055/* Return the UID of statement.
2056
2057 Please note that this UID property is supposed to be undefined at
2058 pass boundaries. This means that a given pass should not assume it
2059 contains any useful value when the pa