/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc

Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name cgraph.cc -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 -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/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 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-VXRHyk.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc

→

1/* Callgraph handling code.
 Copyright (C) 2003-2023 Free Software Foundation, Inc.
 Contributed by Jan Hubicka

5This file is part of GCC.

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.

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.

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/>.  */

21/*  This file contains basic routines manipulating call graph

  The call-graph is a data structure designed for inter-procedural
  optimization.  It represents a multi-graph where nodes are functions
  (symbols within symbol table) and edges are call sites. */

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"

71/* FIXME: Only for PROP_loops, but cgraph shouldn't have to know about this.  */
72#include "tree-pass.h"

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)

78/* Symbol table global context.  */
79symbol_table *symtab;

81/* List of hooks triggered on cgraph_edge events.  */
82struct cgraph_edge_hook_list {
cgraph_edge_hook hook;
void *data;
struct cgraph_edge_hook_list *next;
86};

88/* List of hooks triggered on cgraph_node events.  */
89struct cgraph_node_hook_list {
cgraph_node_hook hook;
void *data;
struct cgraph_node_hook_list *next;
93};

95/* List of hooks triggered on events involving two cgraph_edges.  */
96struct cgraph_2edge_hook_list {
cgraph_2edge_hook hook;
void *data;
struct cgraph_2edge_hook_list *next;
100};

102/* List of hooks triggered on events involving two cgraph_nodes.  */
103struct cgraph_2node_hook_list {
cgraph_2node_hook hook;
void *data;
struct cgraph_2node_hook_list *next;
107};

109/* Hash descriptor for cgraph_function_version_info.  */

111struct function_version_hasher : ggc_ptr_hash<cgraph_function_version_info>
112{
static hashval_t hash (cgraph_function_version_info *);
static bool equal (cgraph_function_version_info *,
     cgraph_function_version_info *);
116};

118/* Map a cgraph_node to cgraph_function_version_info using this htab.
 The cgraph_function_version_info has a THIS_NODE field that is the
 corresponding cgraph_node..  */

122static GTY(()) hash_table<function_version_hasher> *cgraph_fnver_htab = NULL__null;

124/* Hash function for cgraph_fnver_htab.  */
125hashval_t
126function_version_hasher::hash (cgraph_function_version_info *ptr)
127{
int uid = ptr->this_node->get_uid ();
return (hashval_t)(uid);
130}

132/* eq function for cgraph_fnver_htab.  */
133bool
134function_version_hasher::equal (cgraph_function_version_info *n1,
	       	cgraph_function_version_info *n2)
136{
return n1->this_node->get_uid () == n2->this_node->get_uid ();
138}

140/* Mark as GC root all allocated nodes.  */
141static GTY(()) struct cgraph_function_version_info *
version_info_node = NULL__null;

144/* Return true if NODE's address can be compared.  */

146bool
147symtab_node::address_can_be_compared_p ()
148{
/* Address of virtual tables and functions is never compared.  */
if (DECL_VIRTUAL_P (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 150, __FUNCTION__))->decl_common.virtual_flag))
  return false;
/* Address of C++ cdtors is never compared.  */
if (is_a <cgraph_node *> (this)
    && (DECL_CXX_CONSTRUCTOR_P (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 154, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)
 || DECL_CXX_DESTRUCTOR_P (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 155, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_destructor
)))
  return false;
/* Constant pool symbols addresses are never compared.
   flag_merge_constants permits us to assume the same on readonly vars.  */
if (is_a <varpool_node *> (this)
    && (DECL_IN_CONSTANT_POOL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 160, __FUNCTION__, (VAR_DECL)))->decl_with_vis.in_constant_pool
)
 || (flag_merge_constantsglobal_options.x_flag_merge_constants >= 2
     && TREE_READONLY (decl)((non_type_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 162, __FUNCTION__))->base.readonly_flag) && !TREE_THIS_VOLATILE (decl)((decl)->base.volatile_flag))))
  return false;
return true;
165}

167/* Get the cgraph_function_version_info node corresponding to node.  */
168cgraph_function_version_info *
169cgraph_node::function_version (void)
170{
cgraph_function_version_info key;
key.this_node = this;

if (cgraph_fnver_htab == NULL__null)
  return NULL__null;

return cgraph_fnver_htab->find (&key);
178}

180/* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
 corresponding to cgraph_node NODE.  */
182cgraph_function_version_info *
183cgraph_node::insert_new_function_version (void)
184{
version_info_node = NULL__null;
version_info_node = ggc_cleared_alloc<cgraph_function_version_info> ();
version_info_node->this_node = this;

if (cgraph_fnver_htab == NULL__null)
  cgraph_fnver_htab = hash_table<function_version_hasher>::create_ggc (2);

*cgraph_fnver_htab->find_slot (version_info_node, INSERT)
  = version_info_node;
return version_info_node;
195}

197/* Remove the cgraph_function_version_info node given by DECL_V.  */
198static void
199delete_function_version (cgraph_function_version_info *decl_v)
200{
if (decl_v == NULL__null)
  return;

if (version_info_node == decl_v)
  version_info_node = NULL__null;

if (decl_v->prev != NULL__null)
  decl_v->prev->next = decl_v->next;

if (decl_v->next != NULL__null)
  decl_v->next->prev = decl_v->prev;

if (cgraph_fnver_htab != NULL__null)
  cgraph_fnver_htab->remove_elt (decl_v);
215}

217/* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
 DECL is a duplicate declaration.  */
219void
220cgraph_node::delete_function_version_by_decl (tree decl)
221{
cgraph_node *decl_node = cgraph_node::get (decl);

if (decl_node == NULL__null)
  return;

delete_function_version (decl_node->function_version ());

decl_node->remove ();
230}

232/* Record that DECL1 and DECL2 are semantically identical function
 versions.  */
234void
235cgraph_node::record_function_versions (tree decl1, tree decl2)
236{
cgraph_node *decl1_node = cgraph_node::get_create (decl1);
cgraph_node *decl2_node = cgraph_node::get_create (decl2);
cgraph_function_version_info *decl1_v = NULL__null;
cgraph_function_version_info *decl2_v = NULL__null;
cgraph_function_version_info *before;
cgraph_function_version_info *after;

gcc_assert (decl1_node != NULL && decl2_node != NULL)((void)(!(decl1_node != __null && decl2_node != __null
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 244, __FUNCTION__), 0 : 0));
decl1_v = decl1_node->function_version ();
decl2_v = decl2_node->function_version ();

if (decl1_v != NULL__null && decl2_v != NULL__null)
  return;

if (decl1_v == NULL__null)
  decl1_v = decl1_node->insert_new_function_version ();

if (decl2_v == NULL__null)
  decl2_v = decl2_node->insert_new_function_version ();

/* Chain decl2_v and decl1_v.  All semantically identical versions
   will be chained together.  */

before = decl1_v;
after = decl2_v;

while (before->next != NULL__null)
  before = before->next;

while (after->prev != NULL__null)
  after= after->prev;

before->next = after;
after->prev = before;
271}

273/* Initialize callgraph dump file.  */

275void
276symbol_table::initialize (void)
277{
if (!dump_file)
  dump_file = dump_begin (TDI_cgraph, NULL__null);

if (!ipa_clones_dump_file)
  ipa_clones_dump_file = dump_begin (TDI_clones, NULL__null);
283}

285/* Allocate new callgraph node and insert it into basic data structures.  */

287cgraph_node *
288symbol_table::create_empty (void)
289{
cgraph_count++;
return new (ggc_alloc<cgraph_node> ()) cgraph_node (cgraph_max_uid++);
292}

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{
cgraph_edge_hook_list *entry;
cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;

entry = (cgraph_edge_hook_list *) xmalloc (sizeof (*entry));
entry->hook = hook;
entry->data = data;
entry->next = NULL__null;
while (*ptr)
  ptr = &(*ptr)->next;
*ptr = entry;
return entry;
309}

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{
cgraph_edge_hook_list **ptr = &m_first_edge_removal_hook;

while (*ptr != entry)
  ptr = &(*ptr)->next;
*ptr = entry->next;
free (entry);
321}

323/* Call all edge removal hooks.  */
324void
325symbol_table::call_edge_removal_hooks (cgraph_edge *e)
326{
cgraph_edge_hook_list *entry = m_first_edge_removal_hook;
while (entry)
{
  entry->hook (e, entry->data);
  entry = entry->next;
}
333}

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{
cgraph_node_hook_list *entry;
cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;

entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
entry->hook = hook;
entry->data = data;
entry->next = NULL__null;
while (*ptr)
  ptr = &(*ptr)->next;
*ptr = entry;
return entry;
350}

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{
cgraph_node_hook_list **ptr = &m_first_cgraph_removal_hook;

while (*ptr != entry)
  ptr = &(*ptr)->next;
*ptr = entry->next;
free (entry);
362}

364/* Call all node removal hooks.  */
365void
366symbol_table::call_cgraph_removal_hooks (cgraph_node *node)
367{
cgraph_node_hook_list *entry = m_first_cgraph_removal_hook;
while (entry)
{
  entry->hook (node, entry->data);
  entry = entry->next;
}
374}

376/* Call all node removal hooks.  */
377void
378symbol_table::call_cgraph_insertion_hooks (cgraph_node *node)
379{
cgraph_node_hook_list *entry = m_first_cgraph_insertion_hook;
while (entry)
{
  entry->hook (node, entry->data);
  entry = entry->next;
}
386}


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{
cgraph_node_hook_list *entry;
cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;

entry = (cgraph_node_hook_list *) xmalloc (sizeof (*entry));
entry->hook = hook;
entry->data = data;
entry->next = NULL__null;
while (*ptr)
  ptr = &(*ptr)->next;
*ptr = entry;
return entry;
404}

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{
cgraph_node_hook_list **ptr = &m_first_cgraph_insertion_hook;

while (*ptr != entry)
  ptr = &(*ptr)->next;
*ptr = entry->next;
free (entry);
416}

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{
cgraph_2edge_hook_list *entry;
cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;

entry = (cgraph_2edge_hook_list *) xmalloc (sizeof (*entry));
entry->hook = hook;
entry->data = data;
entry->next = NULL__null;
while (*ptr)
  ptr = &(*ptr)->next;
*ptr = entry;
return entry;
433}

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{
cgraph_2edge_hook_list **ptr = &m_first_edge_duplicated_hook;

while (*ptr != entry)
  ptr = &(*ptr)->next;
*ptr = entry->next;
free (entry);
445}

447/* Call all edge duplication hooks.  */
448void
449symbol_table::call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2)
450{
cgraph_2edge_hook_list *entry = m_first_edge_duplicated_hook;
while (entry)
{
  entry->hook (cs1, cs2, entry->data);
  entry = entry->next;
}
457}

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{
cgraph_2node_hook_list *entry;
cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;

entry = (cgraph_2node_hook_list *) xmalloc (sizeof (*entry));
entry->hook = hook;
entry->data = data;
entry->next = NULL__null;
while (*ptr)
  ptr = &(*ptr)->next;
*ptr = entry;
return entry;
474}

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{
cgraph_2node_hook_list **ptr = &m_first_cgraph_duplicated_hook;

while (*ptr != entry)
  ptr = &(*ptr)->next;
*ptr = entry->next;
free (entry);
486}

488/* Call all node duplication hooks.  */
489void
490symbol_table::call_cgraph_duplication_hooks (cgraph_node *node,
			     cgraph_node *node2)
492{
cgraph_2node_hook_list *entry = m_first_cgraph_duplicated_hook;
while (entry)
{
  entry->hook (node, node2, entry->data);
  entry = entry->next;
}
499}

501/* Return cgraph node assigned to DECL.  Create new one when needed.  */

503cgraph_node *
504cgraph_node::create (tree decl)
505{
cgraph_node *node = symtab->create_empty ();
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL)((void)(!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 507, __FUNCTION__), 0 : 0));

node->decl = decl;
node->semantic_interposition = opt_for_fn (decl, flag_semantic_interposition)(opts_for_fn (decl)->x_flag_semantic_interposition);

if ((flag_openaccglobal_options.x_flag_openacc || flag_openmpglobal_options.x_flag_openmp)
    && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 513, __FUNCTION__))->decl_common.attributes)))
  {
    node->offloadable = 1;
    if (ENABLE_OFFLOADING0)
g->have_offload = true;
  }

if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 520, __FUNCTION__))->decl_common.attributes)))
  node->ifunc_resolver = true;

node->register_symbol ();
maybe_record_nested_function (node);

return node;
527}

529/* Try to find a call graph node for declaration DECL and if it does not exist
 or if it corresponds to an inline clone, create a new one.  */

532cgraph_node *
533cgraph_node::get_create (tree decl)
534{
cgraph_node *first_clone = cgraph_node::get (decl);

if (first_clone && !first_clone->inlined_to)
  return first_clone;

cgraph_node *node = cgraph_node::create (decl);
if (first_clone)
  {
    first_clone->clone_of = node;
    node->clones = first_clone;
    node->order = first_clone->order;
    symtab->symtab_prevail_in_asm_name_hash (node);
    node->decl->decl_with_vis.symtab_node = node;
    if (dump_file && symtab->state != PARSING)
fprintf (dump_file, "Introduced new external node "
 "(%s) and turned into root of the clone tree.\n",
 node->dump_name ());
  }
else if (dump_file && symtab->state != PARSING)
  fprintf (dump_file, "Introduced new external node "
    "(%s).\n", node->dump_name ());
return node;
557}

559/* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
 the function body is associated with
 (not necessarily cgraph_node (DECL)).  */

563cgraph_node *
564cgraph_node::create_alias (tree alias, tree target)
565{
cgraph_node *alias_node;

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 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 569, __FUNCTION__), 0 : 0))
     || TREE_CODE (target) == IDENTIFIER_NODE)((void)(!(((enum tree_code) (target)->base.code) == FUNCTION_DECL
 || ((enum tree_code) (target)->base.code) == IDENTIFIER_NODE
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 569, __FUNCTION__), 0 : 0));
gcc_assert (TREE_CODE (alias) == FUNCTION_DECL)((void)(!(((enum tree_code) (alias)->base.code) == FUNCTION_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 570, __FUNCTION__), 0 : 0));
alias_node = cgraph_node::get_create (alias);
gcc_assert (!alias_node->definition)((void)(!(!alias_node->definition) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 572, __FUNCTION__), 0 : 0));
alias_node->alias_target = target;
alias_node->definition = true;
alias_node->alias = true;
if (lookup_attribute ("weakref", DECL_ATTRIBUTES (alias)((contains_struct_check ((alias), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 576, __FUNCTION__))->decl_common.attributes)) != NULL__null)
  alias_node->transparent_alias = alias_node->weakref = true;
if (lookup_attribute ("ifunc", DECL_ATTRIBUTES (alias)((contains_struct_check ((alias), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 578, __FUNCTION__))->decl_common.attributes)))
  alias_node->ifunc_resolver = true;
return alias_node;
581}

583/* Attempt to mark ALIAS as an alias to DECL.  Return alias node if successful
 and NULL otherwise.
 Same body aliases are output whenever the body of DECL is output,
 and cgraph_node::get (ALIAS) transparently returns
 cgraph_node::get (DECL).  */

589cgraph_node *
590cgraph_node::create_same_body_alias (tree alias, tree decl)
591{
cgraph_node *n;

/* If aliases aren't supported by the assembler, fail.  */
if (!TARGET_SUPPORTS_ALIASES1)
  return NULL__null;

/* Langhooks can create same body aliases of symbols not defined.
   Those are useless. Drop them on the floor.  */
if (symtab->global_info_ready)
  return NULL__null;

n = cgraph_node::create_alias (alias, decl);
n->cpp_implicit_alias = true;
if (symtab->cpp_implicit_aliases_done)
  n->resolve_alias (cgraph_node::get (decl));
return n;
608}

610/* Add thunk alias into callgraph.  The alias declaration is ALIAS and it
 aliases DECL with an adjustments made into the first parameter.
 See comments in struct cgraph_thunk_info for detail on the parameters.  */

614cgraph_node *
615cgraph_node::create_thunk (tree alias, tree, bool this_adjusting,
	   HOST_WIDE_INTlong fixed_offset,
	   HOST_WIDE_INTlong virtual_value,
	   HOST_WIDE_INTlong indirect_offset,
	   tree virtual_offset,
	   tree real_alias)
621{
cgraph_node *node;

node = cgraph_node::get (alias);
if (node)
  node->reset ();
else
  node = cgraph_node::create (alias);

/* Make sure that if VIRTUAL_OFFSET is in sync with VIRTUAL_VALUE.  */
gcc_checking_assert (virtual_offset((void)(!(virtual_offset ? virtual_value == wi::to_wide (virtual_offset
) : virtual_value == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 633, __FUNCTION__), 0 : 0))
       ? virtual_value == wi::to_wide (virtual_offset)((void)(!(virtual_offset ? virtual_value == wi::to_wide (virtual_offset
) : virtual_value == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 633, __FUNCTION__), 0 : 0))
       : virtual_value == 0)((void)(!(virtual_offset ? virtual_value == wi::to_wide (virtual_offset
) : virtual_value == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 633, __FUNCTION__), 0 : 0));

node->thunk = true;
node->definition = true;

thunk_info *i;
thunk_info local_info;
if (symtab->state < CONSTRUCTION)
  i = &local_info;
else
  i = thunk_info::get_create (node);
i->fixed_offset = fixed_offset;
i->virtual_value = virtual_value;
i->indirect_offset = indirect_offset;
i->alias = real_alias;
i->this_adjusting = this_adjusting;
i->virtual_offset_p = virtual_offset != NULL__null;
if (symtab->state < CONSTRUCTION)
  i->register_early (node);

return node;
654}

656/* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
 Return NULL if there's no such node.  */

659cgraph_node *
660cgraph_node::get_for_asmname (tree asmname)
661{
/* We do not want to look at inline clones.  */
for (symtab_node *node = symtab_node::get_for_asmname (asmname);
     node;
     node = node->next_sharing_asm_name)
  {
    cgraph_node *cn = dyn_cast <cgraph_node *> (node);
    if (cn && !cn->inlined_to)
return cn;
  }
return NULL__null;
672}

674/* Returns a hash value for X (which really is a cgraph_edge).  */

676hashval_t
677cgraph_edge_hasher::hash (cgraph_edge *e)
678{
/* This is a really poor hash function, but it is what htab_hash_pointer
   uses.  */
return (hashval_t) ((intptr_t)e->call_stmt >> 3);
682}

684/* Returns a hash value for X (which really is a cgraph_edge).  */

686hashval_t
687cgraph_edge_hasher::hash (gimple *call_stmt)
688{
/* This is a really poor hash function, but it is what htab_hash_pointer
   uses.  */
return (hashval_t) ((intptr_t)call_stmt >> 3);
692}

694/* Return nonzero if the call_stmt of cgraph_edge X is stmt *Y.  */

696inline bool
697cgraph_edge_hasher::equal (cgraph_edge *x, gimple *y)
698{
return x->call_stmt == y;
700}

702/* Add call graph edge E to call site hash of its caller.  */

704static inline void
705cgraph_update_edge_in_call_site_hash (cgraph_edge *e)
706{
gimple *call = e->call_stmt;
*e->caller->call_site_hash->find_slot_with_hash
    (call, cgraph_edge_hasher::hash (call), INSERT) = e;
710}

712/* Add call graph edge E to call site hash of its caller.  */

714static inline void
715cgraph_add_edge_to_call_site_hash (cgraph_edge *e)
716{
/* There are two speculative edges for every statement (one direct,
   one indirect); always hash the direct one.  */
if (e->speculative && e->indirect_unknown_callee)
  return;
cgraph_edge **slot = e->caller->call_site_hash->find_slot_with_hash
    (e->call_stmt, cgraph_edge_hasher::hash (e->call_stmt), INSERT);
if (*slot)
  {
    gcc_assert (((cgraph_edge *)*slot)->speculative)((void)(!(((cgraph_edge *)*slot)->speculative) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 725, __FUNCTION__), 0 : 0));
    if (e->callee && (!e->prev_callee
	|| !e->prev_callee->speculative
	|| e->prev_callee->call_stmt != e->call_stmt))
*slot = e;
    return;
  }
gcc_assert (!*slot || e->speculative)((void)(!(!*slot || e->speculative) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 732, __FUNCTION__), 0 : 0));
*slot = e;
734}

736/* Return the callgraph edge representing the GIMPLE_CALL statement
 CALL_STMT.  */

739cgraph_edge *
740cgraph_node::get_edge (gimple *call_stmt)
741{
cgraph_edge *e, *e2;
int n = 0;

if (call_site_hash)
  return call_site_hash->find_with_hash
(call_stmt, cgraph_edge_hasher::hash (call_stmt));

/* This loop may turn out to be performance problem.  In such case adding
   hashtables into call nodes with very many edges is probably best
   solution.  It is not good idea to add pointer into CALL_EXPR itself
   because we want to make possible having multiple cgraph nodes representing
   different clones of the same body before the body is actually cloned.  */
for (e = callees; e; e = e->next_callee)
  {
    if (e->call_stmt == call_stmt)
break;
    n++;
  }

if (!e)
  for (e = indirect_calls; e; e = e->next_callee)
    {
if (e->call_stmt == call_stmt)
 break;
n++;
    }

if (n > 100)
  {
    call_site_hash = hash_table<cgraph_edge_hasher>::create_ggc (120);
    for (e2 = callees; e2; e2 = e2->next_callee)
cgraph_add_edge_to_call_site_hash (e2);
    for (e2 = indirect_calls; e2; e2 = e2->next_callee)
cgraph_add_edge_to_call_site_hash (e2);
  }

return e;
779}


782/* Change field call_stmt of edge E to NEW_STMT.  If UPDATE_SPECULATIVE and E
 is any component of speculative edge, then update all components.
 Speculations can be resolved in the process and EDGE can be removed and
 deallocated.  Return the edge that now represents the call.  */

787cgraph_edge *
788cgraph_edge::set_call_stmt (cgraph_edge *e, gcall *new_stmt,
	    bool update_speculative)
790{
tree decl;

cgraph_node *new_direct_callee = NULL__null;
if ((e->indirect_unknown_callee || e->speculative)
    && (decl = gimple_call_fndecl (new_stmt)))
  {
    /* Constant propagation and especially inlining can turn an indirect call
into a direct one.  */
    new_direct_callee = cgraph_node::get (decl);
    gcc_checking_assert (new_direct_callee)((void)(!(new_direct_callee) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 800, __FUNCTION__), 0 : 0));
  }

/* Speculative edges has three component, update all of them
   when asked to.  */
if (update_speculative && e->speculative
    /* If we are about to resolve the speculation by calling make_direct
below, do not bother going over all the speculative edges now.  */
    && !new_direct_callee)
  {
    cgraph_edge *direct, *indirect, *next;
    ipa_ref *ref;
    bool e_indirect = e->indirect_unknown_callee;
    int n = 0;

    direct = e->first_speculative_call_target ();
    indirect = e->speculative_call_indirect_edge ();

    gcall *old_stmt = direct->call_stmt;
    for (cgraph_edge *d = direct; d; d = next)
{
 next = d->next_speculative_call_target ();
 cgraph_edge *d2 = set_call_stmt (d, new_stmt, false);
 gcc_assert (d2 == d)((void)(!(d2 == d) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 823, __FUNCTION__), 0 : 0));
 n++;
}
    gcc_checking_assert (indirect->num_speculative_call_targets_p () == n)((void)(!(indirect->num_speculative_call_targets_p () == n
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 826, __FUNCTION__), 0 : 0));
    for (unsigned int i = 0; e->caller->iterate_reference (i, ref); i++)
if (ref->speculative && ref->stmt == old_stmt)
 {
   ref->stmt = new_stmt;
   n--;
 }

    indirect = set_call_stmt (indirect, new_stmt, false);
    return e_indirect ? indirect : direct;
  }

if (new_direct_callee)
  e = make_direct (e, new_direct_callee);

/* Only direct speculative edges go to call_site_hash.  */
if (e->caller->call_site_hash
    && (!e->speculative || !e->indirect_unknown_callee)
    /* It is possible that edge was previously speculative.  In this case
we have different value in call stmt hash which needs preserving.  */
    && e->caller->get_edge (e->call_stmt) == e)
  e->caller->call_site_hash->remove_elt_with_hash
    (e->call_stmt, cgraph_edge_hasher::hash (e->call_stmt));

e->call_stmt = new_stmt;

function *fun = DECL_STRUCT_FUNCTION (e->caller->decl)((tree_check ((e->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 852, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);
e->can_throw_external = stmt_can_throw_external (fun, new_stmt);
/* Update call stite hash.  For speculative calls we only record the first
   direct edge.  */
if (e->caller->call_site_hash
    && (!e->speculative
 || (e->callee
     && (!e->prev_callee || !e->prev_callee->speculative
  || e->prev_callee->call_stmt != e->call_stmt))
 || (e->speculative && !e->callee)))
  cgraph_add_edge_to_call_site_hash (e);
return e;
864}

866/* Allocate a cgraph_edge structure and fill it with data according to the
 parameters of which only CALLEE can be NULL (when creating an indirect call
 edge).  CLONING_P should be set if properties that are copied from an
 original edge should not be calculated.  */

871cgraph_edge *
872symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee,
	   gcall *call_stmt, profile_count count,
	   bool indir_unknown_callee, bool cloning_p)
875{
cgraph_edge *edge;

/* LTO does not actually have access to the call_stmt since these
   have not been loaded yet.  */
if (call_stmt)
  {
    /* This is a rather expensive check possibly triggering
construction of call stmt hashtable.  */
    cgraph_edge *e;
    gcc_checking_assert (!(e = caller->get_edge (call_stmt))((void)(!(!(e = caller->get_edge (call_stmt)) || e->speculative
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 886, __FUNCTION__), 0 : 0))
	   || e->speculative)((void)(!(!(e = caller->get_edge (call_stmt)) || e->speculative
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 886, __FUNCTION__), 0 : 0));

    gcc_assert (is_gimple_call (call_stmt))((void)(!(is_gimple_call (call_stmt)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 888, __FUNCTION__), 0 : 0));
  }

edge = ggc_alloc<cgraph_edge> ();
edge->m_summary_id = -1;
edges_count++;

gcc_assert (++edges_max_uid != 0)((void)(!(++edges_max_uid != 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 895, __FUNCTION__), 0 : 0));
edge->m_uid = edges_max_uid;
edge->aux = NULL__null;
edge->caller = caller;
edge->callee = callee;
edge->prev_caller = NULL__null;
edge->next_caller = NULL__null;
edge->prev_callee = NULL__null;
edge->next_callee = NULL__null;
edge->lto_stmt_uid = 0;
edge->speculative_id = 0;

edge->count = count;
edge->call_stmt = call_stmt;
edge->indirect_info = NULL__null;
edge->indirect_inlining_edge = 0;
edge->speculative = false;
edge->indirect_unknown_callee = indir_unknown_callee;
if (call_stmt && caller->call_site_hash)
  cgraph_add_edge_to_call_site_hash (edge);

if (cloning_p)
  return edge;

edge->can_throw_external
  = call_stmt ? stmt_can_throw_external (DECL_STRUCT_FUNCTION (caller->decl)((tree_check ((caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 920, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f),
			   call_stmt) : false;
edge->inline_failed = CIF_FUNCTION_NOT_CONSIDERED;
edge->call_stmt_cannot_inline_p = false;

if (opt_for_fn (edge->caller->decl, flag_devirtualize)(opts_for_fn (edge->caller->decl)->x_flag_devirtualize
)
    && call_stmt && DECL_STRUCT_FUNCTION (caller->decl)((tree_check ((caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 926, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))
  edge->in_polymorphic_cdtor
    = decl_maybe_in_construction_p (NULL__null, NULL__null, call_stmt,
		      caller->decl);
else
  edge->in_polymorphic_cdtor = caller->thunk;
if (callee)
  caller->calls_declare_variant_alt |= callee->declare_variant_alt;

if (callee && symtab->state != LTO_STREAMING
    && edge->callee->comdat_local_p ())
  edge->caller->calls_comdat_local = true;

return edge;
940}

942/* Create edge from a given function to CALLEE in the cgraph.  CLONING_P should
 be set if properties that are copied from an original edge should not be
 calculated.  */

946cgraph_edge *
947cgraph_node::create_edge (cgraph_node *callee,
	  gcall *call_stmt, profile_count count, bool cloning_p)
949{
cgraph_edge *edge = symtab->create_edge (this, callee, call_stmt, count,
			   false, cloning_p);

if (!cloning_p)
  initialize_inline_failed (edge);

edge->next_caller = callee->callers;
if (callee->callers)
  callee->callers->prev_caller = edge;
edge->next_callee = callees;
if (callees)
  callees->prev_callee = edge;
callees = edge;
callee->callers = edge;

return edge;
966}

968/* Allocate cgraph_indirect_call_info and set its fields to default values. */

970cgraph_indirect_call_info *
971cgraph_allocate_init_indirect_info (void)
972{
cgraph_indirect_call_info *ii;

ii = ggc_cleared_alloc<cgraph_indirect_call_info> ();
ii->param_index = -1;
return ii;
978}

980/* Create an indirect edge with a yet-undetermined callee where the call
 statement destination is a formal parameter of the caller with index
 PARAM_INDEX. CLONING_P should be set if properties that are copied from an
 original edge should not be calculated and indirect_info structure should
 not be calculated.  */

986cgraph_edge *
987cgraph_node::create_indirect_edge (gcall *call_stmt, int ecf_flags,
		   profile_count count,
		   bool cloning_p)
990{
cgraph_edge *edge = symtab->create_edge (this, NULL__null, call_stmt, count, true,
			   cloning_p);
tree target;

if (!cloning_p)
  initialize_inline_failed (edge);

edge->indirect_info = cgraph_allocate_init_indirect_info ();
edge->indirect_info->ecf_flags = ecf_flags;
edge->indirect_info->vptr_changed = true;

/* Record polymorphic call info.  */
if (!cloning_p
    && call_stmt
    && (target = gimple_call_fn (call_stmt))
    && virtual_method_call_p (target))
  {
    ipa_polymorphic_call_context context (decl, target, call_stmt);

    /* Only record types can have virtual calls.  */
    edge->indirect_info->polymorphic = true;
    edge->indirect_info->param_index = -1;
    edge->indirect_info->otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1014, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1014, __FUNCTION__))))));
    edge->indirect_info->otr_type = obj_type_ref_class (target);
    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 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1016, __FUNCTION__), 0 : 0));
    edge->indirect_info->context = context;
  }

edge->next_callee = indirect_calls;
if (indirect_calls)
  indirect_calls->prev_callee = edge;
indirect_calls = edge;

return edge;
1026}

1028/* Remove the edge from the list of the callees of the caller.  */

1030void
1031cgraph_edge::remove_caller (void)
1032{
if (prev_callee)
  prev_callee->next_callee = next_callee;
if (next_callee)
  next_callee->prev_callee = prev_callee;
if (!prev_callee)
  {
    if (indirect_unknown_callee)
caller->indirect_calls = next_callee;
    else
caller->callees = next_callee;
  }
if (caller->call_site_hash
    && this == caller->get_edge (call_stmt))
  caller->call_site_hash->remove_elt_with_hash
(call_stmt, cgraph_edge_hasher::hash (call_stmt));
1048}

1050/* Put the edge onto the free list.  */

1052void
1053symbol_table::free_edge (cgraph_edge *e)
1054{
edges_count--;
if (e->m_summary_id != -1)
  edge_released_summary_ids.safe_push (e->m_summary_id);

if (e->indirect_info)
  ggc_free (e->indirect_info);
ggc_free (e);
1062}

1064/* Remove the edge in the cgraph.  */

1066void
1067cgraph_edge::remove (cgraph_edge *edge)
1068{
/* Call all edge removal hooks.  */
symtab->call_edge_removal_hooks (edge);

if (!edge->indirect_unknown_callee)
  /* Remove from callers list of the callee.  */
  edge->remove_callee ();

/* Remove from callees list of the callers.  */
edge->remove_caller ();

/* Put the edge onto the free list.  */
symtab->free_edge (edge);
1081}

1083/* Turn edge into speculative call calling N2. Update
 the profile so the direct call is taken COUNT times
 with FREQUENCY.  

 At clone materialization time, the indirect call E will
 be expanded as:

 if (call_dest == N2)
   n2 ();
 else
   call call_dest

 At this time the function just creates the direct call,
 the reference representing the if conditional and attaches
 them all to the original indirect call statement.  

 speculative_id is used to link direct calls with their corresponding
 IPA_REF_ADDR references when representing speculative calls.

 Return direct edge created.  */

1104cgraph_edge *
1105cgraph_edge::make_speculative (cgraph_node *n2, profile_count direct_count,
	       unsigned int speculative_id)
1107{
cgraph_node *n = caller;
ipa_ref *ref = NULL__null;
cgraph_edge *e2;

if (dump_file)
  fprintf (dump_file, "Indirect call -> speculative call %s => %s\n",
    n->dump_name (), n2->dump_name ());
speculative = true;
e2 = n->create_edge (n2, call_stmt, direct_count);
initialize_inline_failed (e2);
e2->speculative = true;
if (TREE_NOTHROW (n2->decl)((n2->decl)->base.nothrow_flag))
  e2->can_throw_external = false;
else
  e2->can_throw_external = can_throw_external;
e2->lto_stmt_uid = lto_stmt_uid;
e2->speculative_id = speculative_id;
e2->in_polymorphic_cdtor = in_polymorphic_cdtor;
indirect_info->num_speculative_call_targets++;
count -= e2->count;
symtab->call_edge_duplication_hooks (this, e2);
ref = n->create_reference (n2, IPA_REF_ADDR, call_stmt);
ref->lto_stmt_uid = lto_stmt_uid;
ref->speculative_id = speculative_id;
ref->speculative = speculative;
n2->mark_address_taken ();
return e2;
1135}

1137/* Speculative call consists of an indirect edge and one or more
 direct edge+ref pairs.

 Given an edge which is part of speculative call, return the first
 direct call edge in the speculative call sequence.  */

1143cgraph_edge *
1144cgraph_edge::first_speculative_call_target ()
1145{
cgraph_edge *e = this;

gcc_checking_assert (e->speculative)((void)(!(e->speculative) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1148, __FUNCTION__), 0 : 0));
if (e->callee)
  {
    while (e->prev_callee && e->prev_callee->speculative
    && e->prev_callee->call_stmt == e->call_stmt
    && e->prev_callee->lto_stmt_uid == e->lto_stmt_uid)
e = e->prev_callee;
    return e;
  }
/* Call stmt site hash always points to the first target of the
   speculative call sequence.  */
if (e->call_stmt)
  return e->caller->get_edge (e->call_stmt);
for (cgraph_edge *e2 = e->caller->callees; true; e2 = e2->next_callee)
  if (e2->speculative
&& e->call_stmt == e2->call_stmt
&& e->lto_stmt_uid == e2->lto_stmt_uid)
    return e2;
1166}

1168/* We always maintain first direct edge in the call site hash, if one
 exists.  E is going to be removed.  See if it is first one and update
 hash accordingly.  INDIRECT is the indirect edge of speculative call.
 We assume that INDIRECT->num_speculative_call_targets_p () is already
 updated for removal of E.  */
1173static void
1174update_call_stmt_hash_for_removing_direct_edge (cgraph_edge *e,
				cgraph_edge *indirect)
1176{
if (e->caller->call_site_hash)
  {
    if (e->caller->get_edge (e->call_stmt) != e)
;
    else if (!indirect->num_speculative_call_targets_p ())
cgraph_update_edge_in_call_site_hash (indirect);
    else
{
 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 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1186, __FUNCTION__), 0 : 0))
	       && 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 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1186, __FUNCTION__), 0 : 0));
 cgraph_update_edge_in_call_site_hash (e->next_callee);
}
  }
1190}

1192/* Speculative call EDGE turned out to be direct call to CALLEE_DECL.  Remove
 the speculative call sequence and return edge representing the call, the
 original EDGE can be removed and deallocated.  Return the edge that now
 represents the call.

 For "speculative" indirect call that contains multiple "speculative"
 targets (i.e. edge->indirect_info->num_speculative_call_targets > 1),
 decrease the count and only remove current direct edge.

 If no speculative direct call left to the speculative indirect call, remove
 the speculative of both the indirect call and corresponding direct edge.

 It is up to caller to iteratively resolve each "speculative" direct call and
 redirect the call as appropriate.  */

1207cgraph_edge *
1208cgraph_edge::resolve_speculation (cgraph_edge *edge, tree callee_decl)
1209{
cgraph_edge *e2;
ipa_ref *ref;

gcc_assert (edge->speculative && (!callee_decl || edge->callee))((void)(!(edge->speculative && (!callee_decl || edge
->callee)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1213, __FUNCTION__), 0 : 0));
if (!edge->callee)
  e2 = edge->first_speculative_call_target ();
else
  e2 = edge;
ref = e2->speculative_call_target_ref ();
edge = edge->speculative_call_indirect_edge ();
if (!callee_decl
    || !ref->referred->semantically_equivalent_p
  (symtab_node::get (callee_decl)))
  {
    if (dump_file)
{
 if (callee_decl)
   {
     fprintf (dump_file, "Speculative indirect call %s => %s has "
       "turned out to have contradicting known target ",
       edge->caller->dump_name (),
       e2->callee->dump_name ());
     print_generic_expr (dump_file, callee_decl);
     fprintf (dump_file, "\n");
   }
 else
   {
     fprintf (dump_file, "Removing speculative call %s => %s\n",
       edge->caller->dump_name (),
       e2->callee->dump_name ());
   }
}
  }
else
  {
    cgraph_edge *tmp = edge;
    if (dump_file)
fprintf (dump_file, "Speculative call turned into direct call.\n");
    edge = e2;
    e2 = tmp;
    /* FIXME:  If EDGE is inlined, we should scale up the frequencies
and counts in the functions inlined through it.  */
  }
edge->count += e2->count;
if (edge->num_speculative_call_targets_p ())
  {
    /* The indirect edge has multiple speculative targets, don't remove
speculative until all related direct edges are resolved.  */
    edge->indirect_info->num_speculative_call_targets--;
    if (!edge->indirect_info->num_speculative_call_targets)
edge->speculative = false;
  }
else
  edge->speculative = false;
e2->speculative = false;
update_call_stmt_hash_for_removing_direct_edge (e2, edge);
ref->remove_reference ();
if (e2->indirect_unknown_callee || e2->inline_failed)
  remove (e2);
else
  e2->callee->remove_symbol_and_inline_clones ();
return edge;
1272}

1274/* Return edge corresponding to speculative call to a given target.
 NULL if speculative call does not have one.  */

1277cgraph_edge *
1278cgraph_edge::speculative_call_for_target (cgraph_node *target)
1279{
for (cgraph_edge *direct = first_speculative_call_target ();
     direct;
     direct = direct->next_speculative_call_target ())
  if (direct->speculative_call_target_ref ()
->referred->semantically_equivalent_p (target))
    return direct;
return NULL__null;
1287}

1289/* Make an indirect or speculative EDGE with an unknown callee an ordinary edge
 leading to CALLEE.  Speculations can be resolved in the process and EDGE can
 be removed and deallocated.  Return the edge that now represents the
 call.  */

1294cgraph_edge *
1295cgraph_edge::make_direct (cgraph_edge *edge, cgraph_node *callee)
1296{
gcc_assert (edge->indirect_unknown_callee || edge->speculative)((void)(!(edge->indirect_unknown_callee || edge->speculative
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1297, __FUNCTION__), 0 : 0));

/* If we are redirecting speculative call, make it non-speculative.  */
if (edge->speculative)
  {
    cgraph_edge *found = NULL__null;
    cgraph_edge *direct, *next;

    edge = edge->speculative_call_indirect_edge ();

    /* Look all speculative targets and remove all but one corresponding
to callee (if it exists).  */
    for (direct = edge->first_speculative_call_target ();
  direct;
  direct = next)
{
 next = direct->next_speculative_call_target ();

 /* Compare ref not direct->callee.  Direct edge is possibly
    inlined or redirected.  */
 if (!direct->speculative_call_target_ref ()
      ->referred->semantically_equivalent_p (callee))
   edge = direct->resolve_speculation (direct, NULL__null);
 else
   {
     gcc_checking_assert (!found)((void)(!(!found) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1322, __FUNCTION__), 0 : 0));
     found = direct;
   }
}

    /* On successful speculation just remove the indirect edge and
return the pre existing direct edge.
It is important to not remove it and redirect because the direct
edge may be inlined or redirected.  */
    if (found)
{
 cgraph_edge *e2 = resolve_speculation (found, callee->decl);
 gcc_checking_assert (!found->speculative && e2 == found)((void)(!(!found->speculative && e2 == found) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1334, __FUNCTION__), 0 : 0));
 return found;
}
    gcc_checking_assert (!edge->speculative)((void)(!(!edge->speculative) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1337, __FUNCTION__), 0 : 0));
  }

edge->indirect_unknown_callee = 0;
ggc_free (edge->indirect_info);
edge->indirect_info = NULL__null;

/* Get the edge out of the indirect edge list. */
if (edge->prev_callee)
  edge->prev_callee->next_callee = edge->next_callee;
if (edge->next_callee)
  edge->next_callee->prev_callee = edge->prev_callee;
if (!edge->prev_callee)
  edge->caller->indirect_calls = edge->next_callee;

/* Put it into the normal callee list */
edge->prev_callee = NULL__null;
edge->next_callee = edge->caller->callees;
if (edge->caller->callees)
  edge->caller->callees->prev_callee = edge;
edge->caller->callees = edge;

/* Insert to callers list of the new callee.  */
edge->set_callee (callee);

/* We need to re-determine the inlining status of the edge.  */
initialize_inline_failed (edge);
return edge;
1365}

1367/* Redirect callee of the edge to N.  The function does not update underlying
 call expression.  */

1370void
1371cgraph_edge::redirect_callee (cgraph_node *n)
1372{
bool loc = callee->comdat_local_p ();
/* Remove from callers list of the current callee.  */
remove_callee ();

/* Insert to callers list of the new callee.  */
set_callee (n);

if (!inline_failed)
  return;
if (!loc && n->comdat_local_p ())
  {
    cgraph_node *to = caller->inlined_to ? caller->inlined_to : caller;
    to->calls_comdat_local = true;
  }
else if (loc && !n->comdat_local_p ())
  {
    cgraph_node *to = caller->inlined_to ? caller->inlined_to : caller;
    gcc_checking_assert (to->calls_comdat_local)((void)(!(to->calls_comdat_local) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1390, __FUNCTION__), 0 : 0));
    to->calls_comdat_local = to->check_calls_comdat_local_p ();
  }
1393}

1395/* If necessary, change the function declaration in the call statement
 associated with E so that it corresponds to the edge callee.  Speculations
 can be resolved in the process and EDGE can be removed and deallocated.

 The edge could be one of speculative direct call generated from speculative
 indirect call.  In this circumstance, decrease the speculative targets
 count (i.e. num_speculative_call_targets) and redirect call stmt to the
 corresponding i-th target.  If no speculative direct call left to the
 speculative indirect call, remove "speculative" of the indirect call and
 also redirect stmt to it's final direct target.

 It is up to caller to iteratively transform each "speculative"
 direct call as appropriate.  */

1409gimple *
1410cgraph_edge::redirect_call_stmt_to_callee (cgraph_edge *e)
1411{
tree decl = gimple_call_fndecl (e->call_stmt);
gcall *new_stmt;

if (e->speculative)
  {
    /* If there already is an direct call (i.e. as a result of inliner's
substitution), forget about speculating.  */
    if (decl)
e = make_direct (e->speculative_call_indirect_edge (),
	 cgraph_node::get (decl));
    else
{
 /* Be sure we redirect all speculative targets before poking
    about indirect edge.  */
 gcc_checking_assert (e->callee)((void)(!(e->callee) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1426, __FUNCTION__), 0 : 0));
 cgraph_edge *indirect = e->speculative_call_indirect_edge ();
 gcall *new_stmt;
 ipa_ref *ref;

 /* Expand speculation into GIMPLE code.  */
 if (dump_file)
   {
     fprintf (dump_file,
       "Expanding speculative call of %s -> %s count: ",
       e->caller->dump_name (),
       e->callee->dump_name ());
     e->count.dump (dump_file);
     fprintf (dump_file, "\n");
   }
 push_cfun (DECL_STRUCT_FUNCTION (e->caller->decl)((tree_check ((e->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1441, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f));

 profile_count all = indirect->count;
 for (cgraph_edge *e2 = e->first_speculative_call_target ();
      e2;
      e2 = e2->next_speculative_call_target ())
   all = all + e2->count;
 profile_probability prob = e->count.probability_in (all);
 if (!prob.initialized_p ())
   prob = profile_probability::even ();
 ref = e->speculative_call_target_ref ();
 new_stmt = gimple_ic (e->call_stmt,
		dyn_cast<cgraph_node *> (ref->referred),
		prob);
 e->speculative = false;
 if (indirect->num_speculative_call_targets_p ())
   {
     /* The indirect edge has multiple speculative targets, don't
 remove speculative until all related direct edges are
 redirected.  */
     indirect->indirect_info->num_speculative_call_targets--;
     if (!indirect->indirect_info->num_speculative_call_targets)
indirect->speculative = false;
   }
 else
   indirect->speculative = false;
 /* Indirect edges are not both in the call site hash.
    get it updated.  */
 update_call_stmt_hash_for_removing_direct_edge (e, indirect);
 cgraph_edge::set_call_stmt (e, new_stmt, false);
 e->count = gimple_bb (e->call_stmt)->count;

 /* Once we are done with expanding the sequence, update also indirect
    call probability.  Until then the basic block accounts for the
    sum of indirect edge and all non-expanded speculations.  */
 if (!indirect->speculative)
   indirect->count = gimple_bb (indirect->call_stmt)->count;
 ref->speculative = false;
 ref->stmt = NULL__null;
 pop_cfun ();
 /* Continue redirecting E to proper target.  */
}
  }


if (e->indirect_unknown_callee
    || decl == e->callee->decl)
  return e->call_stmt;

if (decl && ipa_saved_clone_sources)
  {
    tree *p = ipa_saved_clone_sources->get (e->callee);
    if (p && decl == *p)
{
 gimple_call_set_fndecl (e->call_stmt, e->callee->decl);
 return e->call_stmt;
}
  }
if (flag_checkingglobal_options.x_flag_checking && decl)
  {
    if (cgraph_node *node = cgraph_node::get (decl))
{
 clone_info *info = clone_info::get (node);
 gcc_assert (!info || !info->param_adjustments)((void)(!(!info || !info->param_adjustments) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1504, __FUNCTION__), 0 : 0));
}
  }

clone_info *callee_info = clone_info::get (e->callee);
if (symtab->dump_file)
  {
    fprintf (symtab->dump_file, "updating call of %s -> %s: ",
      e->caller->dump_name (), e->callee->dump_name ());
    print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
    if (callee_info && callee_info->param_adjustments)
callee_info->param_adjustments->dump (symtab->dump_file);
  }

if (ipa_param_adjustments *padjs
= callee_info ? callee_info->param_adjustments : NULL__null)
  {
    /* We need to defer cleaning EH info on the new statement to
fixup-cfg.  We may not have dominator information at this point
and thus would end up with unreachable blocks and have no way
to communicate that we need to run CFG cleanup then.  */
    int lp_nr = lookup_stmt_eh_lp (e->call_stmt);
    if (lp_nr != 0)
remove_stmt_from_eh_lp (e->call_stmt);

    tree old_fntype = gimple_call_fntype (e->call_stmt);
    new_stmt = padjs->modify_call (e, false);
    cgraph_node *origin = e->callee;
    while (origin->clone_of)
origin = origin->clone_of;

    if ((origin->former_clone_of
  && old_fntype == TREE_TYPE (origin->former_clone_of)((contains_struct_check ((origin->former_clone_of), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1536, __FUNCTION__))->typed.type))
 || old_fntype == TREE_TYPE (origin->decl)((contains_struct_check ((origin->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1537, __FUNCTION__))->typed.type))
gimple_call_set_fntype (new_stmt, TREE_TYPE (e->callee->decl)((contains_struct_check ((e->callee->decl), (TS_TYPED),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1538, __FUNCTION__))->typed.type));
    else
{
 tree new_fntype = padjs->build_new_function_type (old_fntype, true);
 gimple_call_set_fntype (new_stmt, new_fntype);
}

    if (lp_nr != 0)
add_stmt_to_eh_lp (new_stmt, lp_nr);
  }
else
  {
    if (flag_checkingglobal_options.x_flag_checking
 && !fndecl_built_in_p (e->callee->decl, BUILT_IN_UNREACHABLE)
 && !fndecl_built_in_p (e->callee->decl, BUILT_IN_UNREACHABLE_TRAP))
ipa_verify_edge_has_no_modifications (e);
    new_stmt = e->call_stmt;
    gimple_call_set_fndecl (new_stmt, e->callee->decl);
    update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl)((tree_check ((e->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1556, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f), new_stmt);
  }

/* If changing the call to __cxa_pure_virtual or similar noreturn function,
   adjust gimple_call_fntype too.  */
if (gimple_call_noreturn_p (new_stmt)
    && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e->callee->decl)))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((e->callee->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1562, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1562, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
    && TYPE_ARG_TYPES (TREE_TYPE (e->callee->decl))((tree_check2 ((((contains_struct_check ((e->callee->decl
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1563, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1563, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)
    && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e->callee->decl)))((tree_check ((((tree_check2 ((((contains_struct_check ((e->
callee->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1564, __FUNCTION__))->typed.type)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1564, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1564, __FUNCTION__, (TREE_LIST)))->list.value)
 == void_type_nodeglobal_trees[TI_VOID_TYPE]))
  gimple_call_set_fntype (new_stmt, TREE_TYPE (e->callee->decl)((contains_struct_check ((e->callee->decl), (TS_TYPED),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1566, __FUNCTION__))->typed.type));

/* If the call becomes noreturn, remove the LHS if possible.  */
tree lhs = gimple_call_lhs (new_stmt);
if (lhs
    && gimple_call_noreturn_p (new_stmt)
    && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt)))(((enum tree_code) (((contains_struct_check ((gimple_call_fntype
 (new_stmt)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1572, __FUNCTION__))->typed.type))->base.code) == VOID_TYPE
)
 || should_remove_lhs_p (lhs)))
  {
    gimple_call_set_lhs (new_stmt, NULL_TREE(tree) __null);
    /* We need to fix up the SSA name to avoid checking errors.  */
    if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == SSA_NAME)
{
 tree var = create_tmp_reg_fn (DECL_STRUCT_FUNCTION (e->caller->decl)((tree_check ((e->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1579, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f),
			TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1580, __FUNCTION__))->typed.type), NULL__null);
 SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs, var)do { tree var_ = (var); (tree_check ((lhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1581, __FUNCTION__, (SSA_NAME)))->ssa_name.var = var_; (
tree_check ((lhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1581, __FUNCTION__, (SSA_NAME)))->base.public_flag = (var_
 && ((enum tree_code) (var_)->base.code) == VAR_DECL
 && ((tree_check ((var_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1581, __FUNCTION__, (VAR_DECL)))->base.u.bits.saturating_flag
)); } while (0);
 SSA_NAME_DEF_STMT (lhs)(tree_check ((lhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1582, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt = gimple_build_nop ();
 set_ssa_default_def (DECL_STRUCT_FUNCTION (e->caller->decl)((tree_check ((e->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1583, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f),
	       var, lhs);
}
    update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl)((tree_check ((e->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1586, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f), new_stmt);
  }

/* If new callee has no static chain, remove it.  */
if (gimple_call_chain (new_stmt) && !DECL_STATIC_CHAIN (e->callee->decl)((tree_check ((e->callee->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1590, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.regdecl_flag
))
  {
    gimple_call_set_chain (new_stmt, NULL__null);
    update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl)((tree_check ((e->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1593, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f), new_stmt);
  }

maybe_remove_unused_call_args (DECL_STRUCT_FUNCTION (e->caller->decl)((tree_check ((e->caller->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1596, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f),
		 new_stmt);

e->caller->set_call_stmt_including_clones (e->call_stmt, new_stmt, false);

if (symtab->dump_file)
  {
    fprintf (symtab->dump_file, "  updated to:");
    print_gimple_stmt (symtab->dump_file, e->call_stmt, 0, dump_flags);
  }
return new_stmt;
1607}

1609/* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
 OLD_STMT changed into NEW_STMT.  OLD_CALL is gimple_call_fndecl
 of OLD_STMT if it was previously call statement.
 If NEW_STMT is NULL, the call has been dropped without any
 replacement.  */

1615static void
1616cgraph_update_edges_for_call_stmt_node (cgraph_node *node,
			gimple *old_stmt, tree old_call,
			gimple *new_stmt)
1619{
tree new_call = (new_stmt && is_gimple_call (new_stmt))
3
←
Assuming 'new_stmt' is non-null→
4
←
'?' condition is true→
  ? gimple_call_fndecl (new_stmt) : 0;
5
←
Calling 'gimple_call_fndecl'→
14
←
Returning from 'gimple_call_fndecl'→

/* We are seeing indirect calls, then there is nothing to update.  */
if (!new_call14.1
'new_call' is null
1
'new_call' is null
1
'new_call' is null
 && !old_call)
15
←
Assuming 'old_call' is non-null→
16
←
Taking false branch→
  return;
/* See if we turned indirect call into direct call or folded call to one builtin
   into different builtin.  */
if (old_call16.1
'old_call' is not equal to 'new_call'
1
'old_call' is not equal to 'new_call'
1
'old_call' is not equal to 'new_call'
 != new_call)
17
←
Taking true branch→
  {
    cgraph_edge *e = node->get_edge (old_stmt);
    cgraph_edge *ne = NULL__null;
    profile_count count;

    if (e)
18
←
Assuming 'e' is non-null→
{
 /* Keep calls marked as dead dead.  */
 if (new_stmt18.1
'new_stmt' is non-null
1
'new_stmt' is non-null
1
'new_stmt' is non-null
 && is_gimple_call (new_stmt) && e->callee
19
←
Assuming field 'callee' is null→
20
←
Assuming pointer value is null→
     && (fndecl_built_in_p (e->callee->decl, BUILT_IN_UNREACHABLE)
  || fndecl_built_in_p (e->callee->decl,
			BUILT_IN_UNREACHABLE_TRAP)))
   {
     cgraph_edge::set_call_stmt (node->get_edge (old_stmt),
			  as_a <gcall *> (new_stmt));
     return;
   }
 /* See if the edge is already there and has the correct callee.  It
    might be so because of indirect inlining has already updated
    it.  We also might've cloned and redirected the edge.  */
 if (new_call20.1
'new_call' is null
1
'new_call' is null
1
'new_call' is null
 && e->callee)
   {
     cgraph_node *callee = e->callee;
     while (callee)
{
  if (callee->decl == new_call
      || callee->former_clone_of == new_call)
    {
      cgraph_edge::set_call_stmt (e, as_a <gcall *> (new_stmt));
      return;
    }
  callee = callee->clone_of;
}
   }

 /* Otherwise remove edge and create new one; we can't simply redirect
    since function has changed, so inline plan and other information
    attached to edge is invalid.  */
 count = e->count;
  if (e->indirect_unknown_callee || e->inline_failed)
21
←
Assuming field 'indirect_unknown_callee' is 0→
22
←
Assuming field 'inline_failed' is 0→
23
←
Taking false branch→
   cgraph_edge::remove (e);
 else
   e->callee->remove_symbol_and_inline_clones ();
24
←
Called C++ object pointer is null
}
    else if (new_call)
{
 /* We are seeing new direct call; compute profile info based on BB.  */
 basic_block bb = gimple_bb (new_stmt);
 count = bb->count;
}

    if (new_call)
{
 ne = node->create_edge (cgraph_node::get_create (new_call),
		  as_a <gcall *> (new_stmt), count);
 gcc_assert (ne->inline_failed)((void)(!(ne->inline_failed) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1684, __FUNCTION__), 0 : 0));
}
  }
/* We only updated the call stmt; update pointer in cgraph edge..  */
else if (old_stmt != new_stmt)
  cgraph_edge::set_call_stmt (node->get_edge (old_stmt),
		as_a <gcall *> (new_stmt));
1691}

1693/* Update or remove the corresponding cgraph edge if a GIMPLE_CALL
 OLD_STMT changed into NEW_STMT.  OLD_DECL is gimple_call_fndecl
 of OLD_STMT before it was updated (updating can happen inplace).  */

1697void
1698cgraph_update_edges_for_call_stmt (gimple *old_stmt, tree old_decl,
		   gimple *new_stmt)
1700{
cgraph_node *orig = cgraph_node::get (cfun(cfun + 0)->decl);
cgraph_node *node;

gcc_checking_assert (orig)((void)(!(orig) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1704, __FUNCTION__), 0 : 0));
1
'?' condition is false→
cgraph_update_edges_for_call_stmt_node (orig, old_stmt, old_decl, new_stmt);
2
←
Calling 'cgraph_update_edges_for_call_stmt_node'→
if (orig->clones)
  for (node = orig->clones; node != orig;)
    {
cgraph_update_edges_for_call_stmt_node (node, old_stmt, old_decl,
				new_stmt);
if (node->clones)
 node = node->clones;
else if (node->next_sibling_clone)
 node = node->next_sibling_clone;
else
 {
   while (node != orig && !node->next_sibling_clone)
     node = node->clone_of;
   if (node != orig)
     node = node->next_sibling_clone;
 }
    }
1723}


1726/* Remove all callees from the node.  */

1728void
1729cgraph_node::remove_callees (void)
1730{
cgraph_edge *e, *f;

calls_comdat_local = false;

/* It is sufficient to remove the edges from the lists of callers of
   the callees.  The callee list of the node can be zapped with one
   assignment.  */
for (e = callees; e; e = f)
  {
    f = e->next_callee;
    symtab->call_edge_removal_hooks (e);
    if (!e->indirect_unknown_callee)
e->remove_callee ();
    symtab->free_edge (e);
  }
for (e = indirect_calls; e; e = f)
  {
    f = e->next_callee;
    symtab->call_edge_removal_hooks (e);
    if (!e->indirect_unknown_callee)
e->remove_callee ();
    symtab->free_edge (e);
  }
indirect_calls = NULL__null;
callees = NULL__null;
if (call_site_hash)
  {
    call_site_hash->empty ();
    call_site_hash = NULL__null;
  }
1761}

1763/* Remove all callers from the node.  */

1765void
1766cgraph_node::remove_callers (void)
1767{
cgraph_edge *e, *f;

/* It is sufficient to remove the edges from the lists of callees of
   the callers.  The caller list of the node can be zapped with one
   assignment.  */
for (e = callers; e; e = f)
  {
    f = e->next_caller;
    symtab->call_edge_removal_hooks (e);
    e->remove_caller ();
    symtab->free_edge (e);
  }
callers = NULL__null;
1781}

1783/* Helper function for cgraph_release_function_body and free_lang_data.
 It releases body from function DECL without having to inspect its
 possibly non-existent symtab node.  */

1787void
1788release_function_body (tree decl)
1789{
function *fn = DECL_STRUCT_FUNCTION (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1790, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);
if (fn)
  {
    if (fn->cfg
 && loops_for_fn (fn))
{
 fn->curr_properties &= ~PROP_loops(1 << 11);
 loop_optimizer_finalize (fn);
}
    if (fn->gimple_df)
{
 delete_tree_ssa (fn);
 fn->eh = NULL__null;
}
    if (fn->cfg)
{
 gcc_assert (!dom_info_available_p (fn, CDI_DOMINATORS))((void)(!(!dom_info_available_p (fn, CDI_DOMINATORS)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1806, __FUNCTION__), 0 : 0));
 gcc_assert (!dom_info_available_p (fn, CDI_POST_DOMINATORS))((void)(!(!dom_info_available_p (fn, CDI_POST_DOMINATORS)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1807, __FUNCTION__), 0 : 0));
 delete_tree_cfg_annotations (fn);
 free_cfg (fn);
 fn->cfg = NULL__null;
}
    if (fn->value_histograms)
free_histograms (fn);
    gimple_set_body (decl, NULL__null);
    /* Struct function hangs a lot of data that would leak if we didn't
removed all pointers to it.   */
    ggc_free (fn);
    DECL_STRUCT_FUNCTION (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1818, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f) = NULL__null;
  }
DECL_SAVED_TREE (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1820, __FUNCTION__, (FUNCTION_DECL)))->function_decl.saved_tree
) = NULL__null;
1821}

1823/* Release memory used to represent body of function.
 Use this only for functions that are released before being translated to
 target code (i.e. RTL).  Functions that are compiled to RTL and beyond
 are free'd in final.cc via free_after_compilation().
 KEEP_ARGUMENTS are useful only if you want to rebuild body as thunk.  */

1829void
1830cgraph_node::release_body (bool keep_arguments)
1831{
ipa_transforms_to_apply.release ();
if (!used_as_abstract_origin && symtab->state != PARSING)
  {
    DECL_RESULT (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1835, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
) = NULL__null;

    if (!keep_arguments)
DECL_ARGUMENTS (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1838, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
) = NULL__null;
  }
/* If the node is abstract and needed, then do not clear
   DECL_INITIAL of its associated function declaration because it's
   needed to emit debug info later.  */
if (!used_as_abstract_origin && DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1843, __FUNCTION__))->decl_common.initial))
  DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1844, __FUNCTION__))->decl_common.initial) = error_mark_nodeglobal_trees[TI_ERROR_MARK];
release_function_body (decl);
if (lto_file_data)
  {
    lto_free_function_in_decl_state_for_node (this);
    lto_file_data = NULL__null;
  }
if (flag_checkingglobal_options.x_flag_checking && clones)
  {
    /* It is invalid to release body before materializing clones except
for thunks that don't really need a body.  Verify also that we do
not leak pointers to the call statements.  */
    for (cgraph_node *node = clones; node;
  node = node->next_sibling_clone)
gcc_assert (node->thunk && !node->callees->call_stmt)((void)(!(node->thunk && !node->callees->call_stmt
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1858, __FUNCTION__), 0 : 0));
  }
remove_callees ();
remove_all_references ();
1862}

1864/* Remove function from symbol table.  */

1866void
1867cgraph_node::remove (void)
1868{
bool clone_info_set = false;
clone_info *info, saved_info;
if (symtab->ipa_clones_dump_file && symtab->cloned_nodes.contains (this))
  fprintf (symtab->ipa_clones_dump_file,
    "Callgraph removal;%s;%d;%s;%d;%d\n", asm_name (), order,
    DECL_SOURCE_FILE (decl)((expand_location (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1874, __FUNCTION__))->decl_minimal.locus))).file), DECL_SOURCE_LINE (decl)((expand_location (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1874, __FUNCTION__))->decl_minimal.locus))).line),
    DECL_SOURCE_COLUMN (decl)((expand_location (((contains_struct_check ((decl), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1875, __FUNCTION__))->decl_minimal.locus))).column));

if ((info = clone_info::get (this)) != NULL__null)
  {
    saved_info = *info;
    clone_info_set = true;
  }
symtab->call_cgraph_removal_hooks (this);
remove_callers ();
remove_callees ();
ipa_transforms_to_apply.release ();
delete_function_version (function_version ());

/* Incremental inlining access removed nodes stored in the postorder list.
   */
force_output = false;
forced_by_abi = false;

unregister (clone_info_set ? &saved_info : NULL__null);
if (prev_sibling_clone)
  prev_sibling_clone->next_sibling_clone = next_sibling_clone;
else if (clone_of)
  {
    clone_of->clones = next_sibling_clone;
    if (!clones)
{
 bool need_body = false;
 for (cgraph_node *n = clone_of; n; n = n->clone_of)
   if (n->analyzed || n->clones)
     {
need_body = true;
break;
     }
 if (!need_body)
   clone_of->release_body ();
}
  }
if (next_sibling_clone)
  next_sibling_clone->prev_sibling_clone = prev_sibling_clone;
if (clones)
  {
    cgraph_node *n, *next;

    if (clone_of)
{
 for (n = clones; n->next_sibling_clone; n = n->next_sibling_clone)
   n->clone_of = clone_of;
 n->clone_of = clone_of;
 n->next_sibling_clone = clone_of->clones;
 if (clone_of->clones)
   clone_of->clones->prev_sibling_clone = n;
 clone_of->clones = clones;
}
    else
{
 /* We are removing node with clones.  This makes clones inconsistent,
    but assume they will be removed subsequently and just keep clone
    tree intact.  This can happen in unreachable function removal since
    we remove unreachable functions in random order, not by bottom-up
    walk of clone trees.  */
 for (n = clones; n; n = next)
   {
      next = n->next_sibling_clone;
      n->next_sibling_clone = NULL__null;
      n->prev_sibling_clone = NULL__null;
      n->clone_of = NULL__null;
   }
}
  }

/* While all the clones are removed after being proceeded, the function
   itself is kept in the cgraph even after it is compiled.  Check whether
   we are done with this body and reclaim it proactively if this is the case.
   */
if (symtab->state != LTO_STREAMING)
  {
    cgraph_node *n = cgraph_node::get (decl);
    if (!n
 || (!n->clones && !n->clone_of && !n->inlined_to
     && ((symtab->global_info_ready || in_lto_pglobal_options.x_in_lto_p)
  && (TREE_ASM_WRITTEN (n->decl)((n->decl)->base.asm_written_flag)
      || DECL_EXTERNAL (n->decl)((contains_struct_check ((n->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1956, __FUNCTION__))->decl_common.decl_flag_1)
      || !n->analyzed
      || (!flag_wpaglobal_options.x_flag_wpa && n->in_other_partition)))))
release_body ();
  }
else
  {
    lto_free_function_in_decl_state_for_node (this);
    lto_file_data = NULL__null;
  }

decl = NULL__null;
if (call_site_hash)
  {
    call_site_hash->empty ();
    call_site_hash = NULL__null;
  }

symtab->release_symbol (this);
1975}

1977/* Likewise indicate that a node is having address taken.  */

1979void
1980cgraph_node::mark_address_taken (void)
1981{
/* Indirect inlining can figure out that all uses of the address are
   inlined.  */
if (inlined_to)
  {
    gcc_assert (cfun->after_inlining)((void)(!((cfun + 0)->after_inlining) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1986, __FUNCTION__), 0 : 0));
    gcc_assert (callers->indirect_inlining_edge)((void)(!(callers->indirect_inlining_edge) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 1987, __FUNCTION__), 0 : 0));
    return;
  }
/* FIXME: address_taken flag is used both as a shortcut for testing whether
   IPA_REF_ADDR reference exists (and thus it should be set on node
   representing alias we take address of) and as a test whether address
   of the object was taken (and thus it should be set on node alias is
   referring to).  We should remove the first use and the remove the
   following set.  */
address_taken = 1;
cgraph_node *node = ultimate_alias_target ();
node->address_taken = 1;
1999}

2001/* Return local info node for the compiled function.  */

2003cgraph_node *
2004cgraph_node::local_info_node (tree decl)
2005{
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL)((void)(!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2006, __FUNCTION__), 0 : 0));
cgraph_node *node = get (decl);
if (!node)
  return NULL__null;
return node->ultimate_alias_target ();
2011}

2013/* Return RTL info for the compiled function.  */

2015cgraph_rtl_info *
2016cgraph_node::rtl_info (const_tree decl)
2017{
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL)((void)(!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2018, __FUNCTION__), 0 : 0));
cgraph_node *node = get (decl);
if (!node)
  return NULL__null;
enum availability avail;
node = node->ultimate_alias_target (&avail);
if (decl != current_function_decl
    && (avail < AVAIL_AVAILABLE
 || (node->decl != current_function_decl
     && !TREE_ASM_WRITTEN (node->decl)((node->decl)->base.asm_written_flag))))
  return NULL__null;
/* Allocate if it doesn't exist.  */
if (node->rtl == NULL__null)
  {
    node->rtl = ggc_cleared_alloc<cgraph_rtl_info> ();
    SET_HARD_REG_SET (node->rtl->function_used_regs);
  }
return node->rtl;
2036}

2038/* Return a string describing the failure REASON.  */

2040const char*
2041cgraph_inline_failed_string (cgraph_inline_failed_t reason)
2042{
2043#undef DEFCIFCODE
2044#define DEFCIFCODE(code, type, string)type,	string,

static const char *cif_string_table[CIF_N_REASONS] = {
2047#include "cif-code.def"
};

/* Signedness of an enum type is implementation defined, so cast it
   to unsigned before testing. */
gcc_assert ((unsigned) reason < CIF_N_REASONS)((void)(!((unsigned) reason < CIF_N_REASONS) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2052, __FUNCTION__), 0 : 0));
return cif_string_table[reason];
2054}

2056/* Return a type describing the failure REASON.  */

2058cgraph_inline_failed_type_t
2059cgraph_inline_failed_type (cgraph_inline_failed_t reason)
2060{
2061#undef DEFCIFCODE
2062#define DEFCIFCODE(code, type, string)type,	type,

static cgraph_inline_failed_type_t cif_type_table[CIF_N_REASONS] = {
2065#include "cif-code.def"
};

/* Signedness of an enum type is implementation defined, so cast it
   to unsigned before testing. */
gcc_assert ((unsigned) reason < CIF_N_REASONS)((void)(!((unsigned) reason < CIF_N_REASONS) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2070, __FUNCTION__), 0 : 0));
return cif_type_table[reason];
2072}

2074/* Names used to print out the availability enum.  */
2075const char * const cgraph_availability_names[] =
{"unset", "not_available", "overwritable", "available", "local"};

2078/* Output flags of edge to a file F.  */

2080void
2081cgraph_edge::dump_edge_flags (FILE *f)
2082{
if (speculative)
  fprintf (f, "(speculative) ");
if (!inline_failed)
  fprintf (f, "(inlined) ");
if (call_stmt_cannot_inline_p)
  fprintf (f, "(call_stmt_cannot_inline_p) ");
if (indirect_inlining_edge)
  fprintf (f, "(indirect_inlining) ");
if (count.initialized_p ())
  {
    fprintf (f, "(");
    count.dump (f);
    fprintf (f, ",");
    fprintf (f, "%.2f per call) ", sreal_frequency ().to_double ());
  }
if (can_throw_external)
  fprintf (f, "(can throw external) ");
2100}

2102/* Dump edge to stderr.  */

2104void
2105cgraph_edge::debug (void)
2106{
fprintf (stderrstderr, "%s -> %s ", caller->dump_asm_name (),
  callee == NULL__null ? "(null)" : callee->dump_asm_name ());
dump_edge_flags (stderrstderr);
fprintf (stderrstderr, "\n\n");
caller->debug ();
if (callee != NULL__null)
  callee->debug ();
2114}

2116/* Dump call graph node to file F.  */

2118void
2119cgraph_node::dump (FILE *f)
2120{
cgraph_edge *edge;

dump_base (f);

if (inlined_to)
  fprintf (f, "  Function %s is inline copy in %s\n",
    dump_name (),
    inlined_to->dump_name ());
if (clone_of)
  fprintf (f, "  Clone of %s\n", clone_of->dump_asm_name ());
if (symtab->function_flags_ready)
  fprintf (f, "  Availability: %s\n",
    cgraph_availability_names [get_availability ()]);

if (profile_id)
  fprintf (f, "  Profile id: %i\n",
    profile_id);
if (unit_id)
  fprintf (f, "  Unit id: %i\n",
    unit_id);
cgraph_function_version_info *vi = function_version ();
if (vi != NULL__null)
  {
    fprintf (f, "  Version info: ");
    if (vi->prev != NULL__null)
{
 fprintf (f, "prev: ");
 fprintf (f, "%s ", vi->prev->this_node->dump_asm_name ());
}
    if (vi->next != NULL__null)
{
 fprintf (f, "next: ");
 fprintf (f, "%s ", vi->next->this_node->dump_asm_name ());
}
    if (vi->dispatcher_resolver != NULL_TREE(tree) __null)
fprintf (f, "dispatcher: %s",
 lang_hooks.decl_printable_name (vi->dispatcher_resolver, 2));

    fprintf (f, "\n");
  }
fprintf (f, "  Function flags:");
if (count.initialized_p ())
  {
    fprintf (f, " count:");
    count.dump (f);
  }
if (tp_first_run > 0)
  fprintf (f, " first_run:%" PRId64"l" "d", (int64_t) tp_first_run);
if (cgraph_node *origin = nested_function_origin (this))
  fprintf (f, " nested in:%s", origin->dump_asm_name ());
if (gimple_has_body_p (decl))
  fprintf (f, " body");
if (process)
  fprintf (f, " process");
if (local)
  fprintf (f, " local");
if (redefined_extern_inline)
  fprintf (f, " redefined_extern_inline");
if (only_called_at_startup)
  fprintf (f, " only_called_at_startup");
if (only_called_at_exit)
  fprintf (f, " only_called_at_exit");
if (tm_clone)
  fprintf (f, " tm_clone");
if (calls_comdat_local)
  fprintf (f, " calls_comdat_local");
if (icf_merged)
  fprintf (f, " icf_merged");
if (merged_comdat)
  fprintf (f, " merged_comdat");
if (merged_extern_inline)
  fprintf (f, " merged_extern_inline");
if (split_part)
  fprintf (f, " split_part");
if (indirect_call_target)
  fprintf (f, " indirect_call_target");
if (nonfreeing_fn)
  fprintf (f, " nonfreeing_fn");
if (DECL_STATIC_CONSTRUCTOR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2199, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_ctor_flag
))
  fprintf (f," static_constructor (priority:%i)", get_init_priority ());
if (DECL_STATIC_DESTRUCTOR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2201, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_dtor_flag
))
  fprintf (f," static_destructor (priority:%i)", get_fini_priority ());
if (frequency == NODE_FREQUENCY_HOT)
  fprintf (f, " hot");
if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
  fprintf (f, " unlikely_executed");
if (frequency == NODE_FREQUENCY_EXECUTED_ONCE)
  fprintf (f, " executed_once");
if (opt_for_fn (decl, optimize_size)(opts_for_fn (decl)->x_optimize_size))
  fprintf (f, " optimize_size");
if (parallelized_function)
  fprintf (f, " parallelized_function");
if (DECL_IS_MALLOC (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2213, __FUNCTION__, (FUNCTION_DECL)))->function_decl.malloc_flag
))
  fprintf (f, " decl_is_malloc");
if (DECL_IS_OPERATOR_NEW_P (decl)(((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2215, __FUNCTION__, (FUNCTION_DECL)))->function_decl.decl_type
) == OPERATOR_NEW))
  fprintf (f, " %soperator_new",
    DECL_IS_REPLACEABLE_OPERATOR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2217, __FUNCTION__, (FUNCTION_DECL)))->function_decl.replaceable_operator
) ? "replaceable_" : "");
if (DECL_IS_OPERATOR_DELETE_P (decl)(((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2218, __FUNCTION__, (FUNCTION_DECL)))->function_decl.decl_type
) == OPERATOR_DELETE))
  fprintf (f, " %soperator_delete",
    DECL_IS_REPLACEABLE_OPERATOR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2220, __FUNCTION__, (FUNCTION_DECL)))->function_decl.replaceable_operator
) ? "replaceable_" : "");

if (DECL_STATIC_CHAIN (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2222, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.regdecl_flag
))
  fprintf (f, " static_chain");

fprintf (f, "\n");

if (thunk)
  {
    fprintf (f, "  Thunk");
    thunk_info::get (this)->dump (f);
  }
else if (former_thunk_p ())
  {
    fprintf (f, "  Former thunk ");
    thunk_info::get (this)->dump (f);
  }
else gcc_checking_assert (!thunk_info::get (this))((void)(!(!thunk_info::get (this)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2237, __FUNCTION__), 0 : 0));

fprintf (f, "  Called by: ");

profile_count sum = profile_count::zero ();
for (edge = callers; edge; edge = edge->next_caller)
  {
    fprintf (f, "%s ", edge->caller->dump_asm_name ());
    edge->dump_edge_flags (f);
    if (edge->count.initialized_p ())
sum += edge->count.ipa ();
  }

fprintf (f, "\n  Calls: ");
for (edge = callees; edge; edge = edge->next_callee)
  {
    fprintf (f, "%s ", edge->callee->dump_asm_name ());
    edge->dump_edge_flags (f);
  }
fprintf (f, "\n");

if (!body_removed && count.ipa ().initialized_p ())
  {
    bool ok = true;
    bool min = false;
    ipa_ref *ref;

    FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
if (dyn_cast <cgraph_node *> (ref->referring)->count.initialized_p ())
 sum += dyn_cast <cgraph_node *> (ref->referring)->count.ipa ();

    if (inlined_to
 || (symtab->state < EXPANSION
     && ultimate_alias_target () == this && only_called_directly_p ()))
ok = !count.ipa ().differs_from_p (sum);
    else if (count.ipa () > profile_count::from_gcov_type (100)
      && count.ipa () < sum.apply_scale (99, 100))
ok = false, min = true;
    if (!ok)
{
 fprintf (f, "   Invalid sum of caller counts ");
 sum.dump (f);
 if (min)
   fprintf (f, ", should be at most ");
 else
   fprintf (f, ", should be ");
 count.ipa ().dump (f);
 fprintf (f, "\n");
}
  }

for (edge = indirect_calls; edge; edge = edge->next_callee)
  {
    if (edge->indirect_info->polymorphic)
{
 fprintf (f, "   Polymorphic indirect call of type ");
 print_generic_expr (f, edge->indirect_info->otr_type, TDF_SLIM);
 fprintf (f, " token:%i", (int) edge->indirect_info->otr_token);
}
    else
fprintf (f, "   Indirect call");
    edge->dump_edge_flags (f);
    if (edge->indirect_info->param_index != -1)
{
 fprintf (f, "of param:%i ", edge->indirect_info->param_index);
 if (edge->indirect_info->agg_contents)
  fprintf (f, "loaded from %s %s at offset %i ",
    edge->indirect_info->member_ptr ? "member ptr" : "aggregate",
    edge->indirect_info->by_ref ? "passed by reference":"",
    (int)edge->indirect_info->offset);
 if (edge->indirect_info->vptr_changed)
   fprintf (f, "(vptr maybe changed) ");
}
    fprintf (f, "num speculative call targets: %i\n",
      edge->indirect_info->num_speculative_call_targets);
    if (edge->indirect_info->polymorphic)
edge->indirect_info->context.dump (f);
  }
2315}

2317/* Dump call graph node to file F in graphviz format.  */

2319void
2320cgraph_node::dump_graphviz (FILE *f)
2321{
cgraph_edge *edge;

for (edge = callees; edge; edge = edge->next_callee)
  {
    cgraph_node *callee = edge->callee;

    fprintf (f, "\t\"%s\" -> \"%s\"\n", dump_name (), callee->dump_name ());
  }
2330}


2333/* Dump call graph node NODE to stderr.  */

2335DEBUG_FUNCTION__attribute__ ((__used__)) void
2336cgraph_node::debug (void)
2337{
dump (stderrstderr);
2339}

2341/* Dump the callgraph to file F.  */

2343void
2344cgraph_node::dump_cgraph (FILE *f)
2345{
cgraph_node *node;

fprintf (f, "callgraph:\n\n");
FOR_EACH_FUNCTION (node)for ((node) = symtab->first_function (); (node); (node) = symtab
->next_function ((node)))
  node->dump (f);
2351}

2353/* Return true when the DECL can possibly be inlined.  */

2355bool
2356cgraph_function_possibly_inlined_p (tree decl)
2357{
if (!symtab->global_info_ready)
  return !DECL_UNINLINABLE (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2359, __FUNCTION__, (FUNCTION_DECL)))->function_decl.uninlinable
);
return DECL_POSSIBLY_INLINED (decl)(tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2360, __FUNCTION__, (FUNCTION_DECL)))->function_decl.possibly_inlined;
2361}

2363/* Return function availability.  See cgraph.h for description of individual
 return values.  */
2365enum availability
2366cgraph_node::get_availability (symtab_node *ref)
2367{
if (ref)
  {
    cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
    if (cref)
ref = cref->inlined_to;
  }
enum availability avail;
if (!analyzed && !in_other_partition)
  avail = AVAIL_NOT_AVAILABLE;
else if (local)
  avail = AVAIL_LOCAL;
else if (inlined_to)
  avail = AVAIL_AVAILABLE;
else if (transparent_alias)
  ultimate_alias_target (&avail, ref);
else if (ifunc_resolver
  || lookup_attribute ("noipa", DECL_ATTRIBUTES (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2384, __FUNCTION__))->decl_common.attributes)))
  avail = AVAIL_INTERPOSABLE;
else if (!externally_visible)
  avail = AVAIL_AVAILABLE;
/* If this is a reference from symbol itself and there are no aliases, we
   may be sure that the symbol was not interposed by something else because
   the symbol itself would be unreachable otherwise.

   Also comdat groups are always resolved in groups.  */
else if ((this == ref && !has_aliases_p ())
  || (ref && get_comdat_group ()
      && get_comdat_group () == ref->get_comdat_group ()))
  avail = AVAIL_AVAILABLE;
/* Inline functions are safe to be analyzed even if their symbol can
   be overwritten at runtime.  It is not meaningful to enforce any sane
   behavior on replacing inline function by different body.  */
else if (DECL_DECLARED_INLINE_P (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2400, __FUNCTION__, (FUNCTION_DECL)))->function_decl.declared_inline_flag
))
  avail = AVAIL_AVAILABLE;

/* If the function can be overwritten, return OVERWRITABLE.  Take
   care at least of two notable extensions - the COMDAT functions
   used to share template instantiations in C++ (this is symmetric
   to code cp_cannot_inline_tree_fn and probably shall be shared and
   the inlinability hooks completely eliminated).  */

else if (decl_replaceable_p (decl, semantic_interposition)
  && !DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2410, __FUNCTION__))->decl_common.decl_flag_1))
  avail = AVAIL_INTERPOSABLE;
else avail = AVAIL_AVAILABLE;

return avail;
2415}

2417/* Worker for cgraph_node_can_be_local_p.  */
2418static bool
2419cgraph_node_cannot_be_local_p_1 (cgraph_node *node, void *)
2420{
return !(!node->force_output
  && !node->ifunc_resolver
  /* Limitation of gas requires us to output targets of symver aliases
     as global symbols.  This is binutils PR 25295.  */
  && !node->symver
  && ((DECL_COMDAT (node->decl)((contains_struct_check ((node->decl), (TS_DECL_WITH_VIS),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2426, __FUNCTION__))->decl_with_vis.comdat_flag)
&& !node->forced_by_abi
&& !node->used_from_object_file_p ()
&& !node->same_comdat_group)
      || !node->externally_visible));
2431}

2433/* Return true if cgraph_node can be made local for API change.
 Extern inline functions and C++ COMDAT functions can be made local
 at the expense of possible code size growth if function is used in multiple
 compilation units.  */
2437bool
2438cgraph_node::can_be_local_p (void)
2439{
return (!address_taken
 && !call_for_symbol_thunks_and_aliases (cgraph_node_cannot_be_local_p_1,
				NULL__null, true));
2443}

2445/* Call callback on cgraph_node, thunks and aliases associated to cgraph_node.
 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
 skipped.  When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
 skipped.  */
2449bool
2450cgraph_node::call_for_symbol_thunks_and_aliases (bool (*callback)
				   (cgraph_node *, void *),
				 void *data,
				 bool include_overwritable,
				 bool exclude_virtual_thunks)
2455{
cgraph_edge *e;
ipa_ref *ref;
enum availability avail = AVAIL_AVAILABLE;

if (include_overwritable
    || (avail = get_availability ()) > AVAIL_INTERPOSABLE)
  {
    if (callback (this, data))
return true;
  }
FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
  {
    cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    if (include_overwritable
 || alias->get_availability () > AVAIL_INTERPOSABLE)
if (alias->call_for_symbol_thunks_and_aliases (callback, data,
				     include_overwritable,
				     exclude_virtual_thunks))
 return true;
  }
if (avail <= AVAIL_INTERPOSABLE)
  return false;
for (e = callers; e; e = e->next_caller)
  if (e->caller->thunk
&& (include_overwritable
   || e->caller->get_availability () > AVAIL_INTERPOSABLE)
&& !(exclude_virtual_thunks
    && thunk_info::get (e->caller)->virtual_offset_p))
    if (e->caller->call_for_symbol_thunks_and_aliases (callback, data,
				       include_overwritable,
				       exclude_virtual_thunks))
return true;

return false;
2490}

2492/* Worker to bring NODE local.  */

2494bool
2495cgraph_node::make_local (cgraph_node *node, void *)
2496{
gcc_checking_assert (node->can_be_local_p ())((void)(!(node->can_be_local_p ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2497, __FUNCTION__), 0 : 0));
if (DECL_COMDAT (node->decl)((contains_struct_check ((node->decl), (TS_DECL_WITH_VIS),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2498, __FUNCTION__))->decl_with_vis.comdat_flag) || DECL_EXTERNAL (node->decl)((contains_struct_check ((node->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2498, __FUNCTION__))->decl_common.decl_flag_1))
  {
    node->make_decl_local ();
    node->set_section (NULL__null);
    node->set_comdat_group (NULL__null);
    node->externally_visible = false;
    node->forced_by_abi = false;
    node->local = true;
    node->unique_name = ((node->resolution == LDPR_PREVAILING_DEF_IRONLY
	   || node->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP)
	   && !flag_incremental_linkglobal_options.x_flag_incremental_link);
    node->resolution = LDPR_PREVAILING_DEF_IRONLY;
    gcc_assert (node->get_availability () == AVAIL_LOCAL)((void)(!(node->get_availability () == AVAIL_LOCAL) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2510, __FUNCTION__), 0 : 0));
  }
return false;
2513}

2515/* Bring cgraph node local.  */

2517void
2518cgraph_node::make_local (void)
2519{
call_for_symbol_thunks_and_aliases (cgraph_node::make_local, NULL__null, true);
2521}

2523/* Worker to set nothrow flag.  */

2525static void
2526set_nothrow_flag_1 (cgraph_node *node, bool nothrow, bool non_call,
    bool *changed)
2528{
cgraph_edge *e;

if (nothrow && !TREE_NOTHROW (node->decl)((node->decl)->base.nothrow_flag))
  {
    /* With non-call exceptions we can't say for sure if other function body
was not possibly optimized to still throw.  */
    if (!non_call || node->binds_to_current_def_p ())
{
 TREE_NOTHROW (node->decl)((node->decl)->base.nothrow_flag) = true;
 *changed = true;
 for (e = node->callers; e; e = e->next_caller)
   e->can_throw_external = false;
}
  }
else if (!nothrow && TREE_NOTHROW (node->decl)((node->decl)->base.nothrow_flag))
  {
    TREE_NOTHROW (node->decl)((node->decl)->base.nothrow_flag) = false;
    *changed = true;
  }
ipa_ref *ref;
FOR_EACH_ALIAS (node, ref)for (unsigned ref_iter_ = 0; (node)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
  {
    cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    if (!nothrow || alias->get_availability () > AVAIL_INTERPOSABLE)
set_nothrow_flag_1 (alias, nothrow, non_call, changed);
  }
for (cgraph_edge *e = node->callers; e; e = e->next_caller)
  if (e->caller->thunk
&& (!nothrow || e->caller->get_availability () > AVAIL_INTERPOSABLE))
    set_nothrow_flag_1 (e->caller, nothrow, non_call, changed);
2559}

2561/* Set TREE_NOTHROW on NODE's decl and on aliases of NODE
 if any to NOTHROW.  */

2564bool
2565cgraph_node::set_nothrow_flag (bool nothrow)
2566{
bool changed = false;
bool non_call = opt_for_fn (decl, flag_non_call_exceptions)(opts_for_fn (decl)->x_flag_non_call_exceptions);

if (!nothrow || get_availability () > AVAIL_INTERPOSABLE)
  set_nothrow_flag_1 (this, nothrow, non_call, &changed);
else
  {
    ipa_ref *ref;

    FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
{
 cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
 if (!nothrow || alias->get_availability () > AVAIL_INTERPOSABLE)
   set_nothrow_flag_1 (alias, nothrow, non_call, &changed);
}
  }
return changed;
2584}

2586/* Worker to set malloc flag.  */
2587static void
2588set_malloc_flag_1 (cgraph_node *node, bool malloc_p, bool *changed)
2589{
if (malloc_p && !DECL_IS_MALLOC (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2590, __FUNCTION__, (FUNCTION_DECL)))->function_decl.malloc_flag
))
  {
    DECL_IS_MALLOC (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2592, __FUNCTION__, (FUNCTION_DECL)))->function_decl.malloc_flag
) = true;
    *changed = true;
  }

ipa_ref *ref;
FOR_EACH_ALIAS (node, ref)for (unsigned ref_iter_ = 0; (node)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
  {
    cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
    if (!malloc_p || alias->get_availability () > AVAIL_INTERPOSABLE)
set_malloc_flag_1 (alias, malloc_p, changed);
  }

for (cgraph_edge *e = node->callers; e; e = e->next_caller)
  if (e->caller->thunk
&& (!malloc_p || e->caller->get_availability () > AVAIL_INTERPOSABLE))
    set_malloc_flag_1 (e->caller, malloc_p, changed);
2608}

2610/* Set DECL_IS_MALLOC on NODE's decl and on NODE's aliases if any.  */

2612bool
2613cgraph_node::set_malloc_flag (bool malloc_p)
2614{
bool changed = false;

if (!malloc_p || get_availability () > AVAIL_INTERPOSABLE)
  set_malloc_flag_1 (this, malloc_p, &changed);
else
  {
    ipa_ref *ref;

    FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
{
 cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
 if (!malloc_p || alias->get_availability () > AVAIL_INTERPOSABLE)
   set_malloc_flag_1 (alias, malloc_p, &changed);
}
  }
return changed;
2631}

2633/* Worker to set noreturng flag.  */
2634static void
2635set_noreturn_flag_1 (cgraph_node *node, bool noreturn_p, bool *changed)
2636{
if (noreturn_p && !TREE_THIS_VOLATILE (node->decl)((node->decl)->base.volatile_flag))
  {
    TREE_THIS_VOLATILE (node->decl)((node->decl)->base.volatile_flag) = true;
    *changed = true;
  }

ipa_ref *ref;
FOR_EACH_ALIAS (node, ref)for (unsigned ref_iter_ = 0; (node)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
  {
    cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
    if (!noreturn_p || alias->get_availability () > AVAIL_INTERPOSABLE)
set_noreturn_flag_1 (alias, noreturn_p, changed);
  }

for (cgraph_edge *e = node->callers; e; e = e->next_caller)
  if (e->caller->thunk
&& (!noreturn_p || e->caller->get_availability () > AVAIL_INTERPOSABLE))
    set_noreturn_flag_1 (e->caller, noreturn_p, changed);
2655}

2657/* Set TREE_THIS_VOLATILE on NODE's decl and on NODE's aliases if any.  */

2659bool
2660cgraph_node::set_noreturn_flag (bool noreturn_p)
2661{
bool changed = false;

if (!noreturn_p || get_availability () > AVAIL_INTERPOSABLE)
  set_noreturn_flag_1 (this, noreturn_p, &changed);
else
  {
    ipa_ref *ref;

    FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
{
 cgraph_node *alias = dyn_cast<cgraph_node *> (ref->referring);
 if (!noreturn_p || alias->get_availability () > AVAIL_INTERPOSABLE)
   set_noreturn_flag_1 (alias, noreturn_p, &changed);
}
  }
return changed;
2678}

2680/* Worker to set_const_flag.  */

2682static void
2683set_const_flag_1 (cgraph_node *node, bool set_const, bool looping,
  bool *changed)
2685{
/* Static constructors and destructors without a side effect can be
   optimized out.  */
if (set_const && !looping)
  {
    if (DECL_STATIC_CONSTRUCTOR (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2690, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_ctor_flag
))
{
 DECL_STATIC_CONSTRUCTOR (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2692, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_ctor_flag
) = 0;
 *changed = true;
}
    if (DECL_STATIC_DESTRUCTOR (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2695, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_dtor_flag
))
{
 DECL_STATIC_DESTRUCTOR (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2697, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_dtor_flag
) = 0;
 *changed = true;
}
  }
if (!set_const)
  {
    if (TREE_READONLY (node->decl)((non_type_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2703, __FUNCTION__))->base.readonly_flag))
{
 TREE_READONLY (node->decl)((non_type_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2705, __FUNCTION__))->base.readonly_flag) = 0;
 DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2706, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
) = false;
 *changed = true;
}
  }
else
  {
    /* Consider function:

bool a(int *p)
{
  return *p==*p;
}

During early optimization we will turn this into:

bool a(int *p)
{
  return true;
}

Now if this function will be detected as CONST however when interposed
it may end up being just pure.  We always must assume the worst
scenario here.  */
    if (TREE_READONLY (node->decl)((non_type_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2729, __FUNCTION__))->base.readonly_flag))
{
 if (!looping && DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2731, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
))
   {
     DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2733, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
) = false;
     *changed = true;
   }
}
    else if (node->binds_to_current_def_p ())
{
 TREE_READONLY (node->decl)((non_type_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2739, __FUNCTION__))->base.readonly_flag) = true;
 DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2740, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
) = looping;
 DECL_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2741, __FUNCTION__, (FUNCTION_DECL)))->function_decl.pure_flag
) = false;
 *changed = true;
}
    else
{
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, "Dropping state to PURE because function does "
     "not bind to current def.\n");
 if (!DECL_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2749, __FUNCTION__, (FUNCTION_DECL)))->function_decl.pure_flag
))
   {
     DECL_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2751, __FUNCTION__, (FUNCTION_DECL)))->function_decl.pure_flag
) = true;
     DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2752, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
) = looping;
     *changed = true;
   }
 else if (!looping && DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2755, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
))
   {
     DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2757, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
) = false;
     *changed = true;
   }
}
  }

ipa_ref *ref;
FOR_EACH_ALIAS (node, ref)for (unsigned ref_iter_ = 0; (node)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
  {
    cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    if (!set_const || alias->get_availability () > AVAIL_INTERPOSABLE)
set_const_flag_1 (alias, set_const, looping, changed);
  }
for (struct cgraph_node *n = node->simd_clones; n != NULL__null;
     n = n->simdclone->next_clone)
  set_const_flag_1 (n, set_const, looping, changed);
for (cgraph_edge *e = node->callers; e; e = e->next_caller)
  if (e->caller->thunk
&& (!set_const || e->caller->get_availability () > AVAIL_INTERPOSABLE))
    {
/* Virtual thunks access virtual offset in the vtable, so they can
  only be pure, never const.  */
if (set_const
   && (thunk_info::get (e->caller)->virtual_offset_p
|| !node->binds_to_current_def_p (e->caller)))
 *changed |= e->caller->set_pure_flag (true, looping);
else
 set_const_flag_1 (e->caller, set_const, looping, changed);
    }
2786}

2788/* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST.
 If SET_CONST if false, clear the flag.

 When setting the flag be careful about possible interposition and
 do not set the flag for functions that can be interposed and set pure
 flag for functions that can bind to other definition. 

 Return true if any change was done. */

2797bool
2798cgraph_node::set_const_flag (bool set_const, bool looping)
2799{
bool changed = false;
if (!set_const || get_availability () > AVAIL_INTERPOSABLE)
  set_const_flag_1 (this, set_const, looping, &changed);
else
  {
    ipa_ref *ref;

    FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
{
 cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
 if (!set_const || alias->get_availability () > AVAIL_INTERPOSABLE)
   set_const_flag_1 (alias, set_const, looping, &changed);
}
  }
return changed;
2815}

2817/* Info used by set_pure_flag_1.  */

2819struct set_pure_flag_info
2820{
bool pure;
bool looping;
bool changed;
2824};

2826/* Worker to set_pure_flag.  */

2828static bool
2829set_pure_flag_1 (cgraph_node *node, void *data)
2830{
struct set_pure_flag_info *info = (struct set_pure_flag_info *)data;
/* Static constructors and destructors without a side effect can be
   optimized out.  */
if (info->pure && !info->looping)
  {
    if (DECL_STATIC_CONSTRUCTOR (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2836, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_ctor_flag
))
{
 DECL_STATIC_CONSTRUCTOR (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2838, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_ctor_flag
) = 0;
 info->changed = true;
}
    if (DECL_STATIC_DESTRUCTOR (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2841, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_dtor_flag
))
{
 DECL_STATIC_DESTRUCTOR (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2843, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_dtor_flag
) = 0;
 info->changed = true;
}
  }
if (info->pure)
  {
    if (!DECL_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2849, __FUNCTION__, (FUNCTION_DECL)))->function_decl.pure_flag
) && !TREE_READONLY (node->decl)((non_type_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2849, __FUNCTION__))->base.readonly_flag))
{
 DECL_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2851, __FUNCTION__, (FUNCTION_DECL)))->function_decl.pure_flag
) = true;
 DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2852, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
) = info->looping;
 info->changed = true;
}
    else if (DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2855, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
)
      && !info->looping)
{
 DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2858, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
) = false;
 info->changed = true;
}
  }
else
  {
    if (DECL_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2864, __FUNCTION__, (FUNCTION_DECL)))->function_decl.pure_flag
))
{
 DECL_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2866, __FUNCTION__, (FUNCTION_DECL)))->function_decl.pure_flag
) = false;
 DECL_LOOPING_CONST_OR_PURE_P (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2867, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
) = false;
 info->changed = true;
}
  }
return false;
2872}

2874/* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node
 if any to PURE.

 When setting the flag, be careful about possible interposition.
 Return true if any change was done. */

2880bool
2881cgraph_node::set_pure_flag (bool pure, bool looping)
2882{
struct set_pure_flag_info info = {pure, looping, false};
call_for_symbol_thunks_and_aliases (set_pure_flag_1, &info, !pure, true);
for (struct cgraph_node *n = simd_clones; n != NULL__null;
     n = n->simdclone->next_clone)
  set_pure_flag_1 (n, &info);
return info.changed;
2889}

2891/* Return true when cgraph_node cannot return or throw and thus
 it is safe to ignore its side effects for IPA analysis.  */

2894bool
2895cgraph_node::cannot_return_p (void)
2896{
int flags = flags_from_decl_or_type (decl);
if (!opt_for_fn (decl, flag_exceptions)(opts_for_fn (decl)->x_flag_exceptions))
  return (flags & ECF_NORETURN(1 << 3)) != 0;
else
  return ((flags & (ECF_NORETURN(1 << 3) | ECF_NOTHROW(1 << 6)))
    == (ECF_NORETURN(1 << 3) | ECF_NOTHROW(1 << 6)));
2903}

2905/* Return true when call of edge cannot lead to return from caller
 and thus it is safe to ignore its side effects for IPA analysis
 when computing side effects of the caller.
 FIXME: We could actually mark all edges that have no reaching
 patch to the exit block or throw to get better results.  */
2910bool
2911cgraph_edge::cannot_lead_to_return_p (void)
2912{
if (caller->cannot_return_p ())
  return true;
if (indirect_unknown_callee)
  {
    int flags = indirect_info->ecf_flags;
    if (!opt_for_fn (caller->decl, flag_exceptions)(opts_for_fn (caller->decl)->x_flag_exceptions))
return (flags & ECF_NORETURN(1 << 3)) != 0;
    else
return ((flags & (ECF_NORETURN(1 << 3) | ECF_NOTHROW(1 << 6)))
 == (ECF_NORETURN(1 << 3) | ECF_NOTHROW(1 << 6)));
  }
else
  return callee->cannot_return_p ();
2926}

2928/* Return true if the edge may be considered hot.  */

2930bool
2931cgraph_edge::maybe_hot_p (void)
2932{
if (!maybe_hot_count_p (NULL__null, count.ipa ()))
  return false;
if (caller->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
    || (callee
 && callee->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED))
  return false;
if (caller->frequency > NODE_FREQUENCY_UNLIKELY_EXECUTED
    && (callee
 && callee->frequency <= NODE_FREQUENCY_EXECUTED_ONCE))
  return false;
if (opt_for_fn (caller->decl, optimize_size)(opts_for_fn (caller->decl)->x_optimize_size))
  return false;
if (caller->frequency == NODE_FREQUENCY_HOT)
  return true;
if (!count.initialized_p ())
  return true;
cgraph_node *where = caller->inlined_to ? caller->inlined_to : caller;
if (!where->count.initialized_p ())
  return false;
if (caller->frequency == NODE_FREQUENCY_EXECUTED_ONCE)
  {
    if (count * 2 < where->count * 3)
return false;
  }
else if (count * param_hot_bb_frequency_fractionglobal_options.x_param_hot_bb_frequency_fraction < where->count)
  return false;
return true;
2960}

2962/* Worker for cgraph_can_remove_if_no_direct_calls_p.  */

2964static bool
2965nonremovable_p (cgraph_node *node, void *)
2966{
return !node->can_remove_if_no_direct_calls_and_refs_p ();
2968}

2970/* Return true if whole comdat group can be removed if there are no direct
 calls to THIS.  */

2973bool
2974cgraph_node::can_remove_if_no_direct_calls_p (bool will_inline)
2975{
struct ipa_ref *ref;

/* For local symbols or non-comdat group it is the same as 
   can_remove_if_no_direct_calls_p.  */
if (!externally_visible || !same_comdat_group)
  {
    if (DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 2982, __FUNCTION__))->decl_common.decl_flag_1))
return true;
    if (address_taken)
return false;
    return !call_for_symbol_and_aliases (nonremovable_p, NULL__null, true);
  }

if (will_inline && address_taken)
  return false;

/* Otherwise check if we can remove the symbol itself and then verify
   that only uses of the comdat groups are direct call to THIS
   or its aliases.   */
if (!can_remove_if_no_direct_calls_and_refs_p ())
  return false;

/* Check that all refs come from within the comdat group.  */
for (int i = 0; iterate_referring (i, ref); i++)
  if (ref->referring->get_comdat_group () != get_comdat_group ())
    return false;

struct cgraph_node *target = ultimate_alias_target ();
for (cgraph_node *next = dyn_cast<cgraph_node *> (same_comdat_group);
     next != this; next = dyn_cast<cgraph_node *> (next->same_comdat_group))
  {
    if (!externally_visible)
continue;
    if (!next->alias
 && !next->can_remove_if_no_direct_calls_and_refs_p ())
return false;

    /* If we see different symbol than THIS, be sure to check calls.  */
    if (next->ultimate_alias_target () != target)
for (cgraph_edge *e = next->callers; e; e = e->next_caller)
 if (e->caller->get_comdat_group () != get_comdat_group ()
     || will_inline)
   return false;

    /* If function is not being inlined, we care only about
references outside of the comdat group.  */
    if (!will_inline)
for (int i = 0; next->iterate_referring (i, ref); i++)
 if (ref->referring->get_comdat_group () != get_comdat_group ())
   return false;
  }
return true;
3028}

3030/* Return true when function cgraph_node can be expected to be removed
 from program when direct calls in this compilation unit are removed.

 As a special case COMDAT functions are
 cgraph_can_remove_if_no_direct_calls_p while the are not
 cgraph_only_called_directly_p (it is possible they are called from other
 unit)

 This function behaves as cgraph_only_called_directly_p because eliminating
 all uses of COMDAT function does not make it necessarily disappear from
 the program unless we are compiling whole program or we do LTO.  In this
 case we know we win since dynamic linking will not really discard the
 linkonce section.  */

3044bool
3045cgraph_node::will_be_removed_from_program_if_no_direct_calls_p
(bool will_inline)
3047{
gcc_assert (!inlined_to)((void)(!(!inlined_to) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3048, __FUNCTION__), 0 : 0));
if (DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3049, __FUNCTION__))->decl_common.decl_flag_1))
  return true;

if (!in_lto_pglobal_options.x_in_lto_p && !flag_whole_programglobal_options.x_flag_whole_program)
  {
    /* If the symbol is in comdat group, we need to verify that whole comdat
group becomes unreachable.  Technically we could skip references from
within the group, too.  */
    if (!only_called_directly_p ())
return false;
    if (same_comdat_group && externally_visible)
{
 struct cgraph_node *target = ultimate_alias_target ();

 if (will_inline && address_taken)
   return true;
 for (cgraph_node *next = dyn_cast<cgraph_node *> (same_comdat_group);
      next != this;
      next = dyn_cast<cgraph_node *> (next->same_comdat_group))
   {
     if (!externally_visible)
continue;
     if (!next->alias
  && !next->only_called_directly_p ())
return false;

     /* If we see different symbol than THIS,
 be sure to check calls.  */
     if (next->ultimate_alias_target () != target)
for (cgraph_edge *e = next->callers; e; e = e->next_caller)
  if (e->caller->get_comdat_group () != get_comdat_group ()
      || will_inline)
    return false;
   }
}
    return true;
  }
else
  return can_remove_if_no_direct_calls_p (will_inline);
3088}


3091/* Worker for cgraph_only_called_directly_p.  */

3093static bool
3094cgraph_not_only_called_directly_p_1 (cgraph_node *node, void *)
3095{
return !node->only_called_directly_or_aliased_p ();
3097}

3099/* Return true when function cgraph_node and all its aliases are only called
 directly.
 i.e. it is not externally visible, address was not taken and
 it is not used in any other non-standard way.  */

3104bool
3105cgraph_node::only_called_directly_p (void)
3106{
gcc_assert (ultimate_alias_target () == this)((void)(!(ultimate_alias_target () == this) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3107, __FUNCTION__), 0 : 0));
return !call_for_symbol_and_aliases (cgraph_not_only_called_directly_p_1,
		       NULL__null, true);
3110}


3113/* Collect all callers of NODE.  Worker for collect_callers_of_node.  */

3115static bool
3116collect_callers_of_node_1 (cgraph_node *node, void *data)
3117{
vec<cgraph_edge *> *redirect_callers = (vec<cgraph_edge *> *)data;
cgraph_edge *cs;
enum availability avail;
node->ultimate_alias_target (&avail);

if (avail > AVAIL_INTERPOSABLE)
  for (cs = node->callers; cs != NULL__null; cs = cs->next_caller)
    if (!cs->indirect_inlining_edge
 && !cs->caller->thunk)
redirect_callers->safe_push (cs);
return false;
3129}

3131/* Collect all callers of cgraph_node and its aliases that are known to lead to
 cgraph_node (i.e. are not overwritable).  */

3134auto_vec<cgraph_edge *>
3135cgraph_node::collect_callers (void)
3136{
auto_vec<cgraph_edge *> redirect_callers;
call_for_symbol_thunks_and_aliases (collect_callers_of_node_1,
		    &redirect_callers, false);
return redirect_callers;
3141}


3144/* Return TRUE if NODE2 a clone of NODE or is equivalent to it.  Return
 optimistically true if this cannot be determined.  */

3147static bool
3148clone_of_p (cgraph_node *node, cgraph_node *node2)
3149{
node = node->ultimate_alias_target ();
node2 = node2->ultimate_alias_target ();

if (node2->clone_of == node
    || node2->former_clone_of == node->decl)
  return true;

if (!node->thunk && !node->former_thunk_p ())
  {
    while (node2
    && node->decl != node2->decl
    && node->decl != node2->former_clone_of)
node2 = node2->clone_of;
    return node2 != NULL__null;
  }

/* There are no virtual clones of thunks so check former_clone_of or if we
   might have skipped thunks because this adjustments are no longer
   necessary.  */
while (node->thunk || node->former_thunk_p ())
  {
    if (!thunk_info::get (node)->this_adjusting)
return false;
    /* In case of instrumented expanded thunks, which can have multiple calls
in them, we do not know how to continue and just have to be
optimistic.  The same applies if all calls have already been inlined
into the thunk.  */
    if (!node->callees || node->callees->next_callee)
return true;
    node = node->callees->callee->ultimate_alias_target ();

    clone_info *info = clone_info::get (node2);
    if (!info || !info->param_adjustments
 || info->param_adjustments->first_param_intact_p ())
return false;
    if (node2->former_clone_of == node->decl
 || node2->former_clone_of == node->former_clone_of)
return true;

    cgraph_node *n2 = node2;
    while (n2 && node->decl != n2->decl)
n2 = n2->clone_of;
    if (n2)
return true;
  }

return false;
3197}

3199/* Verify edge count and frequency.  */

3201bool
3202cgraph_edge::verify_count ()
3203{
bool error_found = false;
if (!count.verify ())
  {
    error ("caller edge count invalid");
    error_found = true;
  }
return error_found;
3211}

3213/* Switch to THIS_CFUN if needed and print STMT to stderr.  */
3214static void
3215cgraph_debug_gimple_stmt (function *this_cfun, gimple *stmt)
3216{
bool fndecl_was_null = false;
/* debug_gimple_stmt needs correct cfun */
if (cfun(cfun + 0) != this_cfun)
  set_cfun (this_cfun);
/* ...and an actual current_function_decl */
if (!current_function_decl)
  {
    current_function_decl = this_cfun->decl;
    fndecl_was_null = true;
  }
debug_gimple_stmt (stmt);
if (fndecl_was_null)
  current_function_decl = NULL__null;
3230}

3232/* Verify that call graph edge corresponds to DECL from the associated
 statement.  Return true if the verification should fail.  */

3235bool
3236cgraph_edge::verify_corresponds_to_fndecl (tree decl)
3237{
cgraph_node *node;

if (!decl || callee->inlined_to)
  return false;
if (symtab->state == LTO_STREAMING)
  return false;
node = cgraph_node::get (decl);

/* We do not know if a node from a different partition is an alias or what it
   aliases and therefore cannot do the former_clone_of check reliably.  When
   body_removed is set, we have lost all information about what was alias or
   thunk of and also cannot proceed.  */
if (!node
    || node->body_removed
    || node->in_other_partition
    || callee->icf_merged
    || callee->in_other_partition)
  return false;

node = node->ultimate_alias_target ();

/* Optimizers can redirect unreachable calls or calls triggering undefined
   behavior to __builtin_unreachable or __builtin_unreachable trap.  */

if (fndecl_built_in_p (callee->decl, BUILT_IN_NORMAL)
    && (DECL_FUNCTION_CODE (callee->decl) == BUILT_IN_UNREACHABLE
 || DECL_FUNCTION_CODE (callee->decl) == BUILT_IN_UNREACHABLE_TRAP))
  return false;

if (callee->former_clone_of != node->decl
    && (node != callee->ultimate_alias_target ())
    && !clone_of_p (node, callee))
  return true;
else
  return false;
3273}

3275/* Disable warnings about missing quoting in GCC diagnostics for
 the verification errors.  Their format strings don't follow GCC
 diagnostic conventions and the calls are ultimately followed by
 one to internal_error.  */
3279#if __GNUC__4 >= 10
3280#  pragma GCC diagnostic push
3281#  pragma GCC diagnostic ignored "-Wformat-diag"
3282#endif

3284/* Verify consistency of speculative call in NODE corresponding to STMT
 and LTO_STMT_UID.  If INDIRECT is set, assume that it is the indirect
 edge of call sequence. Return true if error is found.

 This function is called to every component of indirect call (direct edges,
 indirect edge and refs).  To save duplicated work, do full testing only
 in that case.  */
3291static bool
3292verify_speculative_call (struct cgraph_node *node, gimple *stmt,
	 unsigned int lto_stmt_uid,
	 struct cgraph_edge *indirect)
3295{
if (indirect == NULL__null)
  {
    for (indirect = node->indirect_calls; indirect;
  indirect = indirect->next_callee)
if (indirect->call_stmt == stmt
   && indirect->lto_stmt_uid == lto_stmt_uid)
 break;
    if (!indirect)
{
 error ("missing indirect call in speculative call sequence");
 return true;
}
    if (!indirect->speculative)
{
 error ("indirect call in speculative call sequence has no "
 "speculative flag");
 return true;
}
    return false;
  }

/* Maximal number of targets.  We probably will never want to have more than
   this.  */
const unsigned int num = 256;
cgraph_edge *direct_calls[num];
ipa_ref *refs[num];

for (unsigned int i = 0; i < num; i++)
  {
    direct_calls[i] = NULL__null;
    refs[i] = NULL__null;
  }

cgraph_edge *first_call = NULL__null;
cgraph_edge *prev_call = NULL__null;

for (cgraph_edge *direct = node->callees; direct;
     direct = direct->next_callee)
  if (direct->call_stmt == stmt && direct->lto_stmt_uid == lto_stmt_uid)
    {
if (!first_call)
 first_call = direct;
if (prev_call && direct != prev_call->next_callee)
 {
   error ("speculative edges are not adjacent");
   return true;
 }
prev_call = direct;
if (!direct->speculative)
 {
   error ("direct call to %s in speculative call sequence has no "
   "speculative flag", direct->callee->dump_name ());
   return true;
 }
if (direct->speculative_id >= num)
 {
   error ("direct call to %s in speculative call sequence has "
   "speculative_id %i out of range",
   direct->callee->dump_name (), direct->speculative_id);
   return true;
 }
if (direct_calls[direct->speculative_id])
 {
   error ("duplicate direct call to %s in speculative call sequence "
   "with speculative_id %i",
   direct->callee->dump_name (), direct->speculative_id);
   return true;
 }
direct_calls[direct->speculative_id] = direct;
    }

if (first_call->call_stmt
    && first_call != node->get_edge (first_call->call_stmt))
  {
    error ("call stmt hash does not point to first direct edge of "
    "speculative call sequence");
    return true;
  }

ipa_ref *ref;
for (int i = 0; node->iterate_reference (i, ref); i++)
  if (ref->speculative
&& ref->stmt == stmt && ref->lto_stmt_uid == lto_stmt_uid)
    {
if (ref->speculative_id >= num)
 {
   error ("direct call to %s in speculative call sequence has "
   "speculative_id %i out of range",
   ref->referred->dump_name (), ref->speculative_id);
   return true;
 }
if (refs[ref->speculative_id])
 {
   error ("duplicate reference %s in speculative call sequence "
   "with speculative_id %i",
   ref->referred->dump_name (), ref->speculative_id);
   return true;
 }
refs[ref->speculative_id] = ref;
    }

int num_targets = 0;
for (unsigned int i = 0 ; i < num ; i++)
  {
    if (refs[i] && !direct_calls[i])
{
 error ("missing direct call for speculation %i", i);
 return true;
}
    if (!refs[i] && direct_calls[i])
{
 error ("missing ref for speculation %i", i);
 return true;
}
    if (refs[i] != NULL__null)
num_targets++;
  }

if (num_targets != indirect->num_speculative_call_targets_p ())
  {
    error ("number of speculative targets %i mismatched with "
    "num_speculative_call_targets %i",
    num_targets,
    indirect->num_speculative_call_targets_p ());
    return true;
  }
return false;
3423}

3425/* Verify cgraph nodes of given cgraph node.  */
3426DEBUG_FUNCTION__attribute__ ((__used__)) void
3427cgraph_node::verify_node (void)
3428{
cgraph_edge *e;
function *this_cfun = DECL_STRUCT_FUNCTION (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3430, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);
basic_block this_block;
gimple_stmt_iterator gsi;
bool error_found = false;
int i;
ipa_ref *ref = NULL__null;

if (seen_error ())
  return;

timevar_push (TV_CGRAPH_VERIFY);
error_found |= verify_base ();
for (e = callees; e; e = e->next_callee)
  if (e->aux)
    {
error ("aux field set for edge %s->%s",
      identifier_to_locale (e->caller->name ()),
      identifier_to_locale (e->callee->name ()));
error_found = true;
    }
if (!count.verify ())
  {
    error ("cgraph count invalid");
    error_found = true;
  }
if (inlined_to && same_comdat_group)
  {
    error ("inline clone in same comdat group list");
    error_found = true;
  }
if (inlined_to && !count.compatible_p (inlined_to->count))
  {
    error ("inline clone count is not compatible");
    count.debug ();
    inlined_to->count.debug ();
    error_found = true;
  }
if (tp_first_run < 0)
  {
    error ("tp_first_run must be non-negative");
    error_found = true;
  }
if (!definition && !in_other_partition && local)
  {
    error ("local symbols must be defined");
    error_found = true;
  }
if (inlined_to && externally_visible)
  {
    error ("externally visible inline clone");
    error_found = true;
  }
if (inlined_to && address_taken)
  {
    error ("inline clone with address taken");
    error_found = true;
  }
if (inlined_to && force_output)
  {
    error ("inline clone is forced to output");
    error_found = true;
  }
if (symtab->state != LTO_STREAMING)
  {
    if (calls_comdat_local && !same_comdat_group)
{
 error ("calls_comdat_local is set outside of a comdat group");
 error_found = true;
}
    if (!inlined_to && calls_comdat_local != check_calls_comdat_local_p ())
{
 error ("invalid calls_comdat_local flag");
 error_found = true;
}
  }
if (DECL_IS_MALLOC (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3505, __FUNCTION__, (FUNCTION_DECL)))->function_decl.malloc_flag
)
    && !POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (decl)))(((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3506, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3506, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3506, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3506, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
  {
    error ("malloc attribute should be used for a function that "
    "returns a pointer");
    error_found = true;
  }
if (definition
    && externally_visible
    /* For aliases in lto1 free_lang_data doesn't guarantee preservation
of opt_for_fn (decl, flag_semantic_interposition).  See PR105399.  */
    && (!alias || !in_lto_pglobal_options.x_in_lto_p)
    && semantic_interposition
!= opt_for_fn (decl, flag_semantic_interposition)(opts_for_fn (decl)->x_flag_semantic_interposition))
  {
    error ("semantic interposition mismatch");
    error_found = true;
  }
for (e = indirect_calls; e; e = e->next_callee)
  {
    if (e->aux)
{
 error ("aux field set for indirect edge from %s",
 identifier_to_locale (e->caller->name ()));
 error_found = true;
}
    if (!e->count.compatible_p (count))
{
 error ("edge count is not compatible with function count");
 e->count.debug ();
 count.debug ();
 error_found = true;
}
    if (!e->indirect_unknown_callee
 || !e->indirect_info)
{
 error ("An indirect edge from %s is not marked as indirect or has "
 "associated indirect_info, the corresponding statement is: ",
 identifier_to_locale (e->caller->name ()));
 cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
 error_found = true;
}
    if (e->call_stmt && e->lto_stmt_uid)
{
 error ("edge has both call_stmt and lto_stmt_uid set");
 error_found = true;
}
  }
bool check_comdat = comdat_local_p ();
for (e = callers; e; e = e->next_caller)
  {
    if (e->verify_count ())
error_found = true;
    if (check_comdat
 && !in_same_comdat_group_p (e->caller))
{
 error ("comdat-local function called by %s outside its comdat",
 identifier_to_locale (e->caller->name ()));
 error_found = true;
}
    if (!e->inline_failed)
{
 if (inlined_to
     != (e->caller->inlined_to
  ? e->caller->inlined_to : e->caller))
   {
     error ("inlined_to pointer is wrong");
     error_found = true;
   }
 if (callers->next_caller)
   {
     error ("multiple inline callers");
     error_found = true;
   }
}
    else
if (inlined_to)
 {
   error ("inlined_to pointer set for noninline callers");
   error_found = true;
 }
  }
for (e = callees; e; e = e->next_callee)
  {
    if (e->verify_count ())
error_found = true;
    if (!e->count.compatible_p (count))
{
 error ("edge count is not compatible with function count");
 e->count.debug ();
 count.debug ();
 error_found = true;
}
    if (gimple_has_body_p (e->caller->decl)
 && !e->caller->inlined_to
 && !e->speculative
 /* Optimized out calls are redirected to __builtin_unreachable.  */
 && (e->count.nonzero_p ()
     || ! e->callee->decl
     || !(fndecl_built_in_p (e->callee->decl, BUILT_IN_UNREACHABLE)
   || fndecl_built_in_p (e->callee->decl,
			 BUILT_IN_UNREACHABLE_TRAP)))
 && count
     == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl))((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3608, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))
->cfg->x_entry_block_ptr)->count
 && (!e->count.ipa_p ()
     && e->count.differs_from_p (gimple_bb (e->call_stmt)->count)))
{
 error ("caller edge count does not match BB count");
 fprintf (stderrstderr, "edge count: ");
 e->count.dump (stderrstderr);
 fprintf (stderrstderr, "\n bb count: ");
 gimple_bb (e->call_stmt)->count.dump (stderrstderr);
 fprintf (stderrstderr, "\n");
 error_found = true;
}
    if (e->call_stmt && e->lto_stmt_uid)
{
 error ("edge has both call_stmt and lto_stmt_uid set");
 error_found = true;
}
    if (e->speculative
 && verify_speculative_call (e->caller, e->call_stmt, e->lto_stmt_uid,
		      NULL__null))
error_found = true;
  }
for (e = indirect_calls; e; e = e->next_callee)
  {
    if (e->verify_count ())
error_found = true;
    if (gimple_has_body_p (e->caller->decl)
 && !e->caller->inlined_to
 && !e->speculative
 && e->count.ipa_p ()
 && count
     == ENTRY_BLOCK_PTR_FOR_FN (DECL_STRUCT_FUNCTION (decl))((((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3639, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))
->cfg->x_entry_block_ptr)->count
 && (!e->count.ipa_p ()
     && e->count.differs_from_p (gimple_bb (e->call_stmt)->count)))
{
 error ("indirect call count does not match BB count");
 fprintf (stderrstderr, "edge count: ");
 e->count.dump (stderrstderr);
 fprintf (stderrstderr, "\n bb count: ");
 gimple_bb (e->call_stmt)->count.dump (stderrstderr);
 fprintf (stderrstderr, "\n");
 error_found = true;
}
    if (e->speculative
 && verify_speculative_call (e->caller, e->call_stmt, e->lto_stmt_uid,
		      e))
error_found = true;
  }
for (i = 0; iterate_reference (i, ref); i++)
  {
    if (ref->stmt && ref->lto_stmt_uid)
{
 error ("reference has both stmt and lto_stmt_uid set");
 error_found = true;
}
    if (ref->speculative
 && verify_speculative_call (this, ref->stmt,
		      ref->lto_stmt_uid, NULL__null))
error_found = true;
  }

if (!callers && inlined_to)
  {
    error ("inlined_to pointer is set but no predecessors found");
    error_found = true;
  }
if (inlined_to == this)
  {
    error ("inlined_to pointer refers to itself");
    error_found = true;
  }

if (clone_of)
  {
    cgraph_node *first_clone = clone_of->clones;
    if (first_clone != this)
{
 if (prev_sibling_clone->clone_of != clone_of)
   {
     error ("cgraph_node has wrong clone_of");
     error_found = true;
   }
}
  }
if (clones)
  {
    cgraph_node *n;
    for (n = clones; n; n = n->next_sibling_clone)
if (n->clone_of != this)
 break;
    if (n)
{
 error ("cgraph_node has wrong clone list");
 error_found = true;
}
  }
if ((prev_sibling_clone || next_sibling_clone) && !clone_of)
  {
     error ("cgraph_node is in clone list but it is not clone");
     error_found = true;
  }
if (!prev_sibling_clone && clone_of && clone_of->clones != this)
  {
    error ("cgraph_node has wrong prev_clone pointer");
    error_found = true;
  }
if (prev_sibling_clone && prev_sibling_clone->next_sibling_clone != this)
  {
    error ("double linked list of clones corrupted");
    error_found = true;
  }

if (analyzed && alias)
  {
    bool ref_found = false;
    int i;
    ipa_ref *ref = NULL__null;

    if (callees)
{
 error ("Alias has call edges");
 error_found = true;
}
    for (i = 0; iterate_reference (i, ref); i++)
if (ref->use != IPA_REF_ALIAS)
 {
   error ("Alias has non-alias reference");
   error_found = true;
 }
else if (ref_found)
 {
   error ("Alias has more than one alias reference");
   error_found = true;
 }
else
 ref_found = true;
    if (!ref_found)
{
 error ("Analyzed alias has no reference");
 error_found = true;
}
  }

if (analyzed && thunk)
  {
    if (!callees)
{
 error ("No edge out of thunk node");
 error_found = true;
}
    else if (callees->next_callee)
{
 error ("More than one edge out of thunk node");
 error_found = true;
}
    if (gimple_has_body_p (decl) && !inlined_to)
{
 error ("Thunk is not supposed to have body");
 error_found = true;
}
  }
else if (analyzed && gimple_has_body_p (decl)
  && !TREE_ASM_WRITTEN (decl)((decl)->base.asm_written_flag)
  && (!DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3771, __FUNCTION__))->decl_common.decl_flag_1) || inlined_to)
  && !flag_wpaglobal_options.x_flag_wpa)
  {
    if ((this_cfun->curr_properties & PROP_assumptions_done(1 << 19)) != 0)
;
    else if (this_cfun->cfg)
{
 hash_set<gimple *> stmts;

 /* Reach the trees by walking over the CFG, and note the
    enclosing basic-blocks in the call edges.  */
 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)
   {
     for (gsi = gsi_start_phis (this_block);
   !gsi_end_p (gsi); gsi_next (&gsi))
stmts.add (gsi_stmt (gsi));
     for (gsi = gsi_start_bb (this_block);
   !gsi_end_p (gsi);
   gsi_next (&gsi))
{
  gimple *stmt = gsi_stmt (gsi);
  stmts.add (stmt);
  if (is_gimple_call (stmt))
    {
      cgraph_edge *e = get_edge (stmt);
      tree decl = gimple_call_fndecl (stmt);
      if (e)
	{
	  if (e->aux)
	    {
	      error ("shared call_stmt:");
	      cgraph_debug_gimple_stmt (this_cfun, stmt);
	      error_found = true;
	    }
	  if (!e->indirect_unknown_callee)
	    {
	      if (e->verify_corresponds_to_fndecl (decl))
		{
		  error ("edge points to wrong declaration:");
		  debug_tree (e->callee->decl);
		  fprintf (stderrstderr," Instead of:");
		  debug_tree (decl);
		  error_found = true;
		}
	    }
	  else if (decl)
	    {
	      error ("an indirect edge with unknown callee "
		     "corresponding to a call_stmt with "
		     "a known declaration:");
	      error_found = true;
	      cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
	    }
	  e->aux = (void *)1;
	}
      else if (decl)
	{
	  error ("missing callgraph edge for call stmt:");
	  cgraph_debug_gimple_stmt (this_cfun, stmt);
	  error_found = true;
	}
    }
}
     }
   for (i = 0; iterate_reference (i, ref); i++)
     if (ref->stmt && !stmts.contains (ref->stmt))
{
  error ("reference to dead statement");
  cgraph_debug_gimple_stmt (this_cfun, ref->stmt);
  error_found = true;
}
}
    else
/* No CFG available?!  */
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 3845, __FUNCTION__));

    for (e = callees; e; e = e->next_callee)
{
 if (!e->aux && !e->speculative)
   {
     error ("edge %s->%s has no corresponding call_stmt",
     identifier_to_locale (e->caller->name ()),
     identifier_to_locale (e->callee->name ()));
     cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
     error_found = true;
   }
 e->aux = 0;
}
    for (e = indirect_calls; e; e = e->next_callee)
{
 if (!e->aux && !e->speculative)
   {
     error ("an indirect edge from %s has no corresponding call_stmt",
     identifier_to_locale (e->caller->name ()));
     cgraph_debug_gimple_stmt (this_cfun, e->call_stmt);
     error_found = true;
   }
 e->aux = 0;
}
  }

if (nested_function_info *info = nested_function_info::get (this))
  {
    if (info->nested != NULL__null)
{
 for (cgraph_node *n = info->nested; n != NULL__null;
      n = next_nested_function (n))
   {
     nested_function_info *ninfo = nested_function_info::get (n);
     if (ninfo->origin == NULL__null)
{
  error ("missing origin for a node in a nested list");
  error_found = true;
}
     else if (ninfo->origin != this)
{
  error ("origin points to a different parent");
  error_found = true;
  break;
}
   }
}
    if (info->next_nested != NULL__null && info->origin == NULL__null)
{
 error ("missing origin for a node in a nested list");
 error_found = true;
}
  }

if (error_found)
  {
    dump (stderrstderr);
    internal_error ("verify_cgraph_node failed");
  }
timevar_pop (TV_CGRAPH_VERIFY);
3906}

3908/* Verify whole cgraph structure.  */
3909DEBUG_FUNCTION__attribute__ ((__used__)) void
3910cgraph_node::verify_cgraph_nodes (void)
3911{
cgraph_node *node;

if (seen_error ())
  return;

FOR_EACH_FUNCTION (node)for ((node) = symtab->first_function (); (node); (node) = symtab
->next_function ((node)))
  node->verify ();
3919}

3921#if __GNUC__4 >= 10
3922#  pragma GCC diagnostic pop
3923#endif

3925/* Walk the alias chain to return the function cgraph_node is alias of.
 Walk through thunks, too.
 When AVAILABILITY is non-NULL, get minimal availability in the chain.
 When REF is non-NULL, assume that reference happens in symbol REF
 when determining the availability.  */

3931cgraph_node *
3932cgraph_node::function_symbol (enum availability *availability,
	      struct symtab_node *ref)
3934{
cgraph_node *node = ultimate_alias_target (availability, ref);

while (node->thunk)
  {
    enum availability a;

    ref = node;
    node = node->callees->callee;
    node = node->ultimate_alias_target (availability ? &a : NULL__null, ref);
    if (availability && a < *availability)
*availability = a;
  }
return node;
3948}

3950/* Walk the alias chain to return the function cgraph_node is alias of.
 Walk through non virtual thunks, too.  Thus we return either a function
 or a virtual thunk node.
 When AVAILABILITY is non-NULL, get minimal availability in the chain. 
 When REF is non-NULL, assume that reference happens in symbol REF
 when determining the availability.  */

3957cgraph_node *
3958cgraph_node::function_or_virtual_thunk_symbol
		(enum availability *availability,
		 struct symtab_node *ref)
3961{
cgraph_node *node = ultimate_alias_target (availability, ref);

while (node->thunk && !thunk_info::get (node)->virtual_offset_p)
  {
    enum availability a;

    ref = node;
    node = node->callees->callee;
    node = node->ultimate_alias_target (availability ? &a : NULL__null, ref);
    if (availability && a < *availability)
*availability = a;
  }
return node;
3975}

3977/* When doing LTO, read cgraph_node's body from disk if it is not already
 present.  Also perform any necessary clone materializations.  */

3980bool
3981cgraph_node::get_untransformed_body ()
3982{
lto_file_decl_data *file_data;
const char *data, *name;
size_t len;
tree decl = this->decl;

/* See if there is clone to be materialized.
   (inline clones does not need materialization, but we can be seeing
    an inline clone of real clone).  */
cgraph_node *p = this;
for (cgraph_node *c = clone_of; c; c = c->clone_of)
  {
    if (c->decl != decl)
p->materialize_clone ();
    p = c;
  }

/* Check if body is already there.  Either we have gimple body or
   the function is thunk and in that case we set DECL_ARGUMENTS.  */
if (DECL_ARGUMENTS (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4001, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
) || gimple_has_body_p (decl))
  return false;

gcc_assert (in_lto_p && !DECL_RESULT (decl))((void)(!(global_options.x_in_lto_p && !((tree_check (
(decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4004, __FUNCTION__, (FUNCTION_DECL)))->decl_non_common.result
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4004, __FUNCTION__), 0 : 0));

timevar_push (TV_IPA_LTO_GIMPLE_IN);

file_data = lto_file_data;
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))((const char *) (tree_check ((decl_assembler_name (decl)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4009, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);

/* We may have renamed the declaration, e.g., a static function.  */
name = lto_get_decl_name_mapping (file_data, name);
struct lto_in_decl_state *decl_state
= lto_get_function_in_decl_state (file_data, decl);

cgraph_node *origin = this;
while (origin->clone_of)
  origin = origin->clone_of;

int stream_order = origin->order - file_data->order_base;
data = lto_get_section_data (file_data, LTO_section_function_body,
	       name, stream_order, &len,
	       decl_state->compressed);
if (!data)
  fatal_error (input_location, "%s: section %s.%d is missing",
 file_data->file_name, name, stream_order);

gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL)((void)(!(((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4028, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f) ==
 __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4028, __FUNCTION__), 0 : 0));

if (!quiet_flagglobal_options.x_quiet_flag)
  fprintf (stderrstderr, " in:%s", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))((const char *) (tree_check ((decl_assembler_name (decl)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4031, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
lto_input_function_body (file_data, this, data);
lto_stats.num_function_bodies++;
lto_free_section_data (file_data, LTO_section_function_body, name,
	 data, len, decl_state->compressed);
lto_free_function_in_decl_state_for_node (this);
/* Keep lto file data so ipa-inline-analysis knows about cross module
   inlining.  */

timevar_pop (TV_IPA_LTO_GIMPLE_IN);

return true;
4043}

4045/* Prepare function body.  When doing LTO, read cgraph_node's body from disk 
 if it is not already present.  When some IPA transformations are scheduled,
 apply them.  */

4049bool
4050cgraph_node::get_body (void)
4051{
bool updated;

updated = get_untransformed_body ();

/* Getting transformed body makes no sense for inline clones;
   we should never use this on real clones because they are materialized
   early.
   TODO: Materializing clones here will likely lead to smaller LTRANS
   footprint. */
gcc_assert (!inlined_to && !clone_of)((void)(!(!inlined_to && !clone_of) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4061, __FUNCTION__), 0 : 0));
if (ipa_transforms_to_apply.exists ())
  {
    opt_pass *saved_current_pass = current_pass;
    FILE *saved_dump_file = dump_file;
    const char *saved_dump_file_name = dump_file_name;
    dump_flags_t saved_dump_flags = dump_flags;
    dump_file_name = NULL__null;
    set_dump_file (NULL__null);

    push_cfun (DECL_STRUCT_FUNCTION (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4071, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f));

    update_ssa (TODO_update_ssa_only_virtuals(1 << 14));
    execute_all_ipa_transforms (true);
    cgraph_edge::rebuild_edges ();
    free_dominance_info (CDI_DOMINATORS);
    free_dominance_info (CDI_POST_DOMINATORS);
    pop_cfun ();
    updated = true;

    current_pass = saved_current_pass;
    set_dump_file (saved_dump_file);
    dump_file_name = saved_dump_file_name;
    dump_flags = saved_dump_flags;
  }
return updated;
4087}

4089/* Return the DECL_STRUCT_FUNCTION of the function.  */

4091struct function *
4092cgraph_node::get_fun () const
4093{
const cgraph_node *node = this;
struct function *fun = DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4095, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);

while (!fun && node->clone_of)
  {
    node = node->clone_of;
    fun = DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4100, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);
  }

return fun;
4104}

4106/* Reset all state within cgraph.cc so that we can rerun the compiler
 within the same process.  For use by toplev::finalize.  */

4109void
4110cgraph_cc_finalize (void)
4111{
nested_function_info::release ();
thunk_info::release ();
clone_info::release ();
symtab = NULL__null;

x_cgraph_nodes_queue = NULL__null;

cgraph_fnver_htab = NULL__null;
version_info_node = NULL__null;
4121}

4123/* A worker for call_for_symbol_and_aliases.  */

4125bool
4126cgraph_node::call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
					      void *),
			    void *data,
			    bool include_overwritable)
4130{
ipa_ref *ref;
FOR_EACH_ALIAS (this, ref)for (unsigned ref_iter_ = 0; (this)->iterate_direct_aliases
 (ref_iter_, ref); ref_iter_++)
  {
    cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
    if (include_overwritable
 || alias->get_availability () > AVAIL_INTERPOSABLE)
if (alias->call_for_symbol_and_aliases (callback, data,
				include_overwritable))
 return true;
  }
return false;
4142}

4144/* Return true if NODE has thunk.  */

4146bool
4147cgraph_node::has_thunk_p (cgraph_node *node, void *)
4148{
for (cgraph_edge *e = node->callers; e; e = e->next_caller)
  if (e->caller->thunk)
    return true;
return false;
4153}

4155/* Expected frequency of executions within the function.  */

4157sreal
4158cgraph_edge::sreal_frequency ()
4159{
return count.to_sreal_scale (caller->inlined_to
	       ? caller->inlined_to->count
	       : caller->count);
4163}


4166/* During LTO stream in this can be used to check whether call can possibly
 be internal to the current translation unit.  */

4169bool
4170cgraph_edge::possibly_call_in_translation_unit_p (void)
4171{
gcc_checking_assert (in_lto_p && caller->prevailing_p ())((void)(!(global_options.x_in_lto_p && caller->prevailing_p
 ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4172, __FUNCTION__), 0 : 0));

/* While incremental linking we may end up getting function body later.  */
if (flag_incremental_linkglobal_options.x_flag_incremental_link == INCREMENTAL_LINK_LTO)
  return true;

/* We may be smarter here and avoid streaming in indirect calls we can't
   track, but that would require arranging streaming the indirect call
   summary first.  */
if (!callee)
  return true;

/* If callee is local to the original translation unit, it will be
   defined.  */
if (!TREE_PUBLIC (callee->decl)((callee->decl)->base.public_flag) && !DECL_EXTERNAL (callee->decl)((contains_struct_check ((callee->decl), (TS_DECL_COMMON),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4186, __FUNCTION__))->decl_common.decl_flag_1))
  return true;

/* Otherwise we need to lookup prevailing symbol (symbol table is not merged,
   yet) and see if it is a definition.  In fact we may also resolve aliases,
   but that is probably not too important.  */
symtab_node *node = callee;
for (int n = 10; node->previous_sharing_asm_name && n ; n--)
  node = node->previous_sharing_asm_name;
if (node->previous_sharing_asm_name)
  node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (callee->decl)decl_assembler_name (callee->decl));
gcc_assert (TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl))((void)(!(((node->decl)->base.public_flag) || ((contains_struct_check
 ((node->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4197, __FUNCTION__))->decl_common.decl_flag_1)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4197, __FUNCTION__), 0 : 0));
return node->get_availability () >= AVAIL_INTERPOSABLE;
4199}

4201/* Return num_speculative_targets of this edge.  */

4203int
4204cgraph_edge::num_speculative_call_targets_p (void)
4205{
return indirect_info ? indirect_info->num_speculative_call_targets : 0;
4207}

4209/* Check if function calls comdat local.  This is used to recompute
 calls_comdat_local flag after function transformations.  */
4211bool
4212cgraph_node::check_calls_comdat_local_p ()
4213{
for (cgraph_edge *e = callees; e; e = e->next_callee)
  if (e->inline_failed
? e->callee->comdat_local_p ()
: e->callee->check_calls_comdat_local_p ())
    return true;
return false;
4220}

4222/* Return true if this node represents a former, i.e. an expanded, thunk.  */

4224bool
4225cgraph_node::former_thunk_p (void)
4226{
if (thunk)
  return false;
thunk_info *i = thunk_info::get (this);
if (!i)
  return false;
gcc_checking_assert (i->fixed_offset || i->virtual_offset_p((void)(!(i->fixed_offset || i->virtual_offset_p || i->
indirect_offset) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4233, __FUNCTION__), 0 : 0))
       || i->indirect_offset)((void)(!(i->fixed_offset || i->virtual_offset_p || i->
indirect_offset) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4233, __FUNCTION__), 0 : 0));
return true;
4235}

4237/* A stashed copy of "symtab" for use by selftest::symbol_table_test.
 This needs to be a global so that it can be a GC root, and thus
 prevent the stashed copy from being garbage-collected if the GC runs
 during a symbol_table_test.  */

4242symbol_table *saved_symtab;

4244#if CHECKING_P1

4246namespace selftest {

4248/* class selftest::symbol_table_test.  */

4250/* Constructor.  Store the old value of symtab, and create a new one.  */

4252symbol_table_test::symbol_table_test ()
4253{
gcc_assert (saved_symtab == NULL)((void)(!(saved_symtab == __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4254, __FUNCTION__), 0 : 0));
saved_symtab = symtab;
symtab = new (ggc_alloc<symbol_table> ()) symbol_table ();
4257}

4259/* Destructor.  Restore the old value of symtab.  */

4261symbol_table_test::~symbol_table_test ()
4262{
gcc_assert (saved_symtab != NULL)((void)(!(saved_symtab != __null) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4263, __FUNCTION__), 0 : 0));
symtab = saved_symtab;
saved_symtab = NULL__null;
4266}

4268/* Verify that symbol_table_test works.  */

4270static void
4271test_symbol_table_test ()
4272{
/* Simulate running two selftests involving symbol tables.  */
for (int i = 0; i < 2; i++)
  {
    symbol_table_test stt;
    tree test_decl = build_decl (UNKNOWN_LOCATION((location_t) 0), FUNCTION_DECL,
		   get_identifier ("test_decl")(__builtin_constant_p ("test_decl") ? get_identifier_with_length
 (("test_decl"), strlen ("test_decl")) : get_identifier ("test_decl"
)),
		   build_function_type_list (void_type_nodeglobal_trees[TI_VOID_TYPE],
					     NULL_TREE(tree) __null));
    cgraph_node *node = cgraph_node::get_create (test_decl);
    gcc_assert (node)((void)(!(node) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4282, __FUNCTION__), 0 : 0));

    /* Verify that the node has order 0 on both iterations,
and thus that nodes have predictable dump names in selftests.  */
    ASSERT_EQ (node->order, 0)do { const char *desc_ = "ASSERT_EQ (" "(node->order)" ", "
 "(0)" ")"; if (((node->order)) == ((0))) ::selftest::pass
 ((((::selftest::location ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4286, __FUNCTION__)))), desc_); else ::selftest::fail ((((::
selftest::location ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4286, __FUNCTION__)))), desc_); } while (0);
    ASSERT_STREQ (node->dump_name (), "test_decl/0")do { ::selftest::assert_streq ((::selftest::location ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.cc"
, 4287, __FUNCTION__)), "node->dump_name ()", "\"test_decl/0\""
, (node->dump_name ()), ("test_decl/0")); } while (0);
  }
4289}

4291/* Run all of the selftests within this file.  */

4293void
4294cgraph_cc_tests ()
4295{
test_symbol_table_test ();
4297}

4299} // namespace selftest

4301#endif /* CHECKING_P */

4303#include "gt-cgraph.h"

←

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/gimple.h

→

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