/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h

Bug Summary

File:	build/gcc/symbol-summary.h
Warning:	line 701, column 35 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 ipa-profile.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-vWK2Fq.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc

→

1/* Basic IPA optimizations based on profile.
 Copyright (C) 2003-2023 Free Software Foundation, Inc.

4This file is part of GCC.

6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.

11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14for more details.

16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3.  If not see
18<http://www.gnu.org/licenses/>.  */

20/* ipa-profile pass implements the following analysis propagating profille
 inter-procedurally.

 - Count histogram construction.  This is a histogram analyzing how much
   time is spent executing statements with a given execution count read
   from profile feedback. This histogram is complete only with LTO,
   otherwise it contains information only about the current unit.

   The information is used to set hot/cold thresholds.
 - Next speculative indirect call resolution is performed:  the local
   profile pass assigns profile-id to each function and provide us with a
   histogram specifying the most common target.  We look up the callgraph
   node corresponding to the target and produce a speculative call.

   This call may or may not survive through IPA optimization based on decision
   of inliner. 
 - Finally we propagate the following flags: unlikely executed, executed
   once, executed at startup and executed at exit.  These flags are used to
   control code size/performance threshold and code placement (by producing
   .text.unlikely/.text.hot/.text.startup/.text.exit subsections).  */
40#include "config.h"
41#include "system.h"
42#include "coretypes.h"
43#include "backend.h"
44#include "tree.h"
45#include "gimple.h"
46#include "predict.h"
47#include "alloc-pool.h"
48#include "tree-pass.h"
49#include "cgraph.h"
50#include "data-streamer.h"
51#include "gimple-iterator.h"
52#include "ipa-utils.h"
53#include "profile.h"
54#include "value-prof.h"
55#include "tree-inline.h"
56#include "symbol-summary.h"
57#include "tree-vrp.h"
58#include "ipa-prop.h"
59#include "ipa-fnsummary.h"

61/* Entry in the histogram.  */

63struct histogram_entry
64{
gcov_type count;
int time;
int size;
68};

70/* Histogram of profile values.
 The histogram is represented as an ordered vector of entries allocated via
 histogram_pool. During construction a separate hashtable is kept to lookup
 duplicate entries.  */

75vec<histogram_entry *> histogram;
76static object_allocator<histogram_entry> histogram_pool ("IPA histogram");

78/* Hashtable support for storing SSA names hashed by their SSA_NAME_VAR.  */

80struct histogram_hash : nofree_ptr_hash <histogram_entry>
81{
static inline hashval_t hash (const histogram_entry *);
static inline int equal (const histogram_entry *, const histogram_entry *);
84};

86inline hashval_t
87histogram_hash::hash (const histogram_entry *val)
88{
return val->count;
90}

92inline int
93histogram_hash::equal (const histogram_entry *val, const histogram_entry *val2)
94{
return val->count == val2->count;
96}

98/* Account TIME and SIZE executed COUNT times into HISTOGRAM.
 HASHTABLE is the on-side hash kept to avoid duplicates.  */

101static void
102account_time_size (hash_table<histogram_hash> *hashtable,
   vec<histogram_entry *> &histogram,
   gcov_type count, int time, int size)
105{
histogram_entry key = {count, 0, 0};
histogram_entry **val = hashtable->find_slot (&key, INSERT);

if (!*val)
  {
    *val = histogram_pool.allocate ();
    **val = key;
    histogram.safe_push (*val);
  }
(*val)->time += time;
(*val)->size += size;
117}

119int
120cmp_counts (const void *v1, const void *v2)
121{
const histogram_entry *h1 = *(const histogram_entry * const *)v1;
const histogram_entry *h2 = *(const histogram_entry * const *)v2;
if (h1->count < h2->count)
  return 1;
if (h1->count > h2->count)
  return -1;
return 0;
129}

131/* Dump HISTOGRAM to FILE.  */

133static void
134dump_histogram (FILE *file, vec<histogram_entry *> histogram)
135{
unsigned int i;
gcov_type overall_time = 0, cumulated_time = 0, cumulated_size = 0,
   overall_size = 0;

fprintf (dump_file, "Histogram:\n");
for (i = 0; i < histogram.length (); i++)
  {
    overall_time += histogram[i]->count * histogram[i]->time;
    overall_size += histogram[i]->size;
  }
if (!overall_time)
  overall_time = 1;
if (!overall_size)
  overall_size = 1;
for (i = 0; i < histogram.length (); i++)
  {
    cumulated_time += histogram[i]->count * histogram[i]->time;
    cumulated_size += histogram[i]->size;
    fprintf (file, "  %" PRId64"l" "d"": time:%i (%2.2f) size:%i (%2.2f)\n",
      (int64_t) histogram[i]->count,
      histogram[i]->time,
      cumulated_time * 100.0 / overall_time,
      histogram[i]->size,
      cumulated_size * 100.0 / overall_size);
 }
161}

163/* Structure containing speculative target information from profile.  */

165struct speculative_call_target
166{
speculative_call_target (unsigned int id = 0, int prob = 0)
  : target_id (id), target_probability (prob)
{
}

/* Profile_id of target obtained from profile.  */
unsigned int target_id;
/* Probability that call will land in function with target_id.  */
unsigned int target_probability;
176};

178class speculative_call_summary
179{
180public:
speculative_call_summary () : speculative_call_targets ()
{}

auto_vec<speculative_call_target> speculative_call_targets;

void dump (FILE *f);

188};

/* Class to manage call summaries.  */

192class ipa_profile_call_summaries
: public call_summary<speculative_call_summary *>
194{
195public:
ipa_profile_call_summaries (symbol_table *table)
  : call_summary<speculative_call_summary *> (table)
{}

/* Duplicate info when an edge is cloned.  */
void duplicate (cgraph_edge *, cgraph_edge *,
  speculative_call_summary *old_sum,
  speculative_call_summary *new_sum) final override;
204};

206static ipa_profile_call_summaries *call_sums = NULLnullptr;

208/* Dump all information in speculative call summary to F.  */

210void
211speculative_call_summary::dump (FILE *f)
212{
cgraph_node *n2;

unsigned spec_count = speculative_call_targets.length ();
for (unsigned i = 0; i < spec_count; i++)
  {
    speculative_call_target item = speculative_call_targets[i];
    n2 = find_func_by_profile_id (item.target_id);
    if (n2)
fprintf (f, "    The %i speculative target is %s with prob %3.2f\n", i,
 n2->dump_name (),
 item.target_probability / (float) REG_BR_PROB_BASE10000);
    else
fprintf (f, "    The %i speculative target is %u with prob %3.2f\n", i,
 item.target_id,
 item.target_probability / (float) REG_BR_PROB_BASE10000);
  }
229}

231/* Duplicate info when an edge is cloned.  */

233void
234ipa_profile_call_summaries::duplicate (cgraph_edge *, cgraph_edge *,
		       speculative_call_summary *old_sum,
		       speculative_call_summary *new_sum)
237{
if (!old_sum)
  return;

unsigned old_count = old_sum->speculative_call_targets.length ();
if (!old_count)
  return;

new_sum->speculative_call_targets.reserve_exact (old_count);
new_sum->speculative_call_targets.quick_grow_cleared (old_count);

for (unsigned i = 0; i < old_count; i++)
  {
    new_sum->speculative_call_targets[i]
= old_sum->speculative_call_targets[i];
  }
253}

255/* Collect histogram and speculative target summaries from CFG profiles.  */

257static void
258ipa_profile_generate_summary (void)
259{
struct cgraph_node *node;
gimple_stmt_iterator gsi;
basic_block bb;

hash_table<histogram_hash> hashtable (10);

gcc_checking_assert (!call_sums)((void)(!(!call_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 266, __FUNCTION__), 0 : 0));
1
Assuming 'call_sums' is null→
2
←
'?' condition is false→
call_sums = new ipa_profile_call_summaries (symtab);

FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)for ((node) = symtab->first_function_with_gimple_body (); (
node); (node) = symtab->next_function_with_gimple_body (node
))
3
←
Calling 'symbol_table::first_function_with_gimple_body'→
29
←
Returning from 'symbol_table::first_function_with_gimple_body'→
30
←
Loop condition is true.  Entering loop body→
  if (ENTRY_BLOCK_PTR_FOR_FN((((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 271, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))->
cfg->x_entry_block_ptr)
31
←
Taking true branch→
 (DECL_STRUCT_FUNCTION (node->decl))((((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 271, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))->
cfg->x_entry_block_ptr)->count.ipa_p ())
    FOR_EACH_BB_FN (bb, DECL_STRUCT_FUNCTION (node->decl))for (bb = (((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 272, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))->
cfg->x_entry_block_ptr->next_bb; bb != (((tree_check ((
node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 272, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))->
cfg->x_exit_block_ptr; bb = bb->next_bb)
32
←
Assuming 'bb' is not equal to field 'x_exit_block_ptr'→
33
←
Loop condition is true.  Entering loop body→
{
 int time = 0;
 int size = 0;
 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
34
←
Loop condition is true.  Entering loop body→
   {
     gimple *stmt = gsi_stmt (gsi);
     if (gimple_code (stmt) == GIMPLE_CALL
35
←
Assuming the condition is true→
36
←
Taking true branch→
  && !gimple_call_fndecl (stmt))
{
  histogram_value h;
  h = gimple_histogram_value_of_type
	(DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 284, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f),
	 stmt, HIST_TYPE_INDIR_CALL);
  /* No need to do sanity check: gimple_ic_transform already
     takes away bad histograms.  */
  if (h)
37
←
Assuming 'h' is non-null→
38
←
Taking true branch→
    {
      gcov_type val, count, all;
      struct cgraph_edge *e = node->get_edge (stmt);
39
←
'e' initialized here→
      if (e && !e->indirect_unknown_callee)
40
←
Assuming 'e' is null→
	continue;

      speculative_call_summary *csum
	= call_sums->get_create (e);
41
←
Passing null pointer value via 1st parameter 'edge'→
42
←
Calling 'call_summary::get_create'→

      for (unsigned j = 0; j < GCOV_TOPN_MAXIMUM_TRACKED_VALUES32;
	   j++)
	{
	  if (!get_nth_most_common_value (NULLnullptr, "indirect call",
					  h, &val, &count, &all,
					  j))
	    continue;

	  if (val == 0 || count == 0)
	    continue;

	  if (count > all)
	    {
	      if (dump_file)
		fprintf (dump_file,
			 "Probability capped to 1\n");
	      count = all;
	    }
	  speculative_call_target item (
	    val, GCOV_COMPUTE_SCALE (count, all)((all) ? ((((count) * 10000) + ((all)) / 2) / ((all))) : 10000
));
	  csum->speculative_call_targets.safe_push (item);
	}

      gimple_remove_histogram_value
	 (DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 322, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f), stmt, h);
    }
}
     time += estimate_num_insns (stmt, &eni_time_weights);
     size += estimate_num_insns (stmt, &eni_size_weights);
   }
 if (bb->count.ipa_p () && bb->count.initialized_p ())
   account_time_size (&hashtable, histogram,
	       bb->count.ipa ().to_gcov_type (),
	       time, size);
}
histogram.qsort (cmp_counts)qsort (cmp_counts);
334}

336/* Serialize the speculative summary info for LTO.  */

338static void
339ipa_profile_write_edge_summary (lto_simple_output_block *ob,
		speculative_call_summary *csum)
341{
unsigned len = 0;

len = csum->speculative_call_targets.length ();

gcc_assert (len <= GCOV_TOPN_MAXIMUM_TRACKED_VALUES)((void)(!(len <= 32) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 346, __FUNCTION__), 0 : 0));

streamer_write_hwi_stream (ob->main_stream, len);

if (len)
  {
    unsigned spec_count = csum->speculative_call_targets.length ();
    for (unsigned i = 0; i < spec_count; i++)
{
 speculative_call_target item = csum->speculative_call_targets[i];
 gcc_assert (item.target_id)((void)(!(item.target_id) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 356, __FUNCTION__), 0 : 0));
 streamer_write_hwi_stream (ob->main_stream, item.target_id);
 streamer_write_hwi_stream (ob->main_stream, item.target_probability);
}
  }
361}

363/* Serialize the ipa info for lto.  */

365static void
366ipa_profile_write_summary (void)
367{
struct lto_simple_output_block *ob
  = lto_create_simple_output_block (LTO_section_ipa_profile);
unsigned int i;

streamer_write_uhwi_stream (ob->main_stream, histogram.length ());
for (i = 0; i < histogram.length (); i++)
  {
    streamer_write_gcov_count_stream (ob->main_stream, histogram[i]->count);
    streamer_write_uhwi_stream (ob->main_stream, histogram[i]->time);
    streamer_write_uhwi_stream (ob->main_stream, histogram[i]->size);
  }

if (!call_sums)
  return;

/* Serialize speculative targets information.  */
unsigned int count = 0;
lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
lto_symtab_encoder_iterator lsei;
cgraph_node *node;

for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
     lsei_next_function_in_partition (&lsei))
  {
    node = lsei_cgraph_node (lsei);
    if (node->definition && node->has_gimple_body_p ()
 && node->indirect_calls)
count++;
  }

streamer_write_uhwi_stream (ob->main_stream, count);

/* Process all of the functions.  */
for (lsei = lsei_start_function_in_partition (encoder);
     !lsei_end_p (lsei) && count; lsei_next_function_in_partition (&lsei))
  {
    cgraph_node *node = lsei_cgraph_node (lsei);
    if (node->definition && node->has_gimple_body_p ()
 && node->indirect_calls)
{
 int node_ref = lto_symtab_encoder_encode (encoder, node);
 streamer_write_uhwi_stream (ob->main_stream, node_ref);

 for (cgraph_edge *e = node->indirect_calls; e; e = e->next_callee)
   {
     speculative_call_summary *csum = call_sums->get_create (e);
     ipa_profile_write_edge_summary (ob, csum);
   }
    }
  }

lto_destroy_simple_output_block (ob);
420}

422/* Dump all profile summary data for all cgraph nodes and edges to file F.  */

424static void
425ipa_profile_dump_all_summaries (FILE *f)
426{
fprintf (dump_file,
  "\n========== IPA-profile speculative targets: ==========\n");
cgraph_node *node;
FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)for ((node) = symtab->first_function_with_gimple_body (); (
node); (node) = symtab->next_function_with_gimple_body (node
))
  {
    fprintf (f, "\nSummary for node %s:\n", node->dump_name ());
    for (cgraph_edge *e = node->indirect_calls; e; e = e->next_callee)
{
 fprintf (f, "  Summary for %s of indirect edge %d:\n",
   e->caller->dump_name (), e->lto_stmt_uid);
 speculative_call_summary *csum = call_sums->get_create (e);
 csum->dump (f);
}
  }
fprintf (f, "\n\n");
442}

444/* Read speculative targets information about edge for LTO WPA.  */

446static void
447ipa_profile_read_edge_summary (class lto_input_block *ib, cgraph_edge *edge)
448{
unsigned i, len;

len = streamer_read_hwi (ib);
gcc_assert (len <= GCOV_TOPN_MAXIMUM_TRACKED_VALUES)((void)(!(len <= 32) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 452, __FUNCTION__), 0 : 0));
speculative_call_summary *csum = call_sums->get_create (edge);

for (i = 0; i < len; i++)
{
  unsigned int target_id = streamer_read_hwi (ib);
  int target_probability = streamer_read_hwi (ib);
  speculative_call_target item (target_id, target_probability);
  csum->speculative_call_targets.safe_push (item);
}
462}

464/* Read profile speculative targets section information for LTO WPA.  */

466static void
467ipa_profile_read_summary_section (struct lto_file_decl_data *file_data,
		  class lto_input_block *ib)
469{
if (!ib)
  return;

lto_symtab_encoder_t encoder = file_data->symtab_node_encoder;

unsigned int count = streamer_read_uhwi (ib);

unsigned int i;
unsigned int index;
cgraph_node * node;

for (i = 0; i < count; i++)
  {
    index = streamer_read_uhwi (ib);
    node
= dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder, index));

    for (cgraph_edge *e = node->indirect_calls; e; e = e->next_callee)
ipa_profile_read_edge_summary (ib, e);
  }
490}

492/* Deserialize the IPA histogram and speculative targets summary info for LTO.
 */

495static void
496ipa_profile_read_summary (void)
497{
struct lto_file_decl_data ** file_data_vec
  = lto_get_file_decl_data ();
struct lto_file_decl_data * file_data;
int j = 0;

hash_table<histogram_hash> hashtable (10);

gcc_checking_assert (!call_sums)((void)(!(!call_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 505, __FUNCTION__), 0 : 0));
call_sums = new ipa_profile_call_summaries (symtab);

while ((file_data = file_data_vec[j++]))
  {
    const char *data;
    size_t len;
    class lto_input_block *ib
= lto_create_simple_input_block (file_data,
			 LTO_section_ipa_profile,
			 &data, &len);
    if (ib)
{
        unsigned int num = streamer_read_uhwi (ib);
 unsigned int n;
 for (n = 0; n < num; n++)
   {
     gcov_type count = streamer_read_gcov_count (ib);
     int time = streamer_read_uhwi (ib);
     int size = streamer_read_uhwi (ib);
     account_time_size (&hashtable, histogram,
		 count, time, size);
   }

 ipa_profile_read_summary_section (file_data, ib);

 lto_destroy_simple_input_block (file_data,
			  LTO_section_ipa_profile,
			  ib, data, len);
}
  }
histogram.qsort (cmp_counts)qsort (cmp_counts);
537}

539/* Data used by ipa_propagate_frequency.  */

541struct ipa_propagate_frequency_data
542{
cgraph_node *function_symbol;
bool maybe_unlikely_executed;
bool maybe_executed_once;
bool only_called_at_startup;
bool only_called_at_exit;
548};

550/* Worker for ipa_propagate_frequency_1.  */

552static bool
553ipa_propagate_frequency_1 (struct cgraph_node *node, void *data)
554{
struct ipa_propagate_frequency_data *d;
struct cgraph_edge *edge;

d = (struct ipa_propagate_frequency_data *)data;
for (edge = node->callers;
     edge && (d->maybe_unlikely_executed || d->maybe_executed_once
       || d->only_called_at_startup || d->only_called_at_exit);
     edge = edge->next_caller)
  {
    if (edge->caller != d->function_symbol)
{
        d->only_called_at_startup &= edge->caller->only_called_at_startup;
 /* It makes sense to put main() together with the static constructors.
    It will be executed for sure, but rest of functions called from
    main are definitely not at startup only.  */
 if (MAIN_NAME_P (DECL_NAME (edge->caller->decl))((tree_check ((((contains_struct_check ((edge->caller->
decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 570, __FUNCTION__))->decl_minimal.name)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 570, __FUNCTION__, (IDENTIFIER_NODE))) == global_trees[TI_MAIN_IDENTIFIER
]))
   d->only_called_at_startup = 0;
        d->only_called_at_exit &= edge->caller->only_called_at_exit;
}

    /* When profile feedback is available, do not try to propagate too hard;
counts are already good guide on function frequencies and roundoff
errors can make us to push function into unlikely section even when
it is executed by the train run.  Transfer the function only if all
callers are unlikely executed.  */
    if (profile_info
 && !(edge->callee->count.ipa () == profile_count::zero ())
 && (edge->caller->frequency != NODE_FREQUENCY_UNLIKELY_EXECUTED
     || (edge->caller->inlined_to
  && edge->caller->inlined_to->frequency
     != NODE_FREQUENCY_UNLIKELY_EXECUTED)))
 d->maybe_unlikely_executed = false;
    if (edge->count.ipa ().initialized_p ()
 && !edge->count.ipa ().nonzero_p ())
continue;
    switch (edge->caller->frequency)
      {
case NODE_FREQUENCY_UNLIKELY_EXECUTED:
 break;
case NODE_FREQUENCY_EXECUTED_ONCE:
 {
   if (dump_file && (dump_flags & TDF_DETAILS))
     fprintf (dump_file, "  Called by %s that is executed once\n",
       edge->caller->dump_name ());
   d->maybe_unlikely_executed = false;
   ipa_call_summary *s = ipa_call_summaries->get (edge);
   if (s != NULLnullptr && s->loop_depth)
     {
d->maybe_executed_once = false;
if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file, "  Called in loop\n");
     }
   break;
 }
case NODE_FREQUENCY_HOT:
case NODE_FREQUENCY_NORMAL:
 if (dump_file && (dump_flags & TDF_DETAILS))
   fprintf (dump_file, "  Called by %s that is normal or hot\n",
     edge->caller->dump_name ());
 d->maybe_unlikely_executed = false;
 d->maybe_executed_once = false;
 break;
}
  }
return edge != NULLnullptr;
620}

622/* Return ture if NODE contains hot calls.  */

624bool
625contains_hot_call_p (struct cgraph_node *node)
626{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
  if (e->maybe_hot_p ())
    return true;
  else if (!e->inline_failed
    && contains_hot_call_p (e->callee))
    return true;
for (e = node->indirect_calls; e; e = e->next_callee)
  if (e->maybe_hot_p ())
    return true;
return false;
638}

640/* See if the frequency of NODE can be updated based on frequencies of its
 callers.  */
642bool
643ipa_propagate_frequency (struct cgraph_node *node)
644{
struct ipa_propagate_frequency_data d = {node, true, true, true, true};
bool changed = false;

/* We cannot propagate anything useful about externally visible functions
   nor about virtuals.  */
if (!node->local
    || node->alias
    || (opt_for_fn (node->decl, flag_devirtualize)(opts_for_fn (node->decl)->x_flag_devirtualize)
 && DECL_VIRTUAL_P (node->decl)((contains_struct_check ((node->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 653, __FUNCTION__))->decl_common.virtual_flag)))
  return false;
gcc_assert (node->analyzed)((void)(!(node->analyzed) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 655, __FUNCTION__), 0 : 0));
if (dump_file && (dump_flags & TDF_DETAILS))
  fprintf (dump_file, "Processing frequency %s\n", node->dump_name ());

node->call_for_symbol_and_aliases (ipa_propagate_frequency_1, &d,
		     true);

if ((d.only_called_at_startup && !d.only_called_at_exit)
    && !node->only_called_at_startup)
  {
     node->only_called_at_startup = true;
     if (dump_file)
       fprintf (dump_file, "Node %s promoted to only called at startup.\n",
  node->dump_name ());
     changed = true;
  }
if ((d.only_called_at_exit && !d.only_called_at_startup)
    && !node->only_called_at_exit)
  {
     node->only_called_at_exit = true;
     if (dump_file)
       fprintf (dump_file, "Node %s promoted to only called at exit.\n",
  node->dump_name ());
     changed = true;
  }

/* With profile we can decide on hot/normal based on count.  */
if (node->count. ipa().initialized_p ())
  {
    bool hot = false;
    if (!(node->count. ipa() == profile_count::zero ())
 && node->count. ipa() >= get_hot_bb_threshold ())
hot = true;
    if (!hot)
hot |= contains_hot_call_p (node);
    if (hot)
{
 if (node->frequency != NODE_FREQUENCY_HOT)
   {
     if (dump_file)
fprintf (dump_file, "Node %s promoted to hot.\n",
	 node->dump_name ());
     node->frequency = NODE_FREQUENCY_HOT;
     return true;
   }
 return false;
}
    else if (node->frequency == NODE_FREQUENCY_HOT)
{
 if (dump_file)
   fprintf (dump_file, "Node %s reduced to normal.\n",
     node->dump_name ());
 node->frequency = NODE_FREQUENCY_NORMAL;
 changed = true;
}
  }
/* These come either from profile or user hints; never update them.  */
if (node->frequency == NODE_FREQUENCY_HOT
    || node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
  return changed;
if (d.maybe_unlikely_executed)
  {
    node->frequency = NODE_FREQUENCY_UNLIKELY_EXECUTED;
    if (dump_file)
fprintf (dump_file, "Node %s promoted to unlikely executed.\n",
 node->dump_name ());
    changed = true;
  }
else if (d.maybe_executed_once && node->frequency != NODE_FREQUENCY_EXECUTED_ONCE)
  {
    node->frequency = NODE_FREQUENCY_EXECUTED_ONCE;
    if (dump_file)
fprintf (dump_file, "Node %s promoted to executed once.\n",
 node->dump_name ());
    changed = true;
  }
return changed;
732}

734/* Check that number of arguments of N agrees with E.
 Be conservative when summaries are not present.  */

737static bool
738check_argument_count (struct cgraph_node *n, struct cgraph_edge *e)
739{
if (!ipa_node_params_sum || !ipa_edge_args_sum)
  return true;
ipa_node_params *info = ipa_node_params_sum->get (n->function_symbol ());
if (!info)
  return true;
ipa_edge_args *e_info = ipa_edge_args_sum->get (e);
if (!e_info)
  return true;
if (ipa_get_param_count (info) != ipa_get_cs_argument_count (e_info)
    && (ipa_get_param_count (info) >= ipa_get_cs_argument_count (e_info)
 || !stdarg_p (TREE_TYPE (n->decl)((contains_struct_check ((n->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 750, __FUNCTION__))->typed.type))))
  return false;
return true;
753}

755/* Simple ipa profile pass propagating frequencies across the callgraph.  */

757static unsigned int
758ipa_profile (void)
759{
struct cgraph_node **order;
struct cgraph_edge *e;
int order_pos;
bool something_changed = false;
int i;
gcov_type overall_time = 0, cutoff = 0, cumulated = 0, overall_size = 0;
struct cgraph_node *n,*n2;
int nindirect = 0, ncommon = 0, nunknown = 0, nuseless = 0, nconverted = 0;
int nmismatch = 0, nimpossible = 0;
bool node_map_initialized = false;
gcov_type threshold;

if (dump_file)
  dump_histogram (dump_file, histogram);
for (i = 0; i < (int)histogram.length (); i++)
  {
    overall_time += histogram[i]->count * histogram[i]->time;
    overall_size += histogram[i]->size;
  }
threshold = 0;
if (overall_time)
  {
    gcc_assert (overall_size)((void)(!(overall_size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 782, __FUNCTION__), 0 : 0));

    cutoff = (overall_time * param_hot_bb_count_ws_permilleglobal_options.x_param_hot_bb_count_ws_permille + 500) / 1000;
    for (i = 0; cumulated < cutoff; i++)
{
 cumulated += histogram[i]->count * histogram[i]->time;
        threshold = histogram[i]->count;
}
    if (!threshold)
threshold = 1;
    if (dump_file)
{
 gcov_type cumulated_time = 0, cumulated_size = 0;

        for (i = 0;
      i < (int)histogram.length () && histogram[i]->count >= threshold;
      i++)
   {
     cumulated_time += histogram[i]->count * histogram[i]->time;
     cumulated_size += histogram[i]->size;
   }
 fprintf (dump_file, "Determined min count: %" PRId64"l" "d"
   " Time:%3.2f%% Size:%3.2f%%\n", 
   (int64_t)threshold,
   cumulated_time * 100.0 / overall_time,
   cumulated_size * 100.0 / overall_size);
}

    if (in_lto_pglobal_options.x_in_lto_p)
{
 if (dump_file)
   fprintf (dump_file, "Setting hotness threshold in LTO mode.\n");
        set_hot_bb_threshold (threshold);
}
  }
histogram.release ();
histogram_pool.release ();

/* Produce speculative calls: we saved common target from profiling into
   e->target_id.  Now, at link time, we can look up corresponding
   function node and produce speculative call.  */

gcc_checking_assert (call_sums)((void)(!(call_sums) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-profile.cc"
, 824, __FUNCTION__), 0 : 0));

if (dump_file)
  {
    if (!node_map_initialized)
init_node_map (false);
    node_map_initialized = true;

    ipa_profile_dump_all_summaries (dump_file);
  }

FOR_EACH_DEFINED_FUNCTION (n)for ((n) = symtab->first_defined_function (); (n); (n) = symtab
->next_defined_function ((n)))
  {
    bool update = false;

    if (!opt_for_fn (n->decl, flag_ipa_profile)(opts_for_fn (n->decl)->x_flag_ipa_profile))
continue;

    for (e = n->indirect_calls; e; e = e->next_callee)
{
 if (n->count.initialized_p ())
   nindirect++;

 speculative_call_summary *csum = call_sums->get_create (e);
 unsigned spec_count = csum->speculative_call_targets.length ();
 if (spec_count)
   {
     if (!node_map_initialized)
init_node_map (false);
     node_map_initialized = true;
     ncommon++;

     unsigned speculative_id = 0;
     profile_count orig = e->count;
     for (unsigned i = 0; i < spec_count; i++)
{
  speculative_call_target item
    = csum->speculative_call_targets[i];
  n2 = find_func_by_profile_id (item.target_id);
  if (n2)
    {
      if (dump_file)
	{
	  fprintf (dump_file,
		   "Indirect call -> direct call from"
		   " other module %s => %s, prob %3.2f\n",
		   n->dump_name (),
		   n2->dump_name (),
		   item.target_probability
		     / (float) REG_BR_PROB_BASE10000);
	}
      if (item.target_probability < REG_BR_PROB_BASE10000 / 2)
	{
	  nuseless++;
	  if (dump_file)
	    fprintf (dump_file,
		     "Not speculating: "
		     "probability is too low.\n");
	}
      else if (!e->maybe_hot_p ())
	{
	  nuseless++;
	  if (dump_file)
	    fprintf (dump_file,
		     "Not speculating: call is cold.\n");
	}
      else if (n2->get_availability () <= AVAIL_INTERPOSABLE
	       && n2->can_be_discarded_p ())
	{
	  nuseless++;
	  if (dump_file)
	    fprintf (dump_file,
		     "Not speculating: target is overwritable "
		     "and can be discarded.\n");
	}
      else if (!check_argument_count (n2, e))
	{
	  nmismatch++;
	  if (dump_file)
	    fprintf (dump_file,
		     "Not speculating: "
		     "parameter count mismatch\n");
	}
      else if (e->indirect_info->polymorphic
	       && !opt_for_fn (n->decl, flag_devirtualize)(opts_for_fn (n->decl)->x_flag_devirtualize)
	       && !possible_polymorphic_call_target_p (e, n2))
	{
	  nimpossible++;
	  if (dump_file)
	    fprintf (dump_file,
		     "Not speculating: "
		     "function is not in the polymorphic "
		     "call target list\n");
	}
      else
	{
	  /* Target may be overwritable, but profile says that
	     control flow goes to this particular implementation
	     of N2.  Speculate on the local alias to allow
	     inlining.  */
	  if (!n2->can_be_discarded_p ())
	    {
	      cgraph_node *alias;
	      alias = dyn_cast<cgraph_node *>
		   (n2->noninterposable_alias ());
	      if (alias)
		n2 = alias;
	    }
	  nconverted++;
	  profile_probability prob
		 = profile_probability::from_reg_br_prob_base
			(item.target_probability).adjusted ();
	  e->make_speculative (n2,
			       orig.apply_probability (prob),
			       speculative_id);
	  update = true;
	  speculative_id++;
	}
    }
  else
    {
      if (dump_file)
	fprintf (dump_file,
		 "Function with profile-id %i not found.\n",
		 item.target_id);
      nunknown++;
    }
}
   }
}
    if (update)
ipa_update_overall_fn_summary (n);
  }
if (node_map_initialized)
  del_node_map ();
if (dump_file && nindirect)
  fprintf (dump_file,
    "%i indirect calls trained.\n"
    "%i (%3.2f%%) have common target.\n"
    "%i (%3.2f%%) targets was not found.\n"
    "%i (%3.2f%%) targets had parameter count mismatch.\n"
    "%i (%3.2f%%) targets was not in polymorphic call target list.\n"
    "%i (%3.2f%%) speculations seems useless.\n"
    "%i (%3.2f%%) speculations produced.\n",
    nindirect,
    ncommon, ncommon * 100.0 / nindirect,
    nunknown, nunknown * 100.0 / nindirect,
    nmismatch, nmismatch * 100.0 / nindirect,
    nimpossible, nimpossible * 100.0 / nindirect,
    nuseless, nuseless * 100.0 / nindirect,
    nconverted, nconverted * 100.0 / nindirect);

order = XCNEWVEC (struct cgraph_node *, symtab->cgraph_count)((struct cgraph_node * *) xcalloc ((symtab->cgraph_count),
 sizeof (struct cgraph_node *)));
order_pos = ipa_reverse_postorder (order);
for (i = order_pos - 1; i >= 0; i--)
  {
    if (order[i]->local
 && opt_for_fn (order[i]->decl, flag_ipa_profile)(opts_for_fn (order[i]->decl)->x_flag_ipa_profile)
 && ipa_propagate_frequency (order[i]))
{
 for (e = order[i]->callees; e; e = e->next_callee)
   if (e->callee->local && !e->callee->aux)
     {
       something_changed = true;
       e->callee->aux = (void *)1;
     }
}
    order[i]->aux = NULLnullptr;
  }

while (something_changed)
  {
    something_changed = false;
    for (i = order_pos - 1; i >= 0; i--)
{
 if (order[i]->aux
     && opt_for_fn (order[i]->decl, flag_ipa_profile)(opts_for_fn (order[i]->decl)->x_flag_ipa_profile)
     && ipa_propagate_frequency (order[i]))
   {
     for (e = order[i]->callees; e; e = e->next_callee)
if (e->callee->local && !e->callee->aux)
  {
    something_changed = true;
    e->callee->aux = (void *)1;
  }
   }
 order[i]->aux = NULLnullptr;
}
  }
free (order);

if (dump_file && (dump_flags & TDF_DETAILS))
  symtab->dump (dump_file);

delete call_sums;
call_sums = NULLnullptr;

return 0;
1022}

1024namespace {

1026const pass_data pass_data_ipa_profile =
1027{
IPA_PASS, /* type */
"profile_estimate", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_IPA_PROFILE, /* tv_id */
0, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
0, /* todo_flags_finish */
1037};

1039class pass_ipa_profile : public ipa_opt_pass_d
1040{
1041public:
pass_ipa_profile (gcc::context *ctxt)
  : ipa_opt_pass_d (pass_data_ipa_profile, ctxt,
      ipa_profile_generate_summary, /* generate_summary */
      ipa_profile_write_summary, /* write_summary */
      ipa_profile_read_summary, /* read_summary */
      NULLnullptr, /* write_optimization_summary */
      NULLnullptr, /* read_optimization_summary */
      NULLnullptr, /* stmt_fixup */
      0, /* function_transform_todo_flags_start */
      NULLnullptr, /* function_transform */
      NULLnullptr) /* variable_transform */
{}

/* opt_pass methods: */
bool gate (function *) final override { return flag_ipa_profileglobal_options.x_flag_ipa_profile || in_lto_pglobal_options.x_in_lto_p; }
unsigned int execute (function *) final override { return ipa_profile (); }

1059}; // class pass_ipa_profile

1061} // anon namespace

1063ipa_opt_pass_d *
1064make_pass_ipa_profile (gcc::context *ctxt)
1065{
return new pass_ipa_profile (ctxt);
1067}

←

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

→

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#ifndef GCC_CGRAPH_H
22#define GCC_CGRAPH_H

24#include "profile-count.h"
25#include "ipa-ref.h"
26#include "plugin-api.h"
27#include "ipa-param-manipulation.h"

29extern void debuginfo_early_init (void);
30extern void debuginfo_init (void);
31extern void debuginfo_fini (void);
32extern void debuginfo_start (void);
33extern void debuginfo_stop (void);
34extern void debuginfo_early_start (void);
35extern void debuginfo_early_stop (void);

37class ipa_opt_pass_d;
38typedef ipa_opt_pass_d *ipa_opt_pass;

40/* Symbol table consists of functions and variables.
 TODO: add labels and CONST_DECLs.  */
42enum symtab_type
43{
SYMTAB_SYMBOL,
SYMTAB_FUNCTION,
SYMTAB_VARIABLE
47};

49/* Section names are stored as reference counted strings in GGC safe hashtable
 (to make them survive through PCH).  */

52struct GTY((for_user)) section_hash_entry
53{
int ref_count;
char *name;  /* As long as this datastructure stays in GGC, we cannot put
  string at the tail of structure of GGC dies in horrible
  way  */
58};

60struct section_name_hasher : ggc_ptr_hash<section_hash_entry>
61{
typedef const char *compare_type;

static hashval_t hash (section_hash_entry *);
static bool equal (section_hash_entry *, const char *);
66};

68enum availability
69{
/* Not yet set by cgraph_function_body_availability.  */
AVAIL_UNSET,
/* Function body/variable initializer is unknown.  */
AVAIL_NOT_AVAILABLE,
/* Function body/variable initializer is known but might be replaced
   by a different one from other compilation unit and thus needs to
   be dealt with a care.  Like AVAIL_NOT_AVAILABLE it can have
   arbitrary side effects on escaping variables and functions, while
   like AVAILABLE it might access static variables.  */
AVAIL_INTERPOSABLE,
/* Function body/variable initializer is known and will be used in final
   program.  */
AVAIL_AVAILABLE,
/* Function body/variable initializer is known and all it's uses are
   explicitly visible within current unit (i.e. it's address is never taken
   and it is not exported to other units). Currently used only for
   functions.  */
AVAIL_LOCAL
88};

90/* Classification of symbols WRT partitioning.  */
91enum symbol_partitioning_class
92{
 /* External declarations are ignored by partitioning algorithms and they are
    added into the boundary later via compute_ltrans_boundary.  */
 SYMBOL_EXTERNAL,
 /* Partitioned symbols are put into one of partitions.  */
 SYMBOL_PARTITION,
 /* Duplicated symbols (such as comdat or constant pool references) are
    copied into every node needing them via add_symbol_to_partition.  */
 SYMBOL_DUPLICATE
101};

103/* Base of all entries in the symbol table.
 The symtab_node is inherited by cgraph and varpol nodes.  */
105struct GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"),
   chain_next ("%h.next"), chain_prev ("%h.previous")))
symtab_node
108{
109public:
friend class symbol_table;

/* Constructor.  */
explicit symtab_node (symtab_type t)
  : type (t), resolution (LDPR_UNKNOWN), definition (false), alias (false),
    transparent_alias (false), weakref (false), cpp_implicit_alias (false),
    symver (false), analyzed (false), writeonly (false),
    refuse_visibility_changes (false), externally_visible (false),
    no_reorder (false), force_output (false), forced_by_abi (false),
    unique_name (false), implicit_section (false), body_removed (false),
    semantic_interposition (flag_semantic_interpositionglobal_options.x_flag_semantic_interposition),
    used_from_other_partition (false), in_other_partition (false),
    address_taken (false), in_init_priority_hash (false),
    need_lto_streaming (false), offloadable (false), ifunc_resolver (false),
    order (false), next_sharing_asm_name (NULLnullptr),
    previous_sharing_asm_name (NULLnullptr), same_comdat_group (NULLnullptr), ref_list (),
    alias_target (NULLnullptr), lto_file_data (NULLnullptr), aux (NULLnullptr),
    x_comdat_group (NULL_TREE(tree) nullptr), x_section (NULLnullptr)
{}

/* Return name.  */
const char *name () const;

/* Return dump name.  */
const char *dump_name () const;

/* Return asm name.  */
const char *asm_name () const;

/* Return dump name with assembler name.  */
const char *dump_asm_name () const;

/* Return visibility name.  */
const char *get_visibility_string () const;

/* Return type_name name.  */
const char *get_symtab_type_string () const;

/* Add node into symbol table.  This function is not used directly, but via
   cgraph/varpool node creation routines.  */
void register_symbol (void);

/* Remove symbol from symbol table.  */
void remove (void);

/* Dump symtab node to F.  */
void dump (FILE *f);

/* Dump symtab callgraph in graphviz format.  */
void dump_graphviz (FILE *f);

/* Dump symtab node to stderr.  */
void DEBUG_FUNCTION__attribute__ ((__used__)) debug (void);

/* Verify consistency of node.  */
void DEBUG_FUNCTION__attribute__ ((__used__)) verify (void);

/* Return ipa reference from this symtab_node to
   REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
   of the use and STMT the statement (if it exists).  */
ipa_ref *create_reference (symtab_node *referred_node,
	     enum ipa_ref_use use_type);

/* Return ipa reference from this symtab_node to
   REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
   of the use and STMT the statement (if it exists).  */
ipa_ref *create_reference (symtab_node *referred_node,
	     enum ipa_ref_use use_type, gimple *stmt);

/* If VAL is a reference to a function or a variable, add a reference from
   this symtab_node to the corresponding symbol table node.  Return the new
   reference or NULL if none was created.  */
ipa_ref *maybe_create_reference (tree val, gimple *stmt);

/* Clone all references from symtab NODE to this symtab_node.  */
void clone_references (symtab_node *node);

/* Remove all stmt references in non-speculative references.
   Those are not maintained during inlining & clonning.
   The exception are speculative references that are updated along
   with callgraph edges associated with them.  */
void clone_referring (symtab_node *node);

/* Clone reference REF to this symtab_node and set its stmt to STMT.  */
ipa_ref *clone_reference (ipa_ref *ref, gimple *stmt);

/* Find the structure describing a reference to REFERRED_NODE
   and associated with statement STMT.  */
ipa_ref *find_reference (symtab_node *referred_node, gimple *stmt,
	   unsigned int lto_stmt_uid);

/* Remove all references that are associated with statement STMT.  */
void remove_stmt_references (gimple *stmt);

/* Remove all stmt references in non-speculative references.
   Those are not maintained during inlining & clonning.
   The exception are speculative references that are updated along
   with callgraph edges associated with them.  */
void clear_stmts_in_references (void);

/* Remove all references in ref list.  */
void remove_all_references (void);

/* Remove all referring items in ref list.  */
void remove_all_referring (void);

/* Dump references in ref list to FILE.  */
void dump_references (FILE *file);

/* Dump referring in list to FILE.  */
void dump_referring (FILE *);

/* Get number of references for this node.  */
inline unsigned num_references (void)
{
  return ref_list.references.length ();
}

/* Iterates I-th reference in the list, REF is also set.  */
ipa_ref *iterate_reference (unsigned i, ipa_ref *&ref);

/* Iterates I-th referring item in the list, REF is also set.  */
ipa_ref *iterate_referring (unsigned i, ipa_ref *&ref);

/* Iterates I-th referring alias item in the list, REF is also set.  */
ipa_ref *iterate_direct_aliases (unsigned i, ipa_ref *&ref);

/* Return true if symtab node and TARGET represents
   semantically equivalent symbols.  */
bool semantically_equivalent_p (symtab_node *target);

/* Classify symbol symtab node for partitioning.  */
enum symbol_partitioning_class get_partitioning_class (void);

/* Return comdat group.  */
tree get_comdat_group ()
  {
    return x_comdat_group;
  }

/* Return comdat group as identifier_node.  */
tree get_comdat_group_id ()
  {
    if (x_comdat_group && TREE_CODE (x_comdat_group)((enum tree_code) (x_comdat_group)->base.code) != IDENTIFIER_NODE)
x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group)decl_assembler_name (x_comdat_group);
    return x_comdat_group;
  }

/* Set comdat group.  */
void set_comdat_group (tree group)
  {
    gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE((void)(!(!group || ((enum tree_code) (group)->base.code) ==
 IDENTIFIER_NODE || (tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) (group)->base.code))] == tcc_declaration
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 262, __FUNCTION__), 0 : 0))
	   || DECL_P (group))((void)(!(!group || ((enum tree_code) (group)->base.code) ==
 IDENTIFIER_NODE || (tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) (group)->base.code))] == tcc_declaration
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 262, __FUNCTION__), 0 : 0));
    x_comdat_group = group;
  }

/* Return section as string.  */
const char * get_section () const
  {
    if (!x_section)
return NULLnullptr;
    return x_section->name;
  }

/* Remove node from same comdat group.   */
void remove_from_same_comdat_group (void);

/* Add this symtab_node to the same comdat group that OLD is in.  */
void add_to_same_comdat_group (symtab_node *old_node);

/* Dissolve the same_comdat_group list in which NODE resides.  */
void dissolve_same_comdat_group_list (void);

/* Return true when symtab_node is known to be used from other (non-LTO)
   object file. Known only when doing LTO via linker plugin.  */
bool used_from_object_file_p (void);

/* Walk the alias chain to return the symbol NODE is alias of.
   If NODE is not an alias, return 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.  */
symtab_node *ultimate_alias_target (enum availability *avail = NULLnullptr,
		      struct symtab_node *ref = NULLnullptr);

/* Return next reachable static symbol with initializer after NODE.  */
inline symtab_node *next_defined_symbol (void);

/* Add reference recording that symtab node is alias of TARGET.
   If TRANSPARENT is true make the alias to be transparent alias.
   The function can fail in the case of aliasing cycles; in this case
   it returns false.  */
bool resolve_alias (symtab_node *target, bool transparent = false);

/* C++ FE sometimes change linkage flags after producing same
   body aliases.  */
void fixup_same_cpp_alias_visibility (symtab_node *target);

/* Call callback on symtab node and aliases associated to this node.
   When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
   skipped.  */
bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *),
		    void *data,
		    bool include_overwrite);

/* If node cannot be interposable by static or dynamic linker to point to
   different definition, return this symbol. Otherwise look for alias with
   such property and if none exists, introduce new one.  */
symtab_node *noninterposable_alias (void);

/* Return node that alias is aliasing.  */
inline symtab_node *get_alias_target (void);

/* Return DECL that alias is aliasing.  */
inline tree get_alias_target_tree ();

/* Set section for symbol and its aliases.  */
void set_section (const char *section);

/* Like set_section, but copying the section name from another node.  */
void set_section (const symtab_node &other);

/* Set section, do not recurse into aliases.
   When one wants to change section of symbol and its aliases,
   use set_section.  */
void set_section_for_node (const char *section);

/* Like set_section_for_node, but copying the section name from another
   node.  */
void set_section_for_node (const symtab_node &other);

/* Set initialization priority to PRIORITY.  */
void set_init_priority (priority_type priority);

/* Return the initialization priority.  */
priority_type get_init_priority ();

/* Return availability of NODE when referenced from REF.  */
enum availability get_availability (symtab_node *ref = NULLnullptr);

/* During LTO stream-in this predicate can be used to check whether node
   in question prevails in the linking to save some memory usage.  */
bool prevailing_p (void);

/* Return true if NODE binds to current definition in final executable
   when referenced from REF.  If REF is NULL return conservative value
   for any reference.  */
bool binds_to_current_def_p (symtab_node *ref = NULLnullptr);

/* Make DECL local.  */
void make_decl_local (void);

/* Copy visibility from N.  */
void copy_visibility_from (symtab_node *n);

/* Return desired alignment of the definition.  This is NOT alignment useful
   to access THIS, because THIS may be interposable and DECL_ALIGN should
   be used instead.  It however must be guaranteed when output definition
   of THIS.  */
unsigned int definition_alignment ();

/* Return true if alignment can be increased.  */
bool can_increase_alignment_p ();

/* Increase alignment of symbol to ALIGN.  */
void increase_alignment (unsigned int align);

/* Return true if list contains an alias.  */
bool has_aliases_p (void);

/* Return true when the symbol is real symbol, i.e. it is not inline clone
   or abstract function kept for debug info purposes only.  */
bool real_symbol_p (void);

/* Return true when the symbol needs to be output to the LTO symbol table.  */
bool output_to_lto_symbol_table_p (void);

/* Determine if symbol declaration is needed.  That is, visible to something
   either outside this translation unit, something magic in the system
   configury. This function is used just during symbol creation.  */
bool needed_p (void);

/* Return true if this symbol is a function from the C frontend specified
   directly in RTL form (with "__RTL").  */
bool native_rtl_p () const;

/* Return true when there are references to the node.  */
bool referred_to_p (bool include_self = true);

/* Return true if symbol can be discarded by linker from the binary.
   Assume that symbol is used (so there is no need to take into account
   garbage collecting linkers)

   This can happen for comdats, commons and weaks when they are prevailed
   by other definition at static linking time.  */
inline bool
can_be_discarded_p (void)
{
  return ((DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 408, __FUNCTION__))->decl_common.decl_flag_1)
    && !in_other_partition)
   || ((get_comdat_group ()
 || DECL_COMMON (decl)((contains_struct_check ((decl), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 411, __FUNCTION__))->decl_with_vis.common_flag)
 || (DECL_SECTION_NAME (decl)decl_section_name (decl) && DECL_WEAK (decl)((contains_struct_check ((decl), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 412, __FUNCTION__))->decl_with_vis.weak_flag)))
&& ((resolution != LDPR_PREVAILING_DEF
     && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP)
    || flag_incremental_linkglobal_options.x_flag_incremental_link)
&& resolution != LDPR_PREVAILING_DEF_IRONLY));
}

/* Return true if NODE is local to a particular COMDAT group, and must not
   be named from outside the COMDAT.  This is used for C++ decloned
   constructors.  */
inline bool comdat_local_p (void)
{
  return (same_comdat_group && !TREE_PUBLIC (decl)((decl)->base.public_flag));
}

/* Return true if ONE and TWO are part of the same COMDAT group.  */
inline bool in_same_comdat_group_p (symtab_node *target);

/* Return true if symbol is known to be nonzero.  */
bool nonzero_address ();

/* Return 0 if symbol is known to have different address than S2,
   Return 1 if symbol is known to have same address as S2,
   return 2 otherwise. 

   If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
   and S2 is going to be accessed.  This eliminates the situations when
   either THIS or S2 is NULL and is useful for comparing bases when deciding
   about memory aliasing.  */
int equal_address_to (symtab_node *s2, bool memory_accessed = false);

/* Return true if symbol's address may possibly be compared to other
   symbol's address.  */
bool address_matters_p ();

/* Return true if NODE's address can be compared.  This use properties
   of NODE only and does not look if the address is actually taken in
   interesting way.  For that use ADDRESS_MATTERS_P instead.  */
bool address_can_be_compared_p (void);

/* Return symbol table node associated with DECL, if any,
   and NULL otherwise.  */
static inline symtab_node *get (const_tree decl)
{
  /* Check that we are called for sane type of object - functions
     and static or external variables.  */
  gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL((void)(!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL
 || (((enum tree_code) (decl)->base.code) == VAR_DECL &&
 (((decl)->base.static_flag) || ((contains_struct_check ((
decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 460, __FUNCTION__))->decl_common.decl_flag_1) || global_options
.x_in_lto_p))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 461, __FUNCTION__), 0 : 0))
	 || (TREE_CODE (decl) == VAR_DECL((void)(!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL
 || (((enum tree_code) (decl)->base.code) == VAR_DECL &&
 (((decl)->base.static_flag) || ((contains_struct_check ((
decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 460, __FUNCTION__))->decl_common.decl_flag_1) || global_options
.x_in_lto_p))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 461, __FUNCTION__), 0 : 0))
	     && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)((void)(!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL
 || (((enum tree_code) (decl)->base.code) == VAR_DECL &&
 (((decl)->base.static_flag) || ((contains_struct_check ((
decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 460, __FUNCTION__))->decl_common.decl_flag_1) || global_options
.x_in_lto_p))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 461, __FUNCTION__), 0 : 0))
		 || in_lto_p)))((void)(!(((enum tree_code) (decl)->base.code) == FUNCTION_DECL
 || (((enum tree_code) (decl)->base.code) == VAR_DECL &&
 (((decl)->base.static_flag) || ((contains_struct_check ((
decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 460, __FUNCTION__))->decl_common.decl_flag_1) || global_options
.x_in_lto_p))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 461, __FUNCTION__), 0 : 0));
  /* Check that the mapping is sane - perhaps this check can go away,
     but at the moment frontends tends to corrupt the mapping by calling
     memcpy/memset on the tree nodes.  */
  gcc_checking_assert (!decl->decl_with_vis.symtab_node((void)(!(!decl->decl_with_vis.symtab_node || decl->decl_with_vis
.symtab_node->decl == decl) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 466, __FUNCTION__), 0 : 0))
	 || decl->decl_with_vis.symtab_node->decl == decl)((void)(!(!decl->decl_with_vis.symtab_node || decl->decl_with_vis
.symtab_node->decl == decl) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 466, __FUNCTION__), 0 : 0));
  return decl->decl_with_vis.symtab_node;
}

/* Try to find a symtab node for declaration DECL and if it does not
   exist or if it corresponds to an inline clone, create a new one.  */
static inline symtab_node * get_create (tree node);

/* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
   Return NULL if there's no such node.  */
static symtab_node *get_for_asmname (const_tree asmname);

/* Verify symbol table for internal consistency.  */
static DEBUG_FUNCTION__attribute__ ((__used__)) void verify_symtab_nodes (void);

/* Perform internal consistency checks, if they are enabled.  */
static inline void checking_verify_symtab_nodes (void);

/* Type of the symbol.  */
ENUM_BITFIELD (symtab_type)enum symtab_type type : 8;

/* The symbols resolution.  */
ENUM_BITFIELD (ld_plugin_symbol_resolution)enum ld_plugin_symbol_resolution resolution : 8;

/*** Flags representing the symbol type.  ***/

/* True when symbol corresponds to a definition in current unit.
   set via finalize_function or finalize_decl  */
unsigned definition : 1;
/* True when symbol is an alias.
   Set by assemble_alias.  */
unsigned alias : 1;
/* When true the alias is translated into its target symbol either by GCC
   or assembler (it also may just be a duplicate declaration of the same
   linker name).

   Currently transparent aliases come in three different flavors
     - aliases having the same assembler name as their target (aka duplicated
declarations). In this case the assembler names compare via
assembler_names_equal_p and weakref is false
     - aliases that are renamed at a time being output to final file
by varasm.cc. For those DECL_ASSEMBLER_NAME have
IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler
name must be unique.
Weakrefs belong to this category when we target assembler without
.weakref directive.
     - weakrefs that are renamed by assembler via .weakref directive.
In this case the alias may or may not be definition (depending if
target declaration was seen by the compiler), weakref is set.
Unless we are before renaming statics, assembler names are different.

   Given that we now support duplicate declarations, the second option is
   redundant and will be removed.  */
unsigned transparent_alias : 1;
/* True when alias is a weakref.  */
unsigned weakref : 1;
/* C++ frontend produce same body aliases and extra name aliases for
   virtual functions and vtables that are obviously equivalent.
   Those aliases are bit special, especially because C++ frontend
   visibility code is so ugly it cannot get them right at first time
   and their visibility needs to be copied from their "masters" at
   the end of parsing.  */
unsigned cpp_implicit_alias : 1;
/* The alias is a symbol version.  */
unsigned symver : 1;
/* Set once the definition was analyzed.  The list of references and
   other properties are built during analysis.  */
unsigned analyzed : 1;
/* Set for write-only variables.  */
unsigned writeonly : 1;
/* Visibility of symbol was used for further optimization; do not
   permit further changes.  */
unsigned refuse_visibility_changes : 1;

/*** Visibility and linkage flags.  ***/

/* Set when function is visible by other units.  */
unsigned externally_visible : 1;
/* Don't reorder to other symbols having this set.  */
unsigned no_reorder : 1;
/* The symbol will be assumed to be used in an invisible way (like
   by an toplevel asm statement).  */
unsigned force_output : 1;
/* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be
   exported.  Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted
   to static and it does not inhibit optimization.  */
unsigned forced_by_abi : 1;
/* True when the name is known to be unique and thus it does not need mangling.  */
unsigned unique_name : 1;
/* Specify whether the section was set by user or by
   compiler via -ffunction-sections.  */
unsigned implicit_section : 1;
/* True when body and other characteristics have been removed by
   symtab_remove_unreachable_nodes. */
unsigned body_removed : 1;
/* True when symbol should comply to -fsemantic-interposition flag.  */
unsigned semantic_interposition : 1;

/*** WHOPR Partitioning flags.
     These flags are used at ltrans stage when only part of the callgraph is
     available. ***/

/* Set when variable is used from other LTRANS partition.  */
unsigned used_from_other_partition : 1;
/* Set when function is available in the other LTRANS partition.
   During WPA output it is used to mark nodes that are present in
   multiple partitions.  */
unsigned in_other_partition : 1;



/*** other flags.  ***/

/* Set when symbol has address taken. */
unsigned address_taken : 1;
/* Set when init priority is set.  */
unsigned in_init_priority_hash : 1;

/* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case
   of offloading, for separate compilation for a different target.  */
unsigned need_lto_streaming : 1;

/* Set when symbol can be streamed into bytecode for offloading.  */
unsigned offloadable : 1;

/* Set when symbol is an IFUNC resolver.  */
unsigned ifunc_resolver : 1;


/* Ordering of all symtab entries.  */
int order;

/* Declaration representing the symbol.  */
tree decl;

/* Linked list of symbol table entries starting with symtab_nodes.  */
symtab_node *next;
symtab_node *previous;

/* Linked list of symbols with the same asm name.  There may be multiple
   entries for single symbol name during LTO, because symbols are renamed
   only after partitioning.

   Because inline clones are kept in the assembler name has, they also produce
   duplicate entries.

   There are also several long standing bugs where frontends and builtin
   code produce duplicated decls.  */
symtab_node *next_sharing_asm_name;
symtab_node *previous_sharing_asm_name;

/* Circular list of nodes in the same comdat group if non-NULL.  */
symtab_node *same_comdat_group;

/* Vectors of referring and referenced entities.  */
ipa_ref_list GTY((skip)) ref_list;

/* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer
   depending to what was known to frontend on the creation time.
   Once alias is resolved, this pointer become NULL.  */
tree alias_target;

/* File stream where this node is being written to.  */
struct lto_file_decl_data * lto_file_data;

void *GTY ((skip)) aux;

/* Comdat group the symbol is in.  Can be private if GGC allowed that.  */
tree x_comdat_group;

/* Section name. Again can be private, if allowed.  */
section_hash_entry *x_section;

639protected:
/* Dump base fields of symtab nodes to F.  Not to be used directly.  */
void dump_base (FILE *);

/* Verify common part of symtab node.  */
bool DEBUG_FUNCTION__attribute__ ((__used__)) verify_base (void);

/* Remove node from symbol table.  This function is not used directly, but via
   cgraph/varpool node removal routines.  */
void unregister (struct clone_info *);

/* Return the initialization and finalization priority information for
   DECL.  If there is no previous priority information, a freshly
   allocated structure is returned.  */
struct symbol_priority_map *priority_info (void);

/* Worker for call_for_symbol_and_aliases_1.  */
bool call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *, void *),
		      void *data,
		      bool include_overwrite);
659private:
/* Workers for set_section.  */
static bool set_section_from_string (symtab_node *n, void *s);
static bool set_section_from_node (symtab_node *n, void *o);

/* Worker for symtab_resolve_alias.  */
static bool set_implicit_section (symtab_node *n, void *);

/* Worker searching noninterposable alias.  */
static bool noninterposable_alias (symtab_node *node, void *data);

/* Worker for ultimate_alias_target.  */
symtab_node *ultimate_alias_target_1 (enum availability *avail = NULLnullptr,
			symtab_node *ref = NULLnullptr);

/* Get dump name with normal or assembly name.  */
const char *get_dump_name (bool asm_name_p) const;
676};

678inline void
679symtab_node::checking_verify_symtab_nodes (void)
680{
if (flag_checkingglobal_options.x_flag_checking)
  symtab_node::verify_symtab_nodes ();
683}

685/* Walk all aliases for NODE.  */
686#define FOR_EACH_ALIAS(NODE, ALIAS)for (unsigned ALIAS_iter_ = 0; (NODE)->iterate_direct_aliases
 (ALIAS_iter_, ALIAS); ALIAS_iter_++)				\
for (unsigned ALIAS##_iter_ = 0;				\
     (NODE)->iterate_direct_aliases (ALIAS##_iter_, ALIAS);	\
     ALIAS##_iter_++)

691/* This is the information that is put into the cgraph local structure
 to recover a function.  */
693struct lto_file_decl_data;

695extern const char * const cgraph_availability_names[];
696extern const char * const ld_plugin_symbol_resolution_names[];
697extern const char * const tls_model_names[];

699/* Represent which DECL tree (or reference to such tree)
 will be replaced by another tree while versioning.  */
701struct GTY(()) ipa_replace_map
702{
/* The new (replacing) tree.  */
tree new_tree;
/* Parameter number to replace, when old_tree is NULL.  */
int parm_num;
/* Set if the newly added reference should not be an address one, but a load
   one from the operand of the ADDR_EXPR in NEW_TREE.  This is for cases when
   the corresponding parameter p is used only as *p.  */
unsigned force_load_ref : 1;
711};

713enum cgraph_simd_clone_arg_type
714{
SIMD_CLONE_ARG_TYPE_VECTOR,
SIMD_CLONE_ARG_TYPE_UNIFORM,
/* These are only for integer/pointer arguments passed by value.  */
SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP,
SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP,
/* These 6 are only for reference type arguments or arguments passed
   by reference.  */
SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP,
SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP,
SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP,
SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP,
SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP,
SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP,
SIMD_CLONE_ARG_TYPE_MASK
729};

731/* Function arguments in the original function of a SIMD clone.
 Supplementary data for `struct simd_clone'.  */

734struct GTY(()) cgraph_simd_clone_arg {
/* Original function argument as it originally existed in
   DECL_ARGUMENTS.  */
tree orig_arg;

/* orig_arg's function (or for extern functions type from
   TYPE_ARG_TYPES).  */
tree orig_type;

/* If argument is a vector, this holds the vector version of
   orig_arg that after adjusting the argument types will live in
   DECL_ARGUMENTS.  Otherwise, this is NULL.

   This basically holds:
     vector(simdlen) __typeof__(orig_arg) new_arg.  */
tree vector_arg;

/* vector_arg's type (or for extern functions new vector type.  */
tree vector_type;

/* If argument is a vector, this holds the array where the simd
   argument is held while executing the simd clone function.  This
   is a local variable in the cloned function.  Its content is
   copied from vector_arg upon entry to the clone.

   This basically holds:
     __typeof__(orig_arg) simd_array[simdlen].  */
tree simd_array;

/* A SIMD clone's argument can be either linear (constant or
   variable), uniform, or vector.  */
enum cgraph_simd_clone_arg_type arg_type;

/* Variable alignment if available, otherwise 0.  */
unsigned int alignment;

/* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is
   the constant linear step, if arg_type is
   SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of
   the uniform argument holding the step, otherwise 0.  */
HOST_WIDE_INTlong linear_step;
775};

777/* Specific data for a SIMD function clone.  */

779struct GTY(()) cgraph_simd_clone {
/* Number of words in the SIMD lane associated with this clone.  */
poly_uint64 simdlen;

/* Number of annotated function arguments in `args'.  This is
   usually the number of named arguments in FNDECL.  */
unsigned int nargs;

/* Max hardware vector size in bits for integral vectors.  */
poly_uint64 vecsize_int;

/* Max hardware vector size in bits for floating point vectors.  */
poly_uint64 vecsize_float;

/* Machine mode of the mask argument(s), if they are to be passed
   as bitmasks in integer argument(s).  VOIDmode if masks are passed
   as vectors of characteristic type.  */
machine_mode mask_mode;

/* The mangling character for a given vector size.  This is used
   to determine the ISA mangling bit as specified in the Intel
   Vector ABI.  */
unsigned char vecsize_mangle;

/* True if this is the masked, in-branch version of the clone,
   otherwise false.  */
unsigned int inbranch : 1;

/* Doubly linked list of SIMD clones.  */
cgraph_node *prev_clone, *next_clone;

/* Original cgraph node the SIMD clones were created for.  */
cgraph_node *origin;

/* Annotated function arguments for the original function.  */
cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1];
815};

817/* Function Multiversioning info.  */
818struct GTY((for_user)) cgraph_function_version_info {
/* The cgraph_node for which the function version info is stored.  */
cgraph_node *this_node;
/* Chains all the semantically identical function versions.  The
   first function in this chain is the version_info node of the
   default function.  */
cgraph_function_version_info *prev;
/* If this version node corresponds to a dispatcher for function
   versions, this points to the version info node of the default
   function, the first node in the chain.  */
cgraph_function_version_info *next;
/* If this node corresponds to a function version, this points
   to the dispatcher function decl, which is the function that must
   be called to execute the right function version at run-time.

   If this cgraph node is a dispatcher (if dispatcher_function is
   true, in the cgraph_node struct) for function versions, this
   points to resolver function, which holds the function body of the
   dispatcher. The dispatcher decl is an alias to the resolver
   function decl.  */
tree dispatcher_resolver;
839};

841#define DEFCIFCODE(code, type, string)CIF_code,	CIF_ ## code,
842/* Reasons for inlining failures.  */

844enum cgraph_inline_failed_t {
845#include "cif-code.def"
CIF_N_REASONS
847};

849enum cgraph_inline_failed_type_t
850{
CIF_FINAL_NORMAL = 0,
CIF_FINAL_ERROR
853};

855struct cgraph_edge;

857struct cgraph_edge_hasher : ggc_ptr_hash<cgraph_edge>
858{
typedef gimple *compare_type;

static hashval_t hash (cgraph_edge *);
static hashval_t hash (gimple *);
static bool equal (cgraph_edge *, gimple *);
864};

866/* The cgraph data structure.
 Each function decl has assigned cgraph_node listing callees and callers.  */

869struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node
870{
friend class symbol_table;

/* Constructor.  */
explicit cgraph_node (int uid)
  : symtab_node (SYMTAB_FUNCTION), callees (NULLnullptr), callers (NULLnullptr),
    indirect_calls (NULLnullptr),
    next_sibling_clone (NULLnullptr), prev_sibling_clone (NULLnullptr), clones (NULLnullptr),
    clone_of (NULLnullptr), call_site_hash (NULLnullptr), former_clone_of (NULLnullptr),
    simdclone (NULLnullptr), simd_clones (NULLnullptr), ipa_transforms_to_apply (vNULL),
    inlined_to (NULLnullptr), rtl (NULLnullptr),
    count (profile_count::uninitialized ()),
    count_materialization_scale (REG_BR_PROB_BASE10000), profile_id (0),
    unit_id (0), tp_first_run (0), thunk (false),
    used_as_abstract_origin (false),
    lowered (false), process (false), frequency (NODE_FREQUENCY_NORMAL),
    only_called_at_startup (false), only_called_at_exit (false),
    tm_clone (false), dispatcher_function (false), calls_comdat_local (false),
    icf_merged (false), nonfreeing_fn (false), merged_comdat (false),
    merged_extern_inline (false), parallelized_function (false),
    split_part (false), indirect_call_target (false), local (false),
    versionable (false), can_change_signature (false),
    redefined_extern_inline (false), tm_may_enter_irr (false),
    ipcp_clone (false), declare_variant_alt (false),
    calls_declare_variant_alt (false), gc_candidate (false),
    m_uid (uid), m_summary_id (-1)
{}

/* Remove the node from cgraph and all inline clones inlined into it.
   Skip however removal of FORBIDDEN_NODE and return true if it needs to be
   removed.  This allows to call the function from outer loop walking clone
   tree.  */
bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULLnullptr);

/* Record all references from cgraph_node that are taken
   in statement STMT.  */
void record_stmt_references (gimple *stmt);

/* Like cgraph_set_call_stmt but walk the clone tree and update all
   clones sharing the same function body.
   When WHOLE_SPECULATIVE_EDGES is true, all three components of
   speculative edge gets updated.  Otherwise we update only direct
   call.  */
void set_call_stmt_including_clones (gimple *old_stmt, gcall *new_stmt,
		       bool update_speculative = true);

/* Walk the alias chain to return the function cgraph_node is alias of.
   Walk through thunk, 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.  */
cgraph_node *function_symbol (enum availability *avail = NULLnullptr,
		struct symtab_node *ref = NULLnullptr);

/* 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.  */
cgraph_node *function_or_virtual_thunk_symbol
		(enum availability *avail = NULLnullptr,
		 struct symtab_node *ref = NULLnullptr);

/* Create node representing clone of N executed COUNT times.  Decrease
   the execution counts from original node too.
   The new clone will have decl set to DECL that may or may not be the same
   as decl of N.

   When UPDATE_ORIGINAL is true, the counts are subtracted from the original
   function's profile to reflect the fact that part of execution is handled
   by node.
   When CALL_DUPLICATION_HOOK is true, the ipa passes are acknowledged about
   the new clone. Otherwise the caller is responsible for doing so later.

   If the new node is being inlined into another one, NEW_INLINED_TO should be
   the outline function the new one is (even indirectly) inlined to.
   All hooks will see this in node's inlined_to, when invoked.
   Can be NULL if the node is not inlined.  SUFFIX is string that is appended
   to the original name.  */
cgraph_node *create_clone (tree decl, profile_count count,
	     bool update_original,
	     vec<cgraph_edge *> redirect_callers,
	     bool call_duplication_hook,
	     cgraph_node *new_inlined_to,
	     ipa_param_adjustments *param_adjustments,
	     const char *suffix = NULLnullptr);

/* Create callgraph node clone with new declaration.  The actual body will be
   copied later at compilation stage.  The name of the new clone will be
   constructed from the name of the original node, SUFFIX and NUM_SUFFIX.  */
cgraph_node *create_virtual_clone (const vec<cgraph_edge *> &redirect_callers,
		     vec<ipa_replace_map *, va_gc> *tree_map,
		     ipa_param_adjustments *param_adjustments,
		     const char * suffix, unsigned num_suffix);

/* Remove the node from the tree of virtual and inline clones and make it a
   standalone node - not a clone any more.  */
void remove_from_clone_tree ();

/* cgraph node being removed from symbol table; see if its entry can be
 replaced by other inline clone.  */
cgraph_node *find_replacement (struct clone_info *);

/* Create a new cgraph node which is the new version of
   callgraph node.  REDIRECT_CALLERS holds the callers
   edges which should be redirected to point to
   NEW_VERSION.  ALL the callees edges of the node
   are cloned to the new version node.  Return the new
   version node.

   If non-NULL BLOCK_TO_COPY determine what basic blocks
   was copied to prevent duplications of calls that are dead
   in the clone.

   SUFFIX is string that is appended to the original name.  */

cgraph_node *create_version_clone (tree new_decl,
		    vec<cgraph_edge *> redirect_callers,
		    bitmap bbs_to_copy,
		    const char *suffix = NULLnullptr);

/* Perform function versioning.
   Function versioning includes copying of the tree and
   a callgraph update (creating a new cgraph node and updating
   its callees and callers).

   REDIRECT_CALLERS varray includes the edges to be redirected
   to the new version.

   TREE_MAP is a mapping of tree nodes we want to replace with
   new ones (according to results of prior analysis).

   If non-NULL ARGS_TO_SKIP determine function parameters to remove
   from new version.
   If SKIP_RETURN is true, the new version will return void.
   If non-NULL BLOCK_TO_COPY determine what basic blocks to copy.
   If non_NULL NEW_ENTRY determine new entry BB of the clone.

   If TARGET_ATTRIBUTES is non-null, when creating a new declaration,
   add the attributes to DECL_ATTRIBUTES.  And call valid_attribute_p
   that will promote value of the attribute DECL_FUNCTION_SPECIFIC_TARGET
   of the declaration.

   If VERSION_DECL is set true, use clone_function_name_numbered for the
   function clone.  Otherwise, use clone_function_name.

   Return the new version's cgraph node.  */
cgraph_node *create_version_clone_with_body
  (vec<cgraph_edge *> redirect_callers,
   vec<ipa_replace_map *, va_gc> *tree_map,
   ipa_param_adjustments *param_adjustments,
   bitmap bbs_to_copy, basic_block new_entry_block, const char *clone_name,
   tree target_attributes = NULL_TREE(tree) nullptr, bool version_decl = true);

/* Insert a new cgraph_function_version_info node into cgraph_fnver_htab
   corresponding to cgraph_node.  */
cgraph_function_version_info *insert_new_function_version (void);

/* Get the cgraph_function_version_info node corresponding to node.  */
cgraph_function_version_info *function_version (void);

/* Discover all functions and variables that are trivially needed, analyze
   them as well as all functions and variables referred by them  */
void analyze (void);

/* 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 symtab-thunks.h for detail on the parameters.  */
cgraph_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);


/* Return node that alias is aliasing.  */
inline cgraph_node *get_alias_target (void);

/* Given function symbol, walk the alias chain to return the function node
   is alias of. Do not walk through thunks.
   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.  */

cgraph_node *ultimate_alias_target (availability *availability = NULLnullptr,
		      symtab_node *ref = NULLnullptr);

/*  Call expand_thunk on all callers that are thunks and analyze those
    nodes that were expanded.  */
void expand_all_artificial_thunks ();

/* Assemble thunks and aliases associated to node.  */
void assemble_thunks_and_aliases (void);

/* Expand function specified by node.  */
void expand (void);

/* As an GCC extension we allow redefinition of the function.  The
   semantics when both copies of bodies differ is not well defined.
   We replace the old body with new body so in unit at a time mode
   we always use new body, while in normal mode we may end up with
   old body inlined into some functions and new body expanded and
   inlined in others.  */
void reset (void);

/* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
   kind of wrapper method.  */
void create_wrapper (cgraph_node *target);

/* Verify cgraph nodes of the cgraph node.  */
void DEBUG_FUNCTION__attribute__ ((__used__)) verify_node (void);

/* Remove function from symbol table.  */
void remove (void);

/* Dump call graph node to file F.  */
void dump (FILE *f);

/* Dump call graph node to file F.  */
void dump_graphviz (FILE *f);

/* Dump call graph node to stderr.  */
void DEBUG_FUNCTION__attribute__ ((__used__)) debug (void);

/* When doing LTO, read cgraph_node's body from disk if it is not already
   present.  */
bool get_untransformed_body ();

/* 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.  */
bool get_body ();

void materialize_clone (void);

/* 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().  */
void release_body (bool keep_arguments = false);

/* Return the DECL_STRUCT_FUNCTION of the function.  */
struct function *get_fun () const;

/* Bring cgraph node local.  */
void make_local (void);

/* Likewise indicate that a node is having address taken.  */
void mark_address_taken (void);

/* Set finalization priority to PRIORITY.  */
void set_fini_priority (priority_type priority);

/* Return the finalization priority.  */
priority_type get_fini_priority (void);

/* Create edge from a given function to CALLEE in the cgraph.  */
cgraph_edge *create_edge (cgraph_node *callee,
	    gcall *call_stmt, profile_count count,
	    bool cloning_p = false);

/* 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. */
cgraph_edge *create_indirect_edge (gcall *call_stmt, int ecf_flags,
		     profile_count count,
		     bool cloning_p = false);

/* Like cgraph_create_edge walk the clone tree and update all clones sharing
 same function body.  If clones already have edge for OLD_STMT; only
 update the edge same way as cgraph_set_call_stmt_including_clones does.  */
void create_edge_including_clones (cgraph_node *callee,
		     gimple *old_stmt, gcall *stmt,
		     profile_count count,
		     cgraph_inline_failed_t reason);

/* Return the callgraph edge representing the GIMPLE_CALL statement
   CALL_STMT.  */
cgraph_edge *get_edge (gimple *call_stmt);

/* Collect all callers of cgraph_node and its aliases that are known to lead
   to NODE (i.e. are not overwritable) and that are not thunks.  */
auto_vec<cgraph_edge *> collect_callers (void);

/* Remove all callers from the node.  */
void remove_callers (void);

/* Remove all callees from the node.  */
void remove_callees (void);

/* Return function availability.  See cgraph.h for description of individual
   return values.  */
enum availability get_availability (symtab_node *ref = NULLnullptr);

/* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node
   if any to NOTHROW.  */
bool set_nothrow_flag (bool nothrow);

/* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node
   if any.  */
bool set_malloc_flag (bool malloc_p);

/* SET TREE_THIS_VOLATILE on cgraph_node's decl and on aliases of the node
   if any.  */
bool set_noreturn_flag (bool noreturn_p);

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

bool set_const_flag (bool set_const, bool looping);

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

bool set_pure_flag (bool pure, bool looping);

/* Call callback on function and aliases associated to the function.
   When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
   skipped. */

bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
				      void *),
		    void *data, bool include_overwritable);

/* Call callback on cgraph_node, thunks and aliases associated to NODE.
   When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
   skipped.  When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are
   skipped.  */
bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node,
					     void *data),
			   void *data,
			   bool include_overwritable,
			   bool exclude_virtual_thunks = false);

/* Likewise indicate that a node is needed, i.e. reachable via some
   external means.  */
inline void mark_force_output (void);

/* Return true when function can be marked local.  */
bool local_p (void);

/* 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.  */
bool can_be_local_p (void);

/* Return true when cgraph_node cannot return or throw and thus
   it is safe to ignore its side effects for IPA analysis.  */
bool cannot_return_p (void);

/* 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.  */
bool only_called_directly_p (void);

/* Return true when function is only called directly or it has alias.
   i.e. it is not externally visible, address was not taken and
   it is not used in any other non-standard way.  */
inline bool only_called_directly_or_aliased_p (void);

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

   If WILL_INLINE is true, assume that function will be inlined into all the
   direct calls.  */
bool will_be_removed_from_program_if_no_direct_calls_p
(bool will_inline = false);

/* Return true when function can be removed from callgraph
   if all direct calls and references are eliminated.  The function does
   not take into account comdat groups.  */
bool can_remove_if_no_direct_calls_and_refs_p (void);

/* Return true when function cgraph_node and its aliases can be removed from
   callgraph if all direct calls are eliminated. 
   If WILL_INLINE is true, assume that function will be inlined into all the
   direct calls.  */
bool can_remove_if_no_direct_calls_p (bool will_inline = false);

/* Return true when callgraph node is a function with Gimple body defined
   in current unit.  Functions can also be define externally or they
   can be thunks with no Gimple representation.

   Note that at WPA stage, the function body may not be present in memory.  */
inline bool has_gimple_body_p (void);

/* Return true if this node represents a former, i.e. an expanded, thunk.  */
bool former_thunk_p (void);

/* Check if function calls comdat local.  This is used to recompute
   calls_comdat_local flag after function transformations.  */
bool check_calls_comdat_local_p ();

/* Return true if function should be optimized for size.  */
enum optimize_size_level optimize_for_size_p (void);

/* Dump the callgraph to file F.  */
static void dump_cgraph (FILE *f);

/* Dump the call graph to stderr.  */
static inline
void debug_cgraph (void)
{
  dump_cgraph (stderrstderr);
}

/* Get unique identifier of the node.  */
inline int get_uid ()
{
  return m_uid;
}

/* Get summary id of the node.  */
inline int get_summary_id ()
{
  return m_summary_id;
}

/* Record that DECL1 and DECL2 are semantically identical function
   versions.  */
static void record_function_versions (tree decl1, tree decl2);

/* Remove the cgraph_function_version_info and cgraph_node for DECL.  This
   DECL is a duplicate declaration.  */
static void delete_function_version_by_decl (tree decl);

/* Add the function FNDECL to the call graph.
   Unlike finalize_function, this function is intended to be used
   by middle end and allows insertion of new function at arbitrary point
   of compilation.  The function can be either in high, low or SSA form
   GIMPLE.

   The function is assumed to be reachable and have address taken (so no
   API breaking optimizations are performed on it).

   Main work done by this function is to enqueue the function for later
   processing to avoid need the passes to be re-entrant.  */
static void add_new_function (tree fndecl, bool lowered);

/* Return callgraph node for given symbol and check it is a function. */
static inline cgraph_node *get (const_tree decl)
{
  gcc_checking_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.h"
, 1336, __FUNCTION__), 0 : 0));
  return dyn_cast <cgraph_node *> (symtab_node::get (decl));
}

/* DECL has been parsed.  Take it, queue it, compile it at the whim of the
   logic in effect.  If NO_COLLECT is true, then our caller cannot stand to
   have the garbage collector run at the moment.  We would need to either
   create a new GC context, or just not compile right now.  */
static void finalize_function (tree, bool);

/* Return cgraph node assigned to DECL.  Create new one when needed.  */
static cgraph_node * create (tree decl);

/* 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.  */
static cgraph_node * get_create (tree);

/* Return local info for the compiled function.  */
static cgraph_node *local_info_node (tree decl);

/* Return RTL info for the compiled function.  */
static struct cgraph_rtl_info *rtl_info (const_tree);

/* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
   Return NULL if there's no such node.  */
static cgraph_node *get_for_asmname (tree asmname);

/* 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).  */
static cgraph_node * create_same_body_alias (tree alias, tree decl);

/* Verify whole cgraph structure.  */
static void DEBUG_FUNCTION__attribute__ ((__used__)) verify_cgraph_nodes (void);

/* Verify cgraph, if consistency checking is enabled.  */
static inline void checking_verify_cgraph_nodes (void);

/* Worker to bring NODE local.  */
static bool make_local (cgraph_node *node, void *);

/* Mark ALIAS as an alias to DECL.  DECL_NODE is cgraph node representing
   the function body is associated
   with (not necessarily cgraph_node (DECL).  */
static cgraph_node *create_alias (tree alias, tree target);

/* Return true if NODE has thunk.  */
static bool has_thunk_p (cgraph_node *node, void *);

cgraph_edge *callees;
cgraph_edge *callers;
/* List of edges representing indirect calls with a yet undetermined
   callee.  */
cgraph_edge *indirect_calls;
cgraph_node *next_sibling_clone;
cgraph_node *prev_sibling_clone;
cgraph_node *clones;
cgraph_node *clone_of;
/* For functions with many calls sites it holds map from call expression
   to the edge to speed up cgraph_edge function.  */
hash_table<cgraph_edge_hasher> *GTY(()) call_site_hash;
/* Declaration node used to be clone of. */
tree former_clone_of;

/* If this is a SIMD clone, this points to the SIMD specific
   information for it.  */
cgraph_simd_clone *simdclone;
/* If this function has SIMD clones, this points to the first clone.  */
cgraph_node *simd_clones;

/* Interprocedural passes scheduled to have their transform functions
   applied next time we execute local pass on them.  We maintain it
   per-function in order to allow IPA passes to introduce new functions.  */
vec<ipa_opt_pass, va_heap, vl_ptr> GTY((skip)) ipa_transforms_to_apply;

/* For inline clones this points to the function they will be
   inlined into.  */
cgraph_node *inlined_to;

struct cgraph_rtl_info *rtl;

/* Expected number of executions: calculated in profile.cc.  */
profile_count count;
/* How to scale counts at materialization time; used to merge
   LTO units with different number of profile runs.  */
int count_materialization_scale;
/* ID assigned by the profiling.  */
unsigned int profile_id;
/* ID of the translation unit.  */
int unit_id;
/* Time profiler: first run of function.  */
int tp_first_run;

/* True when symbol is a thunk.  */
unsigned thunk : 1;
/* Set when decl is an abstract function pointed to by the
   ABSTRACT_DECL_ORIGIN of a reachable function.  */
unsigned used_as_abstract_origin : 1;
/* Set once the function is lowered (i.e. its CFG is built).  */
unsigned lowered : 1;
/* Set once the function has been instantiated and its callee
   lists created.  */
unsigned process : 1;
/* How commonly executed the node is.  Initialized during branch
   probabilities pass.  */
ENUM_BITFIELD (node_frequency)enum node_frequency frequency : 2;
/* True when function can only be called at startup (from static ctor).  */
unsigned only_called_at_startup : 1;
/* True when function can only be called at startup (from static dtor).  */
unsigned only_called_at_exit : 1;
/* True when function is the transactional clone of a function which
   is called only from inside transactions.  */
/* ?? We should be able to remove this.  We have enough bits in
   cgraph to calculate it.  */
unsigned tm_clone : 1;
/* True if this decl is a dispatcher for function versions.  */
unsigned dispatcher_function : 1;
/* True if this decl calls a COMDAT-local function.  This is set up in
   compute_fn_summary and inline_call.  */
unsigned calls_comdat_local : 1;
/* True if node has been created by merge operation in IPA-ICF.  */
unsigned icf_merged: 1;
/* True if call to node can't result in a call to free, munmap or
   other operation that could make previously non-trapping memory
   accesses trapping.  */
unsigned nonfreeing_fn : 1;
/* True if there was multiple COMDAT bodies merged by lto-symtab.  */
unsigned merged_comdat : 1;
/* True if this def was merged with extern inlines.  */
unsigned merged_extern_inline : 1;
/* True if function was created to be executed in parallel.  */
unsigned parallelized_function : 1;
/* True if function is part split out by ipa-split.  */
unsigned split_part : 1;
/* True if the function appears as possible target of indirect call.  */
unsigned indirect_call_target : 1;
/* Set when function is visible in current compilation unit only and
   its address is never taken.  */
unsigned local : 1;
/* False when there is something makes versioning impossible.  */
unsigned versionable : 1;
/* False when function calling convention and signature cannot be changed.
   This is the case when __builtin_apply_args is used.  */
unsigned can_change_signature : 1;
/* True when the function has been originally extern inline, but it is
   redefined now.  */
unsigned redefined_extern_inline : 1;
/* True if the function may enter serial irrevocable mode.  */
unsigned tm_may_enter_irr : 1;
/* True if this was a clone created by ipa-cp.  */
unsigned ipcp_clone : 1;
/* True if this is the deferred declare variant resolution artificial
   function.  */
unsigned declare_variant_alt : 1;
/* True if the function calls declare_variant_alt functions.  */
unsigned calls_declare_variant_alt : 1;
/* True if the function should only be emitted if it is used.  This flag
   is set for local SIMD clones when they are created and cleared if the
   vectorizer uses them.  */
unsigned gc_candidate : 1;

1499private:
/* Unique id of the node.  */
int m_uid;

/* Summary id that is recycled.  */
int m_summary_id;

/* Worker for call_for_symbol_and_aliases.  */
bool call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *,
				        void *),
		      void *data, bool include_overwritable);
1510};

1512/* A cgraph node set is a collection of cgraph nodes.  A cgraph node
 can appear in multiple sets.  */
1514struct cgraph_node_set_def
1515{
hash_map<cgraph_node *, size_t> *map;
vec<cgraph_node *> nodes;
1518};

1520typedef cgraph_node_set_def *cgraph_node_set;
1521typedef struct varpool_node_set_def *varpool_node_set;

1523struct varpool_node;

1525/* A varpool node set is a collection of varpool nodes.  A varpool node
 can appear in multiple sets.  */
1527struct varpool_node_set_def
1528{
hash_map<varpool_node *, size_t> * map;
vec<varpool_node *> nodes;
1531};

1533/* Iterator structure for cgraph node sets.  */
1534struct cgraph_node_set_iterator
1535{
cgraph_node_set set;
unsigned index;
1538};

1540/* Iterator structure for varpool node sets.  */
1541struct varpool_node_set_iterator
1542{
varpool_node_set set;
unsigned index;
1545};

1547/* Context of polymorphic call. It represent information about the type of
 instance that may reach the call.  This is used by ipa-devirt walkers of the
 type inheritance graph.  */

1551class GTY(()) ipa_polymorphic_call_context {
1552public:
/* The called object appears in an object of type OUTER_TYPE
   at offset OFFSET.  When information is not 100% reliable, we
   use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
HOST_WIDE_INTlong offset;
HOST_WIDE_INTlong speculative_offset;
tree outer_type;
tree speculative_outer_type;
/* True if outer object may be in construction or destruction.  */
unsigned maybe_in_construction : 1;
/* True if outer object may be of derived type.  */
unsigned maybe_derived_type : 1;
/* True if speculative outer object may be of derived type.  We always
   speculate that construction does not happen.  */
unsigned speculative_maybe_derived_type : 1;
/* True if the context is invalid and all calls should be redirected
   to BUILTIN_UNREACHABLE.  */
unsigned invalid : 1;
/* True if the outer type is dynamic.  */
unsigned dynamic : 1;

/* Build empty "I know nothing" context.  */
ipa_polymorphic_call_context ();
/* Build polymorphic call context for indirect call E.  */
ipa_polymorphic_call_context (cgraph_edge *e);
/* Build polymorphic call context for IP invariant CST.
   If specified, OTR_TYPE specify the type of polymorphic call
   that takes CST+OFFSET as a parameter.  */
ipa_polymorphic_call_context (tree cst, tree otr_type = NULLnullptr,
		HOST_WIDE_INTlong offset = 0);
/* Build context for pointer REF contained in FNDECL at statement STMT.
   if INSTANCE is non-NULL, return pointer to the object described by
   the context.  */
ipa_polymorphic_call_context (tree fndecl, tree ref, gimple *stmt,
		tree *instance = NULLnullptr);

/* Look for vtable stores or constructor calls to work out dynamic type
   of memory location.  */
bool get_dynamic_type (tree, tree, tree, gimple *, unsigned *);

/* Make context non-speculative.  */
void clear_speculation ();

/* Produce context specifying all derived types of OTR_TYPE.  If OTR_TYPE is
   NULL, the context is set to dummy "I know nothing" setting.  */
void clear_outer_type (tree otr_type = NULLnullptr);

/* Walk container types and modify context to point to actual class
   containing OTR_TYPE (if non-NULL) as base class.
   Return true if resulting context is valid.

   When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
   valid only via allocation of new polymorphic type inside by means
   of placement new.

   When CONSIDER_BASES is false, only look for actual fields, not base types
   of TYPE.  */
bool restrict_to_inner_class (tree otr_type,
		bool consider_placement_new = true,
		bool consider_bases = true);

/* Adjust all offsets in contexts by given number of bits.  */
void offset_by (HOST_WIDE_INTlong);
/* Use when we cannot track dynamic type change.  This speculatively assume
   type change is not happening.  */
void possible_dynamic_type_change (bool, tree otr_type = NULLnullptr);
/* Assume that both THIS and a given context is valid and strengthen THIS
   if possible.  Return true if any strengthening was made.
   If actual type the context is being used in is known, OTR_TYPE should be
   set accordingly. This improves quality of combined result.  */
bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULLnullptr);
bool meet_with (ipa_polymorphic_call_context, tree otr_type = NULLnullptr);

/* Return TRUE if context is fully useless.  */
bool useless_p () const;
/* Return TRUE if this context conveys the same information as X.  */
bool equal_to (const ipa_polymorphic_call_context &x) const;

/* Dump human readable context to F.  If NEWLINE is true, it will be
   terminated by a newline.  */
void dump (FILE *f, bool newline = true) const;
void DEBUG_FUNCTION__attribute__ ((__used__)) debug () const;

/* LTO streaming.  */
void stream_out (struct output_block *) const;
void stream_in (class lto_input_block *, class data_in *data_in);

1639private:
bool combine_speculation_with (tree, HOST_WIDE_INTlong, bool, tree);
bool meet_speculation_with (tree, HOST_WIDE_INTlong, bool, tree);
void set_by_decl (tree, HOST_WIDE_INTlong);
bool set_by_invariant (tree, tree, HOST_WIDE_INTlong);
bool speculation_consistent_p (tree, HOST_WIDE_INTlong, bool, tree) const;
void make_speculative (tree otr_type = NULLnullptr);
1646};

1648/* Structure containing additional information about an indirect call.  */

1650class GTY(()) cgraph_indirect_call_info
1651{
1652public:
/* When agg_content is set, an offset where the call pointer is located
   within the aggregate.  */
HOST_WIDE_INTlong offset;
/* Context of the polymorphic call; use only when POLYMORPHIC flag is set.  */
ipa_polymorphic_call_context context;
/* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set).  */
HOST_WIDE_INTlong otr_token;
/* Type of the object from OBJ_TYPE_REF_OBJECT. */
tree otr_type;
/* Index of the parameter that is called.  */
int param_index;
/* ECF flags determined from the caller.  */
int ecf_flags;

/* Number of speculative call targets, it's less than GCOV_TOPN_VALUES.  */
unsigned num_speculative_call_targets : 16;

/* Set when the call is a virtual call with the parameter being the
   associated object pointer rather than a simple direct call.  */
unsigned polymorphic : 1;
/* Set when the call is a call of a pointer loaded from contents of an
   aggregate at offset.  */
unsigned agg_contents : 1;
/* Set when this is a call through a member pointer.  */
unsigned member_ptr : 1;
/* When the agg_contents bit is set, this one determines whether the
   destination is loaded from a parameter passed by reference. */
unsigned by_ref : 1;
/* When the agg_contents bit is set, this one determines whether we can
   deduce from the function body that the loaded value from the reference is
   never modified between the invocation of the function and the load
   point.  */
unsigned guaranteed_unmodified : 1;
/* For polymorphic calls this specify whether the virtual table pointer
   may have changed in between function entry and the call.  */
unsigned vptr_changed : 1;
1689};

1691class GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"),
  for_user)) cgraph_edge
1693{
1694public:
friend struct cgraph_node;
friend class symbol_table;

/* Remove EDGE from the cgraph.  */
static void remove (cgraph_edge *edge);

/* 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.  */
static cgraph_edge *set_call_stmt (cgraph_edge *e, gcall *new_stmt,
		     bool update_speculative = true);

/* Redirect callee of the edge to N.  The function does not update underlying
   call expression.  */
void redirect_callee (cgraph_node *n);

/* If the edge does not lead to a thunk, simply redirect it to N.  Otherwise
   create one or more equivalent thunks for N and redirect E to the first in
   the chain.  Note that it is then necessary to call
   n->expand_all_artificial_thunks once all callers are redirected.  */
void redirect_callee_duplicating_thunks (cgraph_node *n);

/* Make an indirect 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.  */
static cgraph_edge *make_direct (cgraph_edge *edge, cgraph_node *callee);

/* Turn edge into speculative call calling N2. Update
   the profile so the direct call is taken COUNT times
   with FREQUENCY.  speculative_id is used to link direct calls with their
   corresponding IPA_REF_ADDR references when representing speculative calls.
 */
cgraph_edge *make_speculative (cgraph_node *n2, profile_count direct_count,
		 unsigned int speculative_id = 0);

/* Speculative call consists of an indirect edge and one or more
   direct edge+ref pairs.  Speculative will expand to the following sequence:

   if (call_dest == target1)		// reference to target1
target1 ();			// direct call to target1
   else if (call_dest == target2)	// reference to targt2
target2 ();			// direct call to target2
   else
call_dest ();			// indirect call

   Before the expansion we will have indirect call and the direct call+ref
   pairs all linked to single statement.

   Note that ref may point to different symbol than the corresponding call
   becuase the speculated edge may have been optimized (redirected to
   a clone) or inlined.

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

   In the example above called on any cgraph edge in the sequence it will
   return direct call to target1.  */
cgraph_edge *first_speculative_call_target ();

/* Return next speculative call target or NULL if there is none.
   All targets are required to form an interval in the callee list.

   In example above, if called on call to target1 it will return call to
   target2.  */
cgraph_edge *next_speculative_call_target ()
{
  cgraph_edge *e = this;
  gcc_checking_assert (speculative && callee)((void)(!(speculative && callee) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 1764, __FUNCTION__), 0 : 0));

  if (e->next_callee && e->next_callee->speculative
&& e->next_callee->call_stmt == e->call_stmt
&& e->next_callee->lto_stmt_uid == e->lto_stmt_uid)
    return e->next_callee;
  return NULLnullptr;
}

/* When called on any edge in the speculative call return the (unique)
   indirect call edge in the speculative call sequence.  */
cgraph_edge *speculative_call_indirect_edge ()
{
  gcc_checking_assert (speculative)((void)(!(speculative) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 1777, __FUNCTION__), 0 : 0));
  if (!callee)
    return this;
  for (cgraph_edge *e2 = caller->indirect_calls;
true; e2 = e2->next_callee)
    if (e2->speculative
 && call_stmt == e2->call_stmt
 && lto_stmt_uid == e2->lto_stmt_uid)
return e2;
}

/* When called on any edge in speculative call and when given any target
   of ref which is speculated to it returns the corresponding direct call.

   In example above if called on function target2 it will return call to
   target2.  */
cgraph_edge *speculative_call_for_target (cgraph_node *);

/* Return REF corresponding to direct call in the specualtive call
   sequence.  */
ipa_ref *speculative_call_target_ref ()
{
  ipa_ref *ref;

  gcc_checking_assert (speculative)((void)(!(speculative) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 1801, __FUNCTION__), 0 : 0));
  for (unsigned int i = 0; caller->iterate_reference (i, ref); i++)
    if (ref->speculative && ref->speculative_id == speculative_id
 && ref->stmt == (gimple *)call_stmt
 && ref->lto_stmt_uid == lto_stmt_uid)
return ref;
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 1807, __FUNCTION__));
}

/* 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.  It is up to caller to
   redirect the call as appropriate.  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.  */
static cgraph_edge *resolve_speculation (cgraph_edge *edge,
			   tree callee_decl = NULLnullptr);

/* If necessary, change the function declaration in the call statement
   associated with edge 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.  */
static gimple *redirect_call_stmt_to_callee (cgraph_edge *e);

/* Create clone of edge in the node N represented
   by CALL_EXPR the callgraph.  */
cgraph_edge * clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid,
       profile_count num, profile_count den,
       bool update_original);

/* Verify edge count and frequency.  */
bool verify_count ();

/* 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.  */
bool cannot_lead_to_return_p (void);

/* Return true when the edge represents a direct recursion.  */
bool recursive_p (void);

/* Return true if the edge may be considered hot.  */
bool maybe_hot_p (void);

/* Get unique identifier of the edge.  */
inline int get_uid ()
{
  return m_uid;
}

/* Get summary id of the edge.  */
inline int get_summary_id ()
{
  return m_summary_id;
}

/* Rebuild cgraph edges for current function node.  This needs to be run after
   passes that don't update the cgraph.  */
static unsigned int rebuild_edges (void);

/* Rebuild cgraph references for current function node.  This needs to be run
   after passes that don't update the cgraph.  */
static void rebuild_references (void);

/* During LTO stream in this can be used to check whether call can possibly
   be internal to the current translation unit.  */
bool possibly_call_in_translation_unit_p (void);

/* Return num_speculative_targets of this edge.  */
int num_speculative_call_targets_p (void);

/* Expected number of executions: calculated in profile.cc.  */
profile_count count;
cgraph_node *caller;
cgraph_node *callee;
cgraph_edge *prev_caller;
cgraph_edge *next_caller;
cgraph_edge *prev_callee;
cgraph_edge *next_callee;
gcall *call_stmt;
/* Additional information about an indirect call.  Not cleared when an edge
   becomes direct.  */
cgraph_indirect_call_info *indirect_info;
void *GTY ((skip (""))) aux;
/* When equal to CIF_OK, inline this call.  Otherwise, points to the
   explanation why function was not inlined.  */
enum cgraph_inline_failed_t inline_failed;
/* The stmt_uid of call_stmt.  This is used by LTO to recover the call_stmt
   when the function is serialized in.  */
unsigned int lto_stmt_uid;
/* speculative id is used to link direct calls with their corresponding
   IPA_REF_ADDR references when representing speculative calls.  */
unsigned int speculative_id : 16;
/* Whether this edge was made direct by indirect inlining.  */
unsigned int indirect_inlining_edge : 1;
/* Whether this edge describes an indirect call with an undetermined
   callee.  */
unsigned int indirect_unknown_callee : 1;
/* Whether this edge is still a dangling  */
/* True if the corresponding CALL stmt cannot be inlined.  */
unsigned int call_stmt_cannot_inline_p : 1;
/* Can this call throw externally?  */
unsigned int can_throw_external : 1;
/* Edges with SPECULATIVE flag represents indirect calls that was
   speculatively turned into direct (i.e. by profile feedback).
   The final code sequence will have form:

   if (call_target == expected_fn)
     expected_fn ();
   else
     call_target ();

   Every speculative call is represented by three components attached
   to a same call statement:
   1) a direct call (to expected_fn)
   2) an indirect call (to call_target)
   3) a IPA_REF_ADDR reference to expected_fn.

   Optimizers may later redirect direct call to clone, so 1) and 3)
   do not need to necessarily agree with destination.  */
unsigned int speculative : 1;
/* Set to true when caller is a constructor or destructor of polymorphic
   type.  */
unsigned in_polymorphic_cdtor : 1;

/* Return true if call must bind to current definition.  */
bool binds_to_current_def_p ();

/* Expected frequency of executions within the function.
   When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
   per function call.  The range is 0 to CGRAPH_FREQ_MAX.  */
int frequency ();

/* Expected frequency of executions within the function.  */
sreal sreal_frequency ();
1955private:
/* Unique id of the edge.  */
int m_uid;

/* Summary id that is recycled.  */
int m_summary_id;

/* Remove the edge from the list of the callers of the callee.  */
void remove_caller (void);

/* Remove the edge from the list of the callees of the caller.  */
void remove_callee (void);

/* Set callee N of call graph edge and add it to the corresponding set of
   callers. */
void set_callee (cgraph_node *n);

/* Output flags of edge to a file F.  */
void dump_edge_flags (FILE *f);

/* Dump edge to stderr.  */
void DEBUG_FUNCTION__attribute__ ((__used__)) debug (void);

/* Verify that call graph edge corresponds to DECL from the associated
   statement.  Return true if the verification should fail.  */
bool verify_corresponds_to_fndecl (tree decl);
1981};

1983#define CGRAPH_FREQ_BASE1000 1000
1984#define CGRAPH_FREQ_MAX100000 100000

1986/* The varpool data structure.
 Each static variable decl has assigned varpool_node.  */

1989struct GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node
1990{
/* Constructor.  */
explicit varpool_node ()
  : symtab_node (SYMTAB_VARIABLE), output (0), dynamically_initialized (0),
    tls_model (TLS_MODEL_NONE), used_by_single_function (0)
{}

/* Dump given varpool node to F.  */
void dump (FILE *f);

/* Dump given varpool node to stderr.  */
void DEBUG_FUNCTION__attribute__ ((__used__)) debug (void);

/* Remove variable from symbol table.  */
void remove (void);

/* Remove node initializer when it is no longer needed.  */
void remove_initializer (void);

void analyze (void);

/* Return variable availability.  */
availability get_availability (symtab_node *ref = NULLnullptr);

/* When doing LTO, read variable's constructor from disk if
   it is not already present.  */
tree get_constructor (void);

/* Return true if variable has constructor that can be used for folding.  */
bool ctor_useable_for_folding_p (void);

/* For given variable pool node, walk the alias chain to return the function
   the variable is alias of. Do not walk through thunks.
   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.  */
inline varpool_node *ultimate_alias_target
  (availability *availability = NULLnullptr, symtab_node *ref = NULLnullptr);

/* Return node that alias is aliasing.  */
inline varpool_node *get_alias_target (void);

/* Output one variable, if necessary.  Return whether we output it.  */
bool assemble_decl (void);

/* For variables in named sections make sure get_variable_section
   is called before we switch to those sections.  Then section
   conflicts between read-only and read-only requiring relocations
   sections can be resolved.  */
void finalize_named_section_flags (void);

/* Call callback on varpool symbol and aliases associated to varpool symbol.
   When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are
   skipped. */
bool call_for_symbol_and_aliases (bool (*callback) (varpool_node *, void *),
		    void *data,
		    bool include_overwritable);

/* Return true when variable should be considered externally visible.  */
bool externally_visible_p (void);

/* Return true when all references to variable must be visible
   in ipa_ref_list.
   i.e. if the variable is not externally visible or not used in some magic
   way (asm statement or such).
   The magic uses are all summarized in force_output flag.  */
inline bool all_refs_explicit_p ();

/* Return true when variable can be removed from variable pool
   if all direct calls are eliminated.  */
inline bool can_remove_if_no_refs_p (void);

/* Add the variable DECL to the varpool.
   Unlike finalize_decl function is intended to be used
   by middle end and allows insertion of new variable at arbitrary point
   of compilation.  */
static void add (tree decl);

/* Return varpool node for given symbol and check it is a function. */
static inline varpool_node *get (const_tree decl);

/* Mark DECL as finalized.  By finalizing the declaration, frontend instruct
   the middle end to output the variable to asm file, if needed or externally
   visible.  */
static void finalize_decl (tree decl);

/* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
   Extra name aliases are output whenever DECL is output.  */
static varpool_node * create_extra_name_alias (tree alias, tree decl);

/* Attempt to mark ALIAS as an alias to DECL.  Return TRUE if successful.
   Extra name aliases are output whenever DECL is output.  */
static varpool_node * create_alias (tree, tree);

/* Dump the variable pool to F.  */
static void dump_varpool (FILE *f);

/* Dump the variable pool to stderr.  */
static void DEBUG_FUNCTION__attribute__ ((__used__)) debug_varpool (void);

/* Allocate new callgraph node and insert it into basic data structures.  */
static varpool_node *create_empty (void);

/* Return varpool node assigned to DECL.  Create new one when needed.  */
static varpool_node *get_create (tree decl);

/* Given an assembler name, lookup node.  */
static varpool_node *get_for_asmname (tree asmname);

/* Set when variable is scheduled to be assembled.  */
unsigned output : 1;

/* Set if the variable is dynamically initialized, except for
   function local statics.   */
unsigned dynamically_initialized : 1;

ENUM_BITFIELD(tls_model)enum tls_model tls_model : 3;

/* Set if the variable is known to be used by single function only.
   This is computed by ipa_single_use pass and used by late optimizations
   in places where optimization would be valid for local static variable
   if we did not do any inter-procedural code movement.  */
unsigned used_by_single_function : 1;

2114private:
/* Assemble thunks and aliases associated to varpool node.  */
void assemble_aliases (void);

/* Worker for call_for_node_and_aliases.  */
bool call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *, void *),
		      void *data,
		      bool include_overwritable);
2122};

2124/* Every top level asm statement is put into a asm_node.  */

2126struct GTY(()) asm_node {
/* Next asm node.  */
asm_node *next;
/* String for this asm node.  */
tree asm_str;
/* Ordering of all cgraph nodes.  */
int order;
2133};

2135/* Report whether or not THIS symtab node is a function, aka cgraph_node.  */

2137template <>
2138template <>
2139inline bool
2140is_a_helper <cgraph_node *>::test (symtab_node *p)
2141{
return p7.1
'p' is non-null
1
'p' is non-null
1
'p' is non-null
1
'p' is non-null
 && p->type == SYMTAB_FUNCTION;
8
←
Assuming field 'type' is equal to SYMTAB_FUNCTION→
9
←
Returning without writing to 'p->next', which participates in a condition later→
2143}

2145/* Report whether or not THIS symtab node is a variable, aka varpool_node.  */

2147template <>
2148template <>
2149inline bool
2150is_a_helper <varpool_node *>::test (symtab_node *p)
2151{
return p && p->type == SYMTAB_VARIABLE;
2153}

2155typedef void (*cgraph_edge_hook)(cgraph_edge *, void *);
2156typedef void (*cgraph_node_hook)(cgraph_node *, void *);
2157typedef void (*varpool_node_hook)(varpool_node *, void *);
2158typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *);
2159typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *);

2161struct cgraph_edge_hook_list;
2162struct cgraph_node_hook_list;
2163struct varpool_node_hook_list;
2164struct cgraph_2edge_hook_list;
2165struct cgraph_2node_hook_list;

2167/* Map from a symbol to initialization/finalization priorities.  */
2168struct GTY(()) symbol_priority_map {
priority_type init;
priority_type fini;
2171};

2173enum symtab_state
2174{
/* Frontend is parsing and finalizing functions.  */
PARSING,
/* Callgraph is being constructed.  It is safe to add new functions.  */
CONSTRUCTION,
/* Callgraph is being streamed-in at LTO time.  */
LTO_STREAMING,
/* Callgraph is built and early IPA passes are being run.  */
IPA,
/* Callgraph is built and all functions are transformed to SSA form.  */
IPA_SSA,
/* All inline decisions are done; it is now possible to remove extern inline
   functions and virtual call targets.  */
IPA_SSA_AFTER_INLINING,
/* Functions are now ordered and being passed to RTL expanders.  */
EXPANSION,
/* All cgraph expansion is done.  */
FINISHED
2192};

2194struct asmname_hasher : ggc_ptr_hash <symtab_node>
2195{
typedef const_tree compare_type;

static hashval_t hash (symtab_node *n);
static bool equal (symtab_node *n, const_tree t);
2200};

2202/* Core summaries maintained about symbols.  */

2204struct thunk_info;
2205template <class T> class function_summary;
2206typedef function_summary <thunk_info *> thunk_summary;

2208struct clone_info;
2209template <class T> class function_summary;
2210typedef function_summary <clone_info *> clone_summary;

2212class GTY((tag ("SYMTAB"))) symbol_table
2213{
2214public:
friend struct symtab_node;
friend struct cgraph_node;
friend struct cgraph_edge;

symbol_table (): 
cgraph_count (0), cgraph_max_uid (1), cgraph_max_summary_id (0),
edges_count (0), edges_max_uid (1), edges_max_summary_id (0),
cgraph_released_summary_ids (), edge_released_summary_ids (),
nodes (NULLnullptr), asmnodes (NULLnullptr), asm_last_node (NULLnullptr),
order (0), max_unit (0), global_info_ready (false), state (PARSING),
function_flags_ready (false), cpp_implicit_aliases_done (false),
section_hash (NULLnullptr), assembler_name_hash (NULLnullptr), init_priority_hash (NULLnullptr),
dump_file (NULLnullptr), ipa_clones_dump_file (NULLnullptr), cloned_nodes (),
m_thunks (NULLnullptr), m_clones (NULLnullptr),
m_first_edge_removal_hook (NULLnullptr), m_first_cgraph_removal_hook (NULLnullptr),
m_first_edge_duplicated_hook (NULLnullptr), m_first_cgraph_duplicated_hook (NULLnullptr),
m_first_cgraph_insertion_hook (NULLnullptr), m_first_varpool_insertion_hook (NULLnullptr),
m_first_varpool_removal_hook (NULLnullptr)
{
}

/* Initialize callgraph dump file.  */
void initialize (void);

/* Register a top-level asm statement ASM_STR.  */
inline asm_node *finalize_toplevel_asm (tree asm_str);

/* Analyze the whole compilation unit once it is parsed completely.  */
void finalize_compilation_unit (void);

/* C++ frontend produce same body aliases all over the place, even before PCH
   gets streamed out. It relies on us linking the aliases with their function
   in order to do the fixups, but ipa-ref is not PCH safe.  Consequently we
   first produce aliases without links, but once C++ FE is sure it won't
   stream PCH we build the links via this function.  */
void process_same_body_aliases (void);

/* Perform simple optimizations based on callgraph.  */
void compile (void);

/* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
   functions into callgraph in a way so they look like ordinary reachable
   functions inserted into callgraph already at construction time.  */
void process_new_functions (void);

/* Register a symbol NODE.  */
inline void register_symbol (symtab_node *node);

inline void
clear_asm_symbols (void)
{
  asmnodes = NULLnullptr;
  asm_last_node = NULLnullptr;
}

/* Perform reachability analysis and reclaim all unreachable nodes.  */
bool remove_unreachable_nodes (FILE *file);

/* Optimization of function bodies might've rendered some variables as
   unnecessary so we want to avoid these from being compiled.  Re-do
   reachability starting from variables that are either externally visible
   or was referred from the asm output routines.  */
void remove_unreferenced_decls (void);

/* Unregister a symbol NODE.  */
inline void unregister (symtab_node *node);

/* Allocate new callgraph node and insert it into basic data structures.  */
cgraph_node *create_empty (void);

/* Release a callgraph NODE.  */
void release_symbol (cgraph_node *node);

/* Output all variables enqueued to be assembled.  */
bool output_variables (void);

/* Weakrefs may be associated to external decls and thus not output
   at expansion time.  Emit all necessary aliases.  */
void output_weakrefs (void);

/* Return first static symbol with definition.  */
inline symtab_node *first_symbol (void);

/* Return first assembler symbol.  */
inline asm_node *
first_asm_symbol (void)
{
  return asmnodes;
}

/* Return first static symbol with definition.  */
inline symtab_node *first_defined_symbol (void);

/* Return first variable.  */
inline varpool_node *first_variable (void);

/* Return next variable after NODE.  */
inline varpool_node *next_variable (varpool_node *node);

/* Return first static variable with initializer.  */
inline varpool_node *first_static_initializer (void);

/* Return next static variable with initializer after NODE.  */
inline varpool_node *next_static_initializer (varpool_node *node);

/* Return first static variable with definition.  */
inline varpool_node *first_defined_variable (void);

/* Return next static variable with definition after NODE.  */
inline varpool_node *next_defined_variable (varpool_node *node);

/* Return first function with body defined.  */
inline cgraph_node *first_defined_function (void);

/* Return next function with body defined after NODE.  */
inline cgraph_node *next_defined_function (cgraph_node *node);

/* Return first function.  */
inline cgraph_node *first_function (void);

/* Return next function.  */
inline cgraph_node *next_function (cgraph_node *node);

/* Return first function with body defined.  */
cgraph_node *first_function_with_gimple_body (void);

/* Return next reachable static variable with initializer after NODE.  */
inline cgraph_node *next_function_with_gimple_body (cgraph_node *node);

/* Register HOOK to be called with DATA on each removed edge.  */
cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook,
				void *data);

/* Remove ENTRY from the list of hooks called on removing edges.  */
void remove_edge_removal_hook (cgraph_edge_hook_list *entry);

/* Register HOOK to be called with DATA on each removed node.  */
cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook,
				  void *data);

/* Remove ENTRY from the list of hooks called on removing nodes.  */
void remove_cgraph_removal_hook (cgraph_node_hook_list *entry);

/* Register HOOK to be called with DATA on each removed node.  */
varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook,
				    void *data);

/* Remove ENTRY from the list of hooks called on removing nodes.  */
void remove_varpool_removal_hook (varpool_node_hook_list *entry);

/* Register HOOK to be called with DATA on each inserted node.  */
cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook,
				    void *data);

/* Remove ENTRY from the list of hooks called on inserted nodes.  */
void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry);

/* Register HOOK to be called with DATA on each inserted node.  */
varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook,
				      void *data);

/* Remove ENTRY from the list of hooks called on inserted nodes.  */
void remove_varpool_insertion_hook (varpool_node_hook_list *entry);

/* Register HOOK to be called with DATA on each duplicated edge.  */
cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook,
				     void *data);
/* Remove ENTRY from the list of hooks called on duplicating edges.  */
void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry);

/* Register HOOK to be called with DATA on each duplicated node.  */
cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook,
				       void *data);

/* Remove ENTRY from the list of hooks called on duplicating nodes.  */
void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry);

/* Call all edge removal hooks.  */
void call_edge_removal_hooks (cgraph_edge *e);

/* Call all node insertion hooks.  */
void call_cgraph_insertion_hooks (cgraph_node *node);

/* Call all node removal hooks.  */
void call_cgraph_removal_hooks (cgraph_node *node);

/* Call all node duplication hooks.  */
void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2);

/* Call all edge duplication hooks.  */
void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2);

/* Call all node removal hooks.  */
void call_varpool_removal_hooks (varpool_node *node);

/* Call all node insertion hooks.  */
void call_varpool_insertion_hooks (varpool_node *node);

/* Arrange node to be first in its entry of assembler_name_hash.  */
void symtab_prevail_in_asm_name_hash (symtab_node *node);

/* Initialize asm name hash unless.  */
void symtab_initialize_asm_name_hash (void);

/* Set the DECL_ASSEMBLER_NAME and update symtab hashtables.  */
void change_decl_assembler_name (tree decl, tree name);

/* Dump symbol table to F.  */
void dump (FILE *f);

/* Dump symbol table to F in graphviz format.  */
void dump_graphviz (FILE *f);

/* Dump symbol table to stderr.  */
void DEBUG_FUNCTION__attribute__ ((__used__)) debug (void);

/* Assign a new summary ID for the callgraph NODE.  */
inline int assign_summary_id (cgraph_node *node)
{
  if (!cgraph_released_summary_ids.is_empty ())
    node->m_summary_id = cgraph_released_summary_ids.pop ();
  else
    node->m_summary_id = cgraph_max_summary_id++;

  return node->m_summary_id;
}

/* Assign a new summary ID for the callgraph EDGE.  */
inline int assign_summary_id (cgraph_edge *edge)
{
  if (!edge_released_summary_ids.is_empty ())
    edge->m_summary_id = edge_released_summary_ids.pop ();
  else
    edge->m_summary_id = edges_max_summary_id++;

  return edge->m_summary_id;
}

/* Return true if assembler names NAME1 and NAME2 leads to the same symbol
   name.  */
static bool assembler_names_equal_p (const char *name1, const char *name2);

int cgraph_count;
int cgraph_max_uid;
int cgraph_max_summary_id;

int edges_count;
int edges_max_uid;
int edges_max_summary_id;

/* Vector of released summary IDS for cgraph nodes.  */
vec<int> GTY ((skip)) cgraph_released_summary_ids;

/* Vector of released summary IDS for cgraph nodes.  */
vec<int> GTY ((skip)) edge_released_summary_ids;

/* Return symbol used to separate symbol name from suffix.  */
static char symbol_suffix_separator ();

symtab_node* GTY(()) nodes;
asm_node* GTY(()) asmnodes;
asm_node* GTY(()) asm_last_node;

/* The order index of the next symtab node to be created.  This is
   used so that we can sort the cgraph nodes in order by when we saw
   them, to support -fno-toplevel-reorder.  */
int order;

/* Maximal unit ID used.  */
int max_unit;

/* Set when whole unit has been analyzed so we can access global info.  */
bool global_info_ready;
/* What state callgraph is in right now.  */
enum symtab_state state;
/* Set when the cgraph is fully build and the basic flags are computed.  */
bool function_flags_ready;

bool cpp_implicit_aliases_done;

/* Hash table used to hold sections.  */
hash_table<section_name_hasher> *GTY(()) section_hash;

/* Hash table used to convert assembler names into nodes.  */
hash_table<asmname_hasher> *assembler_name_hash;

/* Hash table used to hold init priorities.  */
hash_map<symtab_node *, symbol_priority_map> *init_priority_hash;

FILE* GTY ((skip)) dump_file;

FILE* GTY ((skip)) ipa_clones_dump_file;

hash_set <const cgraph_node *> GTY ((skip)) cloned_nodes;

/* Thunk annotations.  */
thunk_summary *m_thunks;

/* Virtual clone annotations.  */
clone_summary *m_clones;

2516private:
/* 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.  */
cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee,
	    gcall *call_stmt, profile_count count,
	    bool indir_unknown_callee, bool cloning_p);

/* Put the edge onto the free list.  */
void free_edge (cgraph_edge *e);

/* Insert NODE to assembler name hash.  */
void insert_to_assembler_name_hash (symtab_node *node, bool with_clones);

/* Remove NODE from assembler name hash.  */
void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones);

/* Hash asmnames ignoring the user specified marks.  */
static hashval_t decl_assembler_name_hash (const_tree asmname);

/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
static bool decl_assembler_name_equal (tree decl, const_tree asmname);

friend struct asmname_hasher;

/* List of hooks triggered when an edge is removed.  */
cgraph_edge_hook_list * GTY((skip)) m_first_edge_removal_hook;
/* List of hooks trigger_red when a cgraph node is removed.  */
cgraph_node_hook_list * GTY((skip)) m_first_cgraph_removal_hook;
/* List of hooks triggered when an edge is duplicated.  */
cgraph_2edge_hook_list * GTY((skip)) m_first_edge_duplicated_hook;
/* List of hooks triggered when a node is duplicated.  */
cgraph_2node_hook_list * GTY((skip)) m_first_cgraph_duplicated_hook;
/* List of hooks triggered when an function is inserted.  */
cgraph_node_hook_list * GTY((skip)) m_first_cgraph_insertion_hook;
/* List of hooks triggered when an variable is inserted.  */
varpool_node_hook_list * GTY((skip)) m_first_varpool_insertion_hook;
/* List of hooks triggered when a node is removed.  */
varpool_node_hook_list * GTY((skip)) m_first_varpool_removal_hook;
2556};

2558extern GTY(()) symbol_table *symtab;

2560extern vec<cgraph_node *> cgraph_new_nodes;

2562inline hashval_t
2563asmname_hasher::hash (symtab_node *n)
2564{
return symbol_table::decl_assembler_name_hash
  (DECL_ASSEMBLER_NAME (n->decl)decl_assembler_name (n->decl));
2567}

2569inline bool
2570asmname_hasher::equal (symtab_node *n, const_tree t)
2571{
return symbol_table::decl_assembler_name_equal (n->decl, t);
2573}

2575/* In cgraph.cc  */
2576void cgraph_cc_finalize (void);
2577void release_function_body (tree);
2578cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void);

2580void cgraph_update_edges_for_call_stmt (gimple *, tree, gimple *);
2581bool cgraph_function_possibly_inlined_p (tree);

2583const char* cgraph_inline_failed_string (cgraph_inline_failed_t);
2584cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t);

2586/* In cgraphunit.cc  */
2587void cgraphunit_cc_finalize (void);
2588int tp_first_run_node_cmp (const void *pa, const void *pb);

2590/* In symtab-thunks.cc  */
2591void symtab_thunks_cc_finalize (void);

2593/*  Initialize datastructures so DECL is a function in lowered gimple form.
  IN_SSA is true if the gimple is in SSA.  */
2595basic_block init_lowered_empty_function (tree, bool, profile_count);

2597tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INTlong, tree,
   HOST_WIDE_INTlong);
2599/* In cgraphclones.cc  */

2601tree clone_function_name_numbered (const char *name, const char *suffix);
2602tree clone_function_name_numbered (tree decl, const char *suffix);
2603tree clone_function_name (const char *name, const char *suffix,
	  unsigned long number);
2605tree clone_function_name (tree decl, const char *suffix,
	  unsigned long number);
2607tree clone_function_name (tree decl, const char *suffix);

2609void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *,
	       ipa_param_adjustments *,
	       bool, bitmap, basic_block);

2613void dump_callgraph_transformation (const cgraph_node *original,
		    const cgraph_node *clone,
		    const char *suffix);
2616/* In cgraphbuild.cc  */
2617int compute_call_stmt_bb_frequency (tree, basic_block bb);
2618void record_references_in_initializer (tree, bool);

2620/* In ipa.cc  */
2621void cgraph_build_static_cdtor (char which, tree body, int priority);
2622bool ipa_discover_variable_flags (void);

2624/* In varpool.cc  */
2625tree ctor_for_folding (tree);

2627/* In ipa-inline-analysis.cc  */
2628void initialize_inline_failed (struct cgraph_edge *);
2629bool speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining);

2631/* Return true when the symbol is real symbol, i.e. it is not inline clone
 or abstract function kept for debug info purposes only.  */
2633inline bool
2634symtab_node::real_symbol_p (void)
2635{
cgraph_node *cnode;

if (DECL_ABSTRACT_P (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 2638, __FUNCTION__))->decl_common.abstract_flag))
  return false;
if (transparent_alias && definition)
  return false;
if (!is_a <cgraph_node *> (this))
  return true;
cnode = dyn_cast <cgraph_node *> (this);
if (cnode->inlined_to)
  return false;
return true;
2648}

2650/* Return true if DECL should have entry in symbol table if used.
 Those are functions and static & external variables.  */

2653inline bool
2654decl_in_symtab_p (const_tree decl)
2655{
return (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == FUNCTION_DECL
        || (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == VAR_DECL
     && (TREE_STATIC (decl)((decl)->base.static_flag) || DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 2658, __FUNCTION__))->decl_common.decl_flag_1))));
2659}

2661inline bool
2662symtab_node::in_same_comdat_group_p (symtab_node *target)
2663{
symtab_node *source = this;

if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
  {
    if (cn->inlined_to)
source = cn->inlined_to;
  }
if (cgraph_node *cn = dyn_cast <cgraph_node *> (target))
  {
    if (cn->inlined_to)
target = cn->inlined_to;
  }

return source->get_comdat_group () == target->get_comdat_group ();
2678}

2680/* Return node that alias is aliasing.  */

2682inline symtab_node *
2683symtab_node::get_alias_target (void)
2684{
ipa_ref *ref = NULLnullptr;
iterate_reference (0, ref);
gcc_checking_assert (ref->use == IPA_REF_ALIAS)((void)(!(ref->use == IPA_REF_ALIAS) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 2687, __FUNCTION__), 0 : 0));
return ref->referred;
2689}

2691/* Return the DECL (or identifier) that alias is aliasing.  Unlike the above,
 this works whether or not the alias has been analyzed already.  */

2694inline tree
2695symtab_node::get_alias_target_tree ()
2696{
if (alias_target)
  return alias_target;
return get_alias_target ()->decl;
2700}

2702/* Return next reachable static symbol with initializer after the node.  */

2704inline symtab_node *
2705symtab_node::next_defined_symbol (void)
2706{
symtab_node *node1 = next;

for (; node1; node1 = node1->next)
  if (node1->definition)
    return node1;

return NULLnullptr;
2714}

2716/* Iterates I-th reference in the list, REF is also set.  */

2718inline ipa_ref *
2719symtab_node::iterate_reference (unsigned i, ipa_ref *&ref)
2720{
ref_list.references.iterate (i, &ref);

return ref;
2724}

2726/* Iterates I-th referring item in the list, REF is also set.  */

2728inline ipa_ref *
2729symtab_node::iterate_referring (unsigned i, ipa_ref *&ref)
2730{
ref_list.referring.iterate (i, &ref);

return ref;
2734}

2736/* Iterates I-th referring alias item in the list, REF is also set.  */

2738inline ipa_ref *
2739symtab_node::iterate_direct_aliases (unsigned i, ipa_ref *&ref)
2740{
ref_list.referring.iterate (i, &ref);

if (ref && ref->use != IPA_REF_ALIAS)
  return NULLnullptr;

return ref;
2747}

2749/* Return true if list contains an alias.  */

2751inline bool
2752symtab_node::has_aliases_p (void)
2753{
ipa_ref *ref = NULLnullptr;

return (iterate_direct_aliases (0, ref) != NULLnullptr);
2757}

2759/* Return true when RESOLUTION indicate that linker will use
 the symbol from non-LTO object files.  */

2762inline bool
2763resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution)
2764{
return (resolution == LDPR_PREVAILING_DEF
 || resolution == LDPR_PREEMPTED_REG
 || resolution == LDPR_RESOLVED_EXEC
 || resolution == LDPR_RESOLVED_DYN);
2769}

2771/* Return true when symtab_node is known to be used from other (non-LTO)
 object file. Known only when doing LTO via linker plugin.  */

2774inline bool
2775symtab_node::used_from_object_file_p (void)
2776{
if (!TREE_PUBLIC (decl)((decl)->base.public_flag) || DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 2777, __FUNCTION__))->decl_common.decl_flag_1))
  return false;
if (resolution_used_from_other_file_p (resolution))
  return true;
return false;
2782}

2784/* Return varpool node for given symbol and check it is a function. */

2786inline varpool_node *
2787varpool_node::get (const_tree decl)
2788{
gcc_checking_assert (TREE_CODE (decl) == VAR_DECL)((void)(!(((enum tree_code) (decl)->base.code) == VAR_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 2789, __FUNCTION__), 0 : 0));
return dyn_cast<varpool_node *> (symtab_node::get (decl));
2791}

2793/* Register a symbol NODE.  */

2795inline void
2796symbol_table::register_symbol (symtab_node *node)
2797{
node->next = nodes;
node->previous = NULLnullptr;

if (nodes)
  nodes->previous = node;
nodes = node;

node->order = order++;
2806}

2808/* Register a top-level asm statement ASM_STR.  */

2810asm_node *
2811symbol_table::finalize_toplevel_asm (tree asm_str)
2812{
asm_node *node;

node = ggc_cleared_alloc<asm_node> ();
node->asm_str = asm_str;
node->order = order++;
node->next = NULLnullptr;

if (asmnodes == NULLnullptr)
  asmnodes = node;
else
  asm_last_node->next = node;

asm_last_node = node;
return node;
2827}

2829/* Unregister a symbol NODE.  */
2830inline void
2831symbol_table::unregister (symtab_node *node)
2832{
if (node->previous)
  node->previous->next = node->next;
else
  nodes = node->next;

if (node->next)
  node->next->previous = node->previous;

node->next = NULLnullptr;
node->previous = NULLnullptr;
2843}

2845/* Release a callgraph NODE with UID and put in to the list of free nodes.  */

2847inline void
2848symbol_table::release_symbol (cgraph_node *node)
2849{
cgraph_count--;
if (node->m_summary_id != -1)
  cgraph_released_summary_ids.safe_push (node->m_summary_id);
ggc_free (node);
2854}

2856/* Return first static symbol with definition.  */
2857inline symtab_node *
2858symbol_table::first_symbol (void)
2859{
return nodes;
2861}

2863/* Walk all symbols.  */
2864#define FOR_EACH_SYMBOL(node)for ((node) = symtab->first_symbol (); (node); (node) = (node
)->next) \
 for ((node) = symtab->first_symbol (); (node); (node) = (node)->next)

2867/* Return first static symbol with definition.  */
2868inline symtab_node *
2869symbol_table::first_defined_symbol (void)
2870{
symtab_node *node;

for (node = nodes; node; node = node->next)
  if (node->definition)
    return node;

return NULLnullptr;
2878}

2880/* Walk all symbols with definitions in current unit.  */
2881#define FOR_EACH_DEFINED_SYMBOL(node)for ((node) = symtab->first_defined_symbol (); (node); (node
) = node->next_defined_symbol ()) \
 for ((node) = symtab->first_defined_symbol (); (node); \
(node) = node->next_defined_symbol ())

2885/* Return first variable.  */
2886inline varpool_node *
2887symbol_table::first_variable (void)
2888{
symtab_node *node;
for (node = nodes; node; node = node->next)
  if (varpool_node *vnode = dyn_cast <varpool_node *> (node))
    return vnode;
return NULLnullptr;
2894}

2896/* Return next variable after NODE.  */
2897inline varpool_node *
2898symbol_table::next_variable (varpool_node *node)
2899{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
  if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1))
    return vnode1;
return NULLnullptr;
2905}
2906/* Walk all variables.  */
2907#define FOR_EACH_VARIABLE(node)for ((node) = symtab->first_variable (); (node); (node) = symtab
->next_variable ((node))) \
 for ((node) = symtab->first_variable (); \
      (node); \
(node) = symtab->next_variable ((node)))

2912/* Return first static variable with initializer.  */
2913inline varpool_node *
2914symbol_table::first_static_initializer (void)
2915{
symtab_node *node;
for (node = nodes; node; node = node->next)
  {
    varpool_node *vnode = dyn_cast <varpool_node *> (node);
    if (vnode && DECL_INITIAL (node->decl)((contains_struct_check ((node->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 2920, __FUNCTION__))->decl_common.initial))
return vnode;
  }
return NULLnullptr;
2924}

2926/* Return next static variable with initializer after NODE.  */
2927inline varpool_node *
2928symbol_table::next_static_initializer (varpool_node *node)
2929{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
  {
    varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
    if (vnode1 && DECL_INITIAL (node1->decl)((contains_struct_check ((node1->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 2934, __FUNCTION__))->decl_common.initial))
return vnode1;
  }
return NULLnullptr;
2938}

2940/* Walk all static variables with initializer set.  */
2941#define FOR_EACH_STATIC_INITIALIZER(node)for ((node) = symtab->first_static_initializer (); (node);
 (node) = symtab->next_static_initializer (node)) \
 for ((node) = symtab->first_static_initializer (); (node); \
(node) = symtab->next_static_initializer (node))

2945/* Return first static variable with definition.  */
2946inline varpool_node *
2947symbol_table::first_defined_variable (void)
2948{
symtab_node *node;
for (node = nodes; node; node = node->next)
  {
    varpool_node *vnode = dyn_cast <varpool_node *> (node);
    if (vnode && vnode->definition)
return vnode;
  }
return NULLnullptr;
2957}

2959/* Return next static variable with definition after NODE.  */
2960inline varpool_node *
2961symbol_table::next_defined_variable (varpool_node *node)
2962{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
  {
    varpool_node *vnode1 = dyn_cast <varpool_node *> (node1);
    if (vnode1 && vnode1->definition)
return vnode1;
  }
return NULLnullptr;
2971}
2972/* Walk all variables with definitions in current unit.  */
2973#define FOR_EACH_DEFINED_VARIABLE(node)for ((node) = symtab->first_defined_variable (); (node); (
node) = symtab->next_defined_variable (node)) \
 for ((node) = symtab->first_defined_variable (); (node); \
(node) = symtab->next_defined_variable (node))

2977/* Return first function with body defined.  */
2978inline cgraph_node *
2979symbol_table::first_defined_function (void)
2980{
symtab_node *node;
for (node = nodes; node; node = node->next)
  {
    cgraph_node *cn = dyn_cast <cgraph_node *> (node);
    if (cn && cn->definition)
return cn;
  }
return NULLnullptr;
2989}

2991/* Return next function with body defined after NODE.  */
2992inline cgraph_node *
2993symbol_table::next_defined_function (cgraph_node *node)
2994{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
  {
    cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
    if (cn1 && cn1->definition)
return cn1;
  }
return NULLnullptr;
3003}

3005/* Walk all functions with body defined.  */
3006#define FOR_EACH_DEFINED_FUNCTION(node)for ((node) = symtab->first_defined_function (); (node); (
node) = symtab->next_defined_function ((node))) \
 for ((node) = symtab->first_defined_function (); (node); \
(node) = symtab->next_defined_function ((node)))

3010/* Return first function.  */
3011inline cgraph_node *
3012symbol_table::first_function (void)
3013{
symtab_node *node;
for (node = nodes; node; node = node->next)
  if (cgraph_node *cn = dyn_cast <cgraph_node *> (node))
    return cn;
return NULLnullptr;
3019}

3021/* Return next function.  */
3022inline cgraph_node *
3023symbol_table::next_function (cgraph_node *node)
3024{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
  if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1))
    return cn1;
return NULLnullptr;
3030}

3032/* Return first function with body defined.  */
3033inline cgraph_node *
3034symbol_table::first_function_with_gimple_body (void)
3035{
symtab_node *node;
for (node = nodes; node; node = node->next)
4
←
Loop condition is true.  Entering loop body→
22
←
Loop condition is true.  Entering loop body→
  {
    cgraph_node *cn = dyn_cast <cgraph_node *> (node);
5
←
Calling 'dyn_cast<cgraph_node *, symtab_node>'→
20
←
Returning from 'dyn_cast<cgraph_node *, symtab_node>'→
23
←
Calling 'dyn_cast<cgraph_node *, symtab_node>'→
26
←
Returning from 'dyn_cast<cgraph_node *, symtab_node>'→
    if (cn20.1
'cn' is non-null
1
'cn' is non-null
1
'cn' is non-null
1
'cn' is non-null
1
'cn' is non-null
1
'cn' is non-null
1
'cn' is non-null
1
'cn' is non-null
 && cn->has_gimple_body_p ())
21
←
Taking false branch→
27
←
Taking true branch→
return cn;
28
←
Returning pointer (loaded from 'cn'), which participates in a condition later→
  }
return NULLnullptr;
3044}

3046/* Return next reachable static variable with initializer after NODE.  */
3047inline cgraph_node *
3048symbol_table::next_function_with_gimple_body (cgraph_node *node)
3049{
symtab_node *node1 = node->next;
for (; node1; node1 = node1->next)
  {
    cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1);
    if (cn1 && cn1->has_gimple_body_p ())
return cn1;
  }
return NULLnullptr;
3058}

3060/* Walk all functions.  */
3061#define FOR_EACH_FUNCTION(node)for ((node) = symtab->first_function (); (node); (node) = symtab
->next_function ((node))) \
 for ((node) = symtab->first_function (); (node); \
(node) = symtab->next_function ((node)))

3065/* Return true when callgraph node is a function with Gimple body defined
 in current unit.  Functions can also be define externally or they
 can be thunks with no Gimple representation.

 Note that at WPA stage, the function body may not be present in memory.  */

3071inline bool
3072cgraph_node::has_gimple_body_p (void)
3073{
return definition && !thunk && !alias;
3075}

3077/* Walk all functions with body defined.  */
3078#define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node)for ((node) = symtab->first_function_with_gimple_body (); (
node); (node) = symtab->next_function_with_gimple_body (node
)) \
 for ((node) = symtab->first_function_with_gimple_body (); (node); \
(node) = symtab->next_function_with_gimple_body (node))

3082/* Uniquize all constants that appear in memory.
 Each constant in memory thus far output is recorded
 in `const_desc_table'.  */

3086struct GTY((for_user)) constant_descriptor_tree {
/* A MEM for the constant.  */
rtx rtl;

/* The value of the constant.  */
tree value;

/* Hash of value.  Computing the hash from value each time
   hashfn is called can't work properly, as that means recursive
   use of the hash table during hash table expansion.  */
hashval_t hash;
3097};

3099/* Return true when function is only called directly or it has alias.
 i.e. it is not externally visible, address was not taken and
 it is not used in any other non-standard way.  */

3103inline bool
3104cgraph_node::only_called_directly_or_aliased_p (void)
3105{
gcc_assert (!inlined_to)((void)(!(!inlined_to) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3106, __FUNCTION__), 0 : 0));
return (!force_output && !address_taken
 && !ifunc_resolver
 && !used_from_other_partition
 && !DECL_VIRTUAL_P (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3110, __FUNCTION__))->decl_common.virtual_flag)
 && !DECL_STATIC_CONSTRUCTOR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3111, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_ctor_flag
)
 && !DECL_STATIC_DESTRUCTOR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3112, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_dtor_flag
)
 && !used_from_object_file_p ()
 && !externally_visible);
3115}

3117/* Return true when function can be removed from callgraph
 if all direct calls are eliminated.  */

3120inline bool
3121cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void)
3122{
gcc_checking_assert (!inlined_to)((void)(!(!inlined_to) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3123, __FUNCTION__), 0 : 0));
/* Extern inlines can always go, we will use the external definition.  */
if (DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3125, __FUNCTION__))->decl_common.decl_flag_1))
  return true;
/* When function is needed, we cannot remove it.  */
if (force_output || used_from_other_partition)
  return false;
if (DECL_STATIC_CONSTRUCTOR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3130, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_ctor_flag
)
    || DECL_STATIC_DESTRUCTOR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3131, __FUNCTION__, (FUNCTION_DECL)))->function_decl.static_dtor_flag
))
  return false;
/* Only COMDAT functions can be removed if externally visible.  */
if (externally_visible
    && ((!DECL_COMDAT (decl)((contains_struct_check ((decl), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3135, __FUNCTION__))->decl_with_vis.comdat_flag) || ifunc_resolver)
 || forced_by_abi
 || used_from_object_file_p ()))
  return false;
return true;
3140}

3142/* Verify cgraph, if consistency checking is enabled.  */

3144inline void
3145cgraph_node::checking_verify_cgraph_nodes (void)
3146{
if (flag_checkingglobal_options.x_flag_checking)
  cgraph_node::verify_cgraph_nodes ();
3149}

3151/* Return true when variable can be removed from variable pool
 if all direct calls are eliminated.  */

3154inline bool
3155varpool_node::can_remove_if_no_refs_p (void)
3156{
if (DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3157, __FUNCTION__))->decl_common.decl_flag_1))
  return true;
return (!force_output && !used_from_other_partition
 && ((DECL_COMDAT (decl)((contains_struct_check ((decl), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3160, __FUNCTION__))->decl_with_vis.comdat_flag)
      && !forced_by_abi
      && !used_from_object_file_p ())
     || !externally_visible
     || DECL_HAS_VALUE_EXPR_P (decl)((tree_check3 ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3164, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2)));
3165}

3167/* Return true when all references to variable must be visible in ipa_ref_list.
 i.e. if the variable is not externally visible or not used in some magic
 way (asm statement or such).
 The magic uses are all summarized in force_output flag.  */

3172inline bool
3173varpool_node::all_refs_explicit_p ()
3174{
return (definition
 && !externally_visible
 && !used_from_other_partition
 && !force_output);
3179}

3181struct tree_descriptor_hasher : ggc_ptr_hash<constant_descriptor_tree>
3182{
static hashval_t hash (constant_descriptor_tree *);
static bool equal (constant_descriptor_tree *, constant_descriptor_tree *);
3185};

3187/* Constant pool accessor function.  */
3188hash_table<tree_descriptor_hasher> *constant_pool_htab (void);

3190/* Return node that alias is aliasing.  */

3192inline cgraph_node *
3193cgraph_node::get_alias_target (void)
3194{
return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ());
3196}

3198/* Return node that alias is aliasing.  */

3200inline varpool_node *
3201varpool_node::get_alias_target (void)
3202{
return dyn_cast <varpool_node *> (symtab_node::get_alias_target ());
3204}

3206/* Walk the alias chain to return the symbol NODE is alias of.
 If NODE is not an alias, return 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.  */

3212inline symtab_node *
3213symtab_node::ultimate_alias_target (enum availability *availability,
		    symtab_node *ref)
3215{
if (!alias)
  {
    if (availability)
*availability = get_availability (ref);
    return this;
  }

return ultimate_alias_target_1 (availability, ref);
3224}

3226/* Given function symbol, walk the alias chain to return the function node
 is alias of. Do not walk through thunks.
 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.  */

3232inline cgraph_node *
3233cgraph_node::ultimate_alias_target (enum availability *availability,
		    symtab_node *ref)
3235{
cgraph_node *n = dyn_cast <cgraph_node *>
  (symtab_node::ultimate_alias_target (availability, ref));
if (!n && availability)
  *availability = AVAIL_NOT_AVAILABLE;
return n;
3241}

3243/* For given variable pool node, walk the alias chain to return the function
 the variable is alias of. Do not walk through thunks.
 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.  */

3249inline varpool_node *
3250varpool_node::ultimate_alias_target (availability *availability,
		     symtab_node *ref)
3252{
varpool_node *n = dyn_cast <varpool_node *>
  (symtab_node::ultimate_alias_target (availability, ref));

if (!n && availability)
  *availability = AVAIL_NOT_AVAILABLE;
return n;
3259}

3261/* Set callee N of call graph edge and add it to the corresponding set of
 callers. */

3264inline void
3265cgraph_edge::set_callee (cgraph_node *n)
3266{
prev_caller = NULLnullptr;
if (n->callers)
  n->callers->prev_caller = this;
next_caller = n->callers;
n->callers = this;
callee = n;
3273}

3275/* Return true when the edge represents a direct recursion.  */

3277inline bool
3278cgraph_edge::recursive_p (void)
3279{
cgraph_node *c = callee->ultimate_alias_target ();
if (caller->inlined_to)
  return caller->inlined_to->decl == c->decl;
else
  return caller->decl == c->decl;
3285}

3287/* Remove the edge from the list of the callers of the callee.  */

3289inline void
3290cgraph_edge::remove_callee (void)
3291{
gcc_assert (!indirect_unknown_callee)((void)(!(!indirect_unknown_callee) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3292, __FUNCTION__), 0 : 0));
if (prev_caller)
  prev_caller->next_caller = next_caller;
if (next_caller)
  next_caller->prev_caller = prev_caller;
if (!prev_caller)
  callee->callers = next_caller;
3299}

3301/* Return true if call must bind to current definition.  */

3303inline bool
3304cgraph_edge::binds_to_current_def_p ()
3305{
if (callee)
  return callee->binds_to_current_def_p (caller);
else
  return false;
3310}

3312/* Expected frequency of executions within the function.
 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once
 per function call.  The range is 0 to CGRAPH_FREQ_MAX.  */

3316inline int
3317cgraph_edge::frequency ()
3318{
return count.to_cgraph_frequency (caller->inlined_to
		    ? caller->inlined_to->count
		    : caller->count);
3322}


3325/* Return true if the TM_CLONE bit is set for a given FNDECL.  */
3326inline bool
3327decl_is_tm_clone (const_tree fndecl)
3328{
cgraph_node *n = cgraph_node::get (fndecl);
if (n)
  return n->tm_clone;
return false;
3333}

3335/* Likewise indicate that a node is needed, i.e. reachable via some
 external means.  */

3338inline void
3339cgraph_node::mark_force_output (void)
3340{
force_output = 1;
gcc_checking_assert (!inlined_to)((void)(!(!inlined_to) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3342, __FUNCTION__), 0 : 0));
3343}

3345/* Return true if function should be optimized for size.  */

3347inline enum optimize_size_level
3348cgraph_node::optimize_for_size_p (void)
3349{
if (opt_for_fn (decl, optimize_size)(opts_for_fn (decl)->x_optimize_size))
  return OPTIMIZE_SIZE_MAX;
if (count == profile_count::zero ())
  return OPTIMIZE_SIZE_MAX;
if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED)
  return OPTIMIZE_SIZE_BALANCED;
else
  return OPTIMIZE_SIZE_NO;
3358}

3360/* Return symtab_node for NODE or create one if it is not present
 in symtab.  */

3363inline symtab_node *
3364symtab_node::get_create (tree node)
3365{
if (TREE_CODE (node)((enum tree_code) (node)->base.code) == VAR_DECL)
  return varpool_node::get_create (node);
else
  return cgraph_node::get_create (node);
3370}

3372/* Return availability of NODE when referenced from REF.  */

3374inline enum availability
3375symtab_node::get_availability (symtab_node *ref)
3376{
if (is_a <cgraph_node *> (this))
  return dyn_cast <cgraph_node *> (this)->get_availability (ref);
else
  return dyn_cast <varpool_node *> (this)->get_availability (ref);
3381}

3383/* Call callback on symtab node and aliases associated to this node.
 When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */

3386inline bool
3387symtab_node::call_for_symbol_and_aliases (bool (*callback) (symtab_node *,
					    void *),
			  void *data,
			  bool include_overwritable)
3391{
if (include_overwritable
    || get_availability () > AVAIL_INTERPOSABLE)
  {
    if (callback (this, data))
      return true;
  }
if (has_aliases_p ())
  return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
return false;
3401}

3403/* Call callback on function and aliases associated to the function.
 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
 skipped.  */

3407inline bool
3408cgraph_node::call_for_symbol_and_aliases (bool (*callback) (cgraph_node *,
					    void *),
			  void *data,
			  bool include_overwritable)
3412{
if (include_overwritable
    || get_availability () > AVAIL_INTERPOSABLE)
  {
    if (callback (this, data))
      return true;
  }
if (has_aliases_p ())
  return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
return false;
3422}

3424/* Call callback on varpool symbol and aliases associated to varpool symbol.
 When INCLUDE_OVERWRITABLE is false, overwritable symbols are
 skipped. */

3428inline bool
3429varpool_node::call_for_symbol_and_aliases (bool (*callback) (varpool_node *,
					     void *),
			   void *data,
			   bool include_overwritable)
3433{
if (include_overwritable
    || get_availability () > AVAIL_INTERPOSABLE)
  {
    if (callback (this, data))
      return true;
  }
if (has_aliases_p ())
  return call_for_symbol_and_aliases_1 (callback, data, include_overwritable);
return false;
3443}

3445/* Return true if reference may be used in address compare.  */

3447inline bool
3448ipa_ref::address_matters_p ()
3449{
if (use != IPA_REF_ADDR)
  return false;
/* Addresses taken from virtual tables are never compared.  */
if (is_a <varpool_node *> (referring)
    && DECL_VIRTUAL_P (referring->decl)((contains_struct_check ((referring->decl), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3454, __FUNCTION__))->decl_common.virtual_flag))
  return false;
return referred->address_can_be_compared_p ();
3457}

3459/* Build polymorphic call context for indirect call E.  */

3461inline
3462ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge *e)
3463{
gcc_checking_assert (e->indirect_info->polymorphic)((void)(!(e->indirect_info->polymorphic) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3464, __FUNCTION__), 0 : 0));
*this = e->indirect_info->context;
3466}

3468/* Build empty "I know nothing" context.  */

3470inline
3471ipa_polymorphic_call_context::ipa_polymorphic_call_context ()
3472{
clear_speculation ();
clear_outer_type ();
invalid = false;
3476}

3478/* Make context non-speculative.  */

3480inline void
3481ipa_polymorphic_call_context::clear_speculation ()
3482{
speculative_outer_type = NULLnullptr;
speculative_offset = 0;
speculative_maybe_derived_type = false;
3486}

3488/* Produce context specifying all derived types of OTR_TYPE.  If OTR_TYPE is
 NULL, the context is set to dummy "I know nothing" setting.  */

3491inline void
3492ipa_polymorphic_call_context::clear_outer_type (tree otr_type)
3493{
outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type)((tree_class_check ((otr_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3494, __FUNCTION__))->type_common.main_variant) : NULLnullptr;
offset = 0;
maybe_derived_type = true;
maybe_in_construction = true;
dynamic = true;
3499}

3501/* Adjust all offsets in contexts by OFF bits.  */

3503inline void
3504ipa_polymorphic_call_context::offset_by (HOST_WIDE_INTlong off)
3505{
if (outer_type)
  offset += off;
if (speculative_outer_type)
  speculative_offset += off;
3510}

3512/* Return TRUE if context is fully useless.  */

3514inline bool
3515ipa_polymorphic_call_context::useless_p () const
3516{
return (!outer_type && !speculative_outer_type);
3518}

3520/* When using fprintf (or similar), problems can arise with
 transient generated strings.  Many string-generation APIs
 only support one result being alive at once (e.g. by
 returning a pointer to a statically-allocated buffer).

 If there is more than one generated string within one
 fprintf call: the first string gets evicted or overwritten
 by the second, before fprintf is fully evaluated.
 See e.g. PR/53136.

 This function provides a workaround for this, by providing
 a simple way to create copies of these transient strings,
 without the need to have explicit cleanup:

     fprintf (dumpfile, "string 1: %s string 2:%s\n",
              xstrdup_for_dump (EXPR_1),
              xstrdup_for_dump (EXPR_2));

 This is actually a simple wrapper around ggc_strdup, but
 the name documents the intent.  We require that no GC can occur
 within the fprintf call.  */

3542inline const char *
3543xstrdup_for_dump (const char *transient_str)
3544{
return ggc_strdup (transient_str)ggc_alloc_string ((transient_str), -1 );
3546}

3548/* During LTO stream-in this predicate can be used to check whether node
 in question prevails in the linking to save some memory usage.  */
3550inline bool
3551symtab_node::prevailing_p (void)
3552{
return definition && ((!TREE_PUBLIC (decl)((decl)->base.public_flag) && !DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cgraph.h"
, 3553, __FUNCTION__))->decl_common.decl_flag_1))
	 || previous_sharing_asm_name == NULLnullptr);
3555}

3557extern GTY(()) symbol_table *saved_symtab;

3559#if CHECKING_P1

3561namespace selftest {

3563/* An RAII-style class for use in selftests for temporarily using a different
 symbol_table, so that such tests can be isolated from each other.  */

3566class symbol_table_test
3567{
public:
/* Constructor.  Override "symtab".  */
symbol_table_test ();

/* Destructor.  Restore the saved_symtab.  */
~symbol_table_test ();
3574};

3576} // namespace selftest

3578#endif /* CHECKING_P */

3580#endif  /* GCC_CGRAPH_H  */

←

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/is-a.h

→

1/* Dynamic testing for abstract is-a relationships.
2   Copyright (C) 2012-2023 Free Software Foundation, Inc.
3   Contributed by Lawrence Crowl.
4 
5This file is part of GCC.
6 
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11 
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15for more details.
16 
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3.  If not see
19<http://www.gnu.org/licenses/>.  */
20 
21 
22/* This header generic type query and conversion functions.
23 
24 
25USING THE GENERIC TYPE FACILITY
26 
27 
28The user functions are:
29 
30bool is_a <TYPE> (pointer)
31 
32    Tests whether the pointer actually points to a more derived TYPE.
33 
34    Suppose you have a symtab_node *ptr, AKA symtab_node *ptr.  You can test
35    whether it points to a 'derived' cgraph_node as follows.
36 
37      if (is_a <cgraph_node *> (ptr))
38        ....
39 
40 
41TYPE as_a <TYPE> (pointer)
42 
43    Converts pointer to a TYPE.
44 
45    You can just assume that it is such a node.
46 
47      do_something_with (as_a <cgraph_node *> *ptr);
48 
49TYPE safe_as_a <TYPE> (pointer)
50 
51    Like as_a <TYPE> (pointer), but where pointer could be NULL.  This
52    adds a check against NULL where the regular is_a_helper hook for TYPE
53    assumes non-NULL.
54 
55      do_something_with (safe_as_a <cgraph_node *> *ptr);
56 
57TYPE dyn_cast <TYPE> (pointer)
58 
59    Converts pointer to TYPE if and only if "is_a <TYPE> pointer".  Otherwise,
60    returns NULL.  This function is essentially a checked down cast.
61 
62    This functions reduce compile time and increase type safety when treating a
63    generic item as a more specific item.
64 
65    You can test and obtain a pointer to the 'derived' type in one indivisible
66    operation.
67 
68      if (cgraph_node *cptr = dyn_cast <cgraph_node *> (ptr))
69        ....
70 
71    As an example, the code change is from
72 
73      if (symtab_function_p (node))
74        {
75          struct cgraph_node *cnode = cgraph (node);
76          ....
77        }
78 
79    to
80 
81      if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
82        {
83          ....
84        }
85 
86    The necessary conditional test defines a variable that holds a known good
87    pointer to the specific item and avoids subsequent conversion calls and
88    the assertion checks that may come with them.
89 
90    When, the property test is embedded within a larger condition, the
91    variable declaration gets pulled out of the condition.  (This approach
92    leaves some room for using the variable inappropriately.)
93 
94      if (symtab_variable_p (node) && varpool (node)->finalized)
95        varpool_analyze_node (varpool (node));
96 
97    becomes
98 
99      varpool_node *vnode = dyn_cast <varpool_node *> (node);
100      if (vnode && vnode->finalized)
101        varpool_analyze_node (vnode);
102 
103    Note that we have converted two sets of assertions in the calls to varpool
104    into safe and efficient use of a variable.
105 
106TYPE safe_dyn_cast <TYPE> (pointer)
107 
108    Like dyn_cast <TYPE> (pointer), except that it accepts null pointers
109    and returns null results for them.
110 
111 
112If you use these functions and get a 'inline function not defined' or a
113'missing symbol' error message for 'is_a_helper<....>::test', it means that
114the connection between the types has not been made.  See below.
115 
116 
117EXTENDING THE GENERIC TYPE FACILITY
118 
119Method 1
120--------
121 
122If DERIVED is derived from BASE, and if BASE contains enough information
123to determine whether an object is actually an instance of DERIVED,
124then you can make the above routines work for DERIVED by defining
125a specialization of is_a_helper such as:
126 
127  template<>
128  struct is_a_helper<DERIVED *> : static_is_a_helper<DERIVED *>
129  {
130    static inline bool test (const BASE *p) { return ...; }
131  };
132 
133This test function should return true if P is an instanced of DERIVED.
134This on its own is enough; the comments below for method 2 do not apply.
135 
136Method 2
137--------
138 
139Alternatively, if two types are connected in ways other than C++
140inheritance, each connection between them must be made by defining a
141specialization of the template member function 'test' of the template
142class 'is_a_helper'.  For example,
143 
144  template <>
145  template <>
146  inline bool
147  is_a_helper <cgraph_node *>::test (symtab_node *p)
148  {
149    return p->type == SYMTAB_FUNCTION;
150  }
151 
152If a simple reinterpret_cast between the pointer types is incorrect, then you
153must also specialize the template member function 'cast'.  Failure to do so
154when needed may result in a crash.  For example,
155 
156  template <>
157  template <>
158  inline bool
159  is_a_helper <cgraph_node *>::cast (symtab_node *p)
160  {
161    return &p->x_function;
162  }
163 
164*/
165 
166#ifndef GCC_IS_A_H
167#define GCC_IS_A_H
168 
169/* A base class that specializations of is_a_helper can use if casting
170   U * to T is simply a reinterpret_cast.  */
171 
172template <typename T>
173struct reinterpret_is_a_helper
174{
175  template <typename U>
176  static inline T cast (U *p) { return reinterpret_cast <T> (p); }
15
←
Returning without writing to 'p->next', which participates in a condition later→
16
←
Returning pointer (loaded from 'p'), which participates in a condition later→
177};
178 
179/* A base class that specializations of is_a_helper can use if casting
180   U * to T is simply a static_cast.  This is more type-safe than
181   reinterpret_is_a_helper.  */
182 
183template <typename T>
184struct static_is_a_helper
185{
186  template <typename U>
187  static inline T cast (U *p) { return static_cast <T> (p); }
188};
189 
190/* A generic type conversion internal helper class.  */
191 
192template <typename T>
193struct is_a_helper : reinterpret_is_a_helper<T>
194{
195  template <typename U>
196  static inline bool test (U *p);
197};
198 
199/* Reuse the definition of is_a_helper<T *> to implement
200   is_a_helper<const T *>.  */
201 
202template <typename T>
203struct is_a_helper<const T *>
204{
205  template <typename U>
206  static inline const T *cast (const U *p)
207  {
208    return is_a_helper<T *>::cast (const_cast <U *> (p));
209  }
210  template <typename U>
211  static inline bool test (const U *p)
212  {
213    return is_a_helper<T *>::test (p);
214  }
215};
216 
217/* Note that we deliberately do not define the 'test' member template.  Not
218   doing so will result in a build-time error for type relationships that have
219   not been defined, rather than a run-time error.  See the discussion above
220   for when to define this member.  */
221 
222/* The public interface.  */
223 
224/* A generic test for a type relationship.  See the discussion above for when
225   to use this function.  The question answered is "Is type T a derived type of
226   type U?".  */
227 
228template <typename T, typename U>
229inline bool
230is_a (U *p)
231{
232  return is_a_helper<T>::test (p);
7
←
Calling 'is_a_helper::test'→
10
←
Returning from 'is_a_helper::test'→
11
←
Returning without writing to 'p->next', which participates in a condition later→
233}
234 
235/* A generic conversion from a base type U to a derived type T.  See the
236   discussion above for when to use this function.  */
237 
238template <typename T, typename U>
239inline T
240as_a (U *p)
241{
242  gcc_checking_assert (is_a <T> (p))((void)(!(is_a <T> (p)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/is-a.h"
, 242, __FUNCTION__), 0 : 0));
243  return is_a_helper <T>::cast (p);
244}
245 
246/* Similar to as_a<>, but where the pointer can be NULL, even if
247   is_a_helper<T> doesn't check for NULL.  */
248 
249template <typename T, typename U>
250inline T
251safe_as_a (U *p)
252{
253  if (p)
254    {
255      gcc_checking_assert (is_a <T> (p))((void)(!(is_a <T> (p)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/is-a.h"
, 255, __FUNCTION__), 0 : 0));
256      return is_a_helper <T>::cast (p);
257    }
258  else
259    return NULLnullptr;
260}
261 
262/* A generic checked conversion from a base type U to a derived type T.  See
263   the discussion above for when to use this function.  */
264 
265template <typename T, typename U>
266inline T
267dyn_cast (U *p)
268{
269  if (is_a <T> (p))
6
←
Calling 'is_a<cgraph_node *, symtab_node>'→
12
←
Returning from 'is_a<cgraph_node *, symtab_node>'→
13
←
Taking true branch→
24
←
Taking true branch→
270    return is_a_helper <T>::cast (p);
14
←
Calling 'reinterpret_is_a_helper::cast'→
17
←
Returning from 'reinterpret_is_a_helper::cast'→
18
←
Returning without writing to 'p->next', which participates in a condition later→
19
←
Returning pointer, which participates in a condition later→
25
←
Returning pointer, which participates in a condition later→
271  else
272    return static_cast <T> (0);
273}
274 
275/* Similar to dyn_cast, except that the pointer may be null.  */
276 
277template <typename T, typename U>
278inline T
279safe_dyn_cast (U *p)
280{
281  return p ? dyn_cast <T> (p) : 0;
282}
283 
284#endif  /* GCC_IS_A_H  */

←

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h

1/* Callgraph summary data structure.
 Copyright (C) 2014-2023 Free Software Foundation, Inc.
 Contributed by Martin Liska

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#ifndef GCC_SYMBOL_SUMMARY_H
22#define GCC_SYMBOL_SUMMARY_H

24/* Base class for function_summary and fast_function_summary classes.  */

26template <class T>
27class function_summary_base
28{
29public:
/* Default construction takes SYMTAB as an argument.  */
function_summary_base (symbol_table *symtab,
	 cgraph_node_hook symtab_insertion,
	 cgraph_node_hook symtab_removal,
	 cgraph_2node_hook symtab_duplication
	 CXX_MEM_STAT_INFO):
m_symtab (symtab), m_symtab_insertion (symtab_insertion),
m_symtab_removal (symtab_removal),
m_symtab_duplication (symtab_duplication),
m_symtab_insertion_hook (NULLnullptr), m_symtab_duplication_hook (NULLnullptr),
m_allocator ("function summary" PASS_MEM_STAT)
{
  enable_insertion_hook ();
  m_symtab_removal_hook
    = m_symtab->add_cgraph_removal_hook (m_symtab_removal, this);
  enable_duplication_hook ();
}

/* Basic implementation of insert operation.  */
virtual void insert (cgraph_node *, T *)
{
  /* In most cases, it makes no sense to create summaries without
     initializing them.  */
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 53, __FUNCTION__));
}

/* Basic implementation of removal operation.  */
virtual void remove (cgraph_node *, T *) {}

/* Basic implementation of duplication operation.  */
virtual void duplicate (cgraph_node *, cgraph_node *, T *, T *)
{
  /* It makes no sense to not copy anything during duplication.  */
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 63, __FUNCTION__));
}

/* Enable insertion hook invocation.  */
void enable_insertion_hook ()
{
  if (m_symtab_insertion_hook == NULLnullptr)
    m_symtab_insertion_hook
= m_symtab->add_cgraph_insertion_hook (m_symtab_insertion, this);
}

/* Enable insertion hook invocation.  */
void disable_insertion_hook ()
{
  if (m_symtab_insertion_hook != NULLnullptr)
    {
m_symtab->remove_cgraph_insertion_hook (m_symtab_insertion_hook);
m_symtab_insertion_hook = NULLnullptr;
    }
}

/* Enable duplication hook invocation.  */
void enable_duplication_hook ()
{
  if (m_symtab_duplication_hook == NULLnullptr)
    m_symtab_duplication_hook
= m_symtab->add_cgraph_duplication_hook (m_symtab_duplication, this);
}

/* Enable duplication hook invocation.  */
void disable_duplication_hook ()
{
  if (m_symtab_duplication_hook != NULLnullptr)
    {
m_symtab->remove_cgraph_duplication_hook (m_symtab_duplication_hook);
m_symtab_duplication_hook = NULLnullptr;
    }
}

102protected:
/* Allocates new data that are stored within map.  */
T* allocate_new ()
{
  /* Call gcc_internal_because we do not want to call finalizer for
     a type T.  We call dtor explicitly.  */
  return is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T ()
     : m_allocator.allocate () ;
}

/* Release an item that is stored within map.  */
void release (T *item)
{
  if (is_ggc ())
    ggc_delete (item);
  else
    m_allocator.remove (item);
}

/* Unregister all call-graph hooks.  */
void unregister_hooks ();

/* Symbol table the summary is registered to.  */
symbol_table *m_symtab;

/* Insertion function defined by a summary.  */
cgraph_node_hook m_symtab_insertion;
/* Removal function defined by a summary.  */
cgraph_node_hook m_symtab_removal;
/* Duplication function defined by a summary.  */
cgraph_2node_hook m_symtab_duplication;

/* Internal summary insertion hook pointer.  */
cgraph_node_hook_list *m_symtab_insertion_hook;
/* Internal summary removal hook pointer.  */
cgraph_node_hook_list *m_symtab_removal_hook;
/* Internal summary duplication hook pointer.  */
cgraph_2node_hook_list *m_symtab_duplication_hook;

141private:
/* Return true when the summary uses GGC memory for allocation.  */
virtual bool is_ggc () = 0;

/* Object allocator for heap allocation.  */
object_allocator<T> m_allocator;
147};

149template <typename T>
150void
151function_summary_base<T>::unregister_hooks ()
152{
disable_insertion_hook ();
m_symtab->remove_cgraph_removal_hook (m_symtab_removal_hook);
disable_duplication_hook ();
156}

158/* We want to pass just pointer types as argument for function_summary
 template class.  */

161template <class T>
162class function_summary
163{
164private:
function_summary();
166};

168/* Function summary is a helper class that is used to associate a data structure
 related to a callgraph node.  Typical usage can be seen in IPA passes which
 create a temporary pass-related structures.  The summary class registers
 hooks that are triggered when a new node is inserted, duplicated and deleted.
 A user of a summary class can ovewrite virtual methods than are triggered by
 the summary if such hook is triggered.  Apart from a callgraph node, the user
 is given a data structure tied to the node.

 The function summary class can work both with a heap-allocated memory and
 a memory gained by garbage collected memory.  */

179template <class T>
180class GTY((user)) function_summary <T *>: public function_summary_base<T>
181{
182public:
/* Default construction takes SYMTAB as an argument.  */
function_summary (symbol_table *symtab, bool ggc = false CXX_MEM_STAT_INFO);

/* Destructor.  */
virtual ~function_summary ();

/* Traverses all summarys with a function F called with
   ARG as argument.  */
template<typename Arg, bool (*f)(const T &, Arg)>
void traverse (Arg a) const
{
  m_map.template traverse <f> (a);
}

/* Getter for summary callgraph node pointer.  If a summary for a node
   does not exist it will be created.  */
T* get_create (cgraph_node *node)
{
  bool existed;
  T **v = &m_map.get_or_insert (node->get_uid (), &existed);
  if (!existed)
    *v = this->allocate_new ();

  return *v;
}

/* Getter for summary callgraph node pointer.  */
T* get (cgraph_node *node) ATTRIBUTE_PURE__attribute__ ((__pure__))
{
  T **v = m_map.get (node->get_uid ());
  return v == NULLnullptr ? NULLnullptr : *v;
}

/* Remove node from summary.  */
using function_summary_base<T>::remove;
void remove (cgraph_node *node)
{
  int uid = node->get_uid ();
  T **v = m_map.get (uid);
  if (v)
    {
m_map.remove (uid);
this->release (*v);
    }
}

/* Return true if a summary for the given NODE already exists.  */
bool exists (cgraph_node *node)
{
  return m_map.get (node->get_uid ()) != NULLnullptr;
}

/* Symbol insertion hook that is registered to symbol table.  */
static void symtab_insertion (cgraph_node *node, void *data);

/* Symbol removal hook that is registered to symbol table.  */
static void symtab_removal (cgraph_node *node, void *data);

/* Symbol duplication hook that is registered to symbol table.  */
static void symtab_duplication (cgraph_node *node, cgraph_node *node2,
		  void *data);

245protected:
/* Indication if we use ggc summary.  */
bool m_ggc;

249private:
/* Indication if we use ggc summary.  */
bool is_ggc () final override
{
  return m_ggc;
}

typedef int_hash <int, 0, -1> map_hash;

/* Main summary store, where summary ID is used as key.  */
hash_map <map_hash, T *> m_map;

template <typename U> friend void gt_ggc_mx (function_summary <U *> * const &);
template <typename U> friend void gt_pch_nx (function_summary <U *> * const &);
template <typename U> friend void gt_pch_nx (function_summary <U *> * const &,
    gt_pointer_operator, void *);
265};

267template <typename T>
268function_summary<T *>::function_summary (symbol_table *symtab, bool ggc
			 MEM_STAT_DECL):
function_summary_base<T> (symtab, function_summary::symtab_insertion,
	    function_summary::symtab_removal,
	    function_summary::symtab_duplication
	    PASS_MEM_STAT),
m_ggc (ggc), m_map (13, ggc, true, GATHER_STATISTICS0 PASS_MEM_STAT) {}

276template <typename T>
277function_summary<T *>::~function_summary ()
278{
this->unregister_hooks ();

/* Release all summaries.  */
typedef typename hash_map <map_hash, T *>::iterator map_iterator;
for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
  this->release ((*it).second);
285}

287template <typename T>
288void
289function_summary<T *>::symtab_insertion (cgraph_node *node, void *data)
290{
gcc_checking_assert (node->get_uid ())((void)(!(node->get_uid ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 291, __FUNCTION__), 0 : 0));
function_summary *summary = (function_summary <T *> *) (data);
summary->insert (node, summary->get_create (node));
294}

296template <typename T>
297void
298function_summary<T *>::symtab_removal (cgraph_node *node, void *data)
299{
gcc_checking_assert (node->get_uid ())((void)(!(node->get_uid ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 300, __FUNCTION__), 0 : 0));
function_summary *summary = (function_summary <T *> *) (data);
summary->remove (node);
303}

305template <typename T>
306void
307function_summary<T *>::symtab_duplication (cgraph_node *node,
			   cgraph_node *node2, void *data)
309{
function_summary *summary = (function_summary <T *> *) (data);
T *v = summary->get (node);

if (v)
  summary->duplicate (node, node2, v, summary->get_create (node2));
315}

317template <typename T>
318void
319gt_ggc_mx(function_summary<T *>* const &summary)
320{
gcc_checking_assert (summary->m_ggc)((void)(!(summary->m_ggc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 321, __FUNCTION__), 0 : 0));
gt_ggc_mx (&summary->m_map);
323}

325template <typename T>
326void
327gt_pch_nx (function_summary<T *> *const &)
328{
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 329, __FUNCTION__));
330}

332template <typename T>
333void
334gt_pch_nx (function_summary<T *> *const &, gt_pointer_operator, void *)
335{
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 336, __FUNCTION__));
337}

339/* Help template from std c++11.  */

341template<typename T, typename U>
342struct is_same
343{
  static const bool value = false;
345};

347template<typename T>
348struct is_same<T,T>  //specialization
349{
 static const bool value = true;
351};

353/* We want to pass just pointer types as argument for fast_function_summary
 template class.  */

356template <class T, class V>
357class fast_function_summary
358{
359private:
fast_function_summary ();
361};

363/* Function vector summary is a fast implementation of function_summary that
 utilizes vector as primary storage of summaries.  */

366template <class T, class V>
367class GTY((user)) fast_function_summary <T *, V>
: public function_summary_base<T>
369{
370public:
/* Default construction takes SYMTAB as an argument.  */
fast_function_summary (symbol_table *symtab CXX_MEM_STAT_INFO);

/* Destructor.  */
virtual ~fast_function_summary ();

/* Traverses all summarys with a function F called with
   ARG as argument.  */
template<typename Arg, bool (*f)(const T &, Arg)>
void traverse (Arg a) const
{
  for (unsigned i = 0; i < m_vector->length (); i++)
    if ((*m_vector[i]) != NULLnullptr)
f ((*m_vector)[i], a);
}

/* Getter for summary callgraph node pointer.  If a summary for a node
   does not exist it will be created.  */
T* get_create (cgraph_node *node)
{
  int id = node->get_summary_id ();
  if (id == -1)
    id = this->m_symtab->assign_summary_id (node);

  if ((unsigned int)id >= m_vector->length ())
    vec_safe_grow_cleared (m_vector,
	     this->m_symtab->cgraph_max_summary_id);

  if ((*m_vector)[id] == NULLnullptr)
    (*m_vector)[id] = this->allocate_new ();

  return (*m_vector)[id];
}

/* Getter for summary callgraph node pointer.  */
T* get (cgraph_node *node) ATTRIBUTE_PURE__attribute__ ((__pure__))
{
  return exists (node) ? (*m_vector)[node->get_summary_id ()] : NULLnullptr;
}

using function_summary_base<T>::remove;
void remove (cgraph_node *node)
{
  if (exists (node))
    {
int id = node->get_summary_id ();
this->release ((*m_vector)[id]);
(*m_vector)[id] = NULLnullptr;
    }
}

/* Return true if a summary for the given NODE already exists.  */
bool exists (cgraph_node *node)
{
  int id = node->get_summary_id ();
  return (id != -1
   && (unsigned int)id < m_vector->length ()
   && (*m_vector)[id] != NULLnullptr);
}

/* Symbol insertion hook that is registered to symbol table.  */
static void symtab_insertion (cgraph_node *node, void *data);

/* Symbol removal hook that is registered to symbol table.  */
static void symtab_removal (cgraph_node *node, void *data);

/* Symbol duplication hook that is registered to symbol table.  */
static void symtab_duplication (cgraph_node *node, cgraph_node *node2,
		  void *data);

441private:
bool is_ggc () final override;

/* Summary is stored in the vector.  */
vec <T *, V> *m_vector;

template <typename U> friend void gt_ggc_mx (fast_function_summary <U *, va_gc> * const &);
template <typename U> friend void gt_pch_nx (fast_function_summary <U *, va_gc> * const &);
template <typename U> friend void gt_pch_nx (fast_function_summary <U *, va_gc> * const &,
    gt_pointer_operator, void *);
451};

453template <typename T, typename V>
454fast_function_summary<T *, V>::fast_function_summary (symbol_table *symtab
				      MEM_STAT_DECL):
function_summary_base<T> (symtab,
	    fast_function_summary::symtab_insertion,
	    fast_function_summary::symtab_removal,
	    fast_function_summary::symtab_duplication
	    PASS_MEM_STAT), m_vector (NULLnullptr)
461{
vec_alloc (m_vector, 13 PASS_MEM_STAT);
463}

465template <typename T, typename V>
466fast_function_summary<T *, V>::~fast_function_summary ()
467{
this->unregister_hooks ();

/* Release all summaries.  */
for (unsigned i = 0; i < m_vector->length (); i++)
  if ((*m_vector)[i] != NULLnullptr)
    this->release ((*m_vector)[i]);
vec_free (m_vector);
475}

477template <typename T, typename V>
478void
479fast_function_summary<T *, V>::symtab_insertion (cgraph_node *node, void *data)
480{
gcc_checking_assert (node->get_uid ())((void)(!(node->get_uid ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 481, __FUNCTION__), 0 : 0));
fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);
summary->insert (node, summary->get_create (node));
484}

486template <typename T, typename V>
487void
488fast_function_summary<T *, V>::symtab_removal (cgraph_node *node, void *data)
489{
gcc_checking_assert (node->get_uid ())((void)(!(node->get_uid ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 490, __FUNCTION__), 0 : 0));
fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);

if (summary->exists (node))
  summary->remove (node);
495}

497template <typename T, typename V>
498void
499fast_function_summary<T *, V>::symtab_duplication (cgraph_node *node,
				   cgraph_node *node2,
				   void *data)
502{
fast_function_summary *summary = (fast_function_summary <T *, V> *) (data);
T *v = summary->get (node);

if (v)
  {
    T *duplicate = summary->get_create (node2);
    summary->duplicate (node, node2, v, duplicate);
  }
511}

513template <typename T, typename V>
514inline bool
515fast_function_summary<T *, V>::is_ggc ()
516{
return is_same<V, va_gc>::value;
518}

520template <typename T>
521void
522gt_ggc_mx (fast_function_summary<T *, va_heap>* const &)
523{
524}

526template <typename T>
527void
528gt_pch_nx (fast_function_summary<T *, va_heap>* const &)
529{
530}

532template <typename T>
533void
534gt_pch_nx (fast_function_summary<T *, va_heap>* const&, gt_pointer_operator,
  void *)
536{
537}

539template <typename T>
540void
541gt_ggc_mx (fast_function_summary<T *, va_gc>* const &summary)
542{
ggc_test_and_set_mark (summary->m_vector)((summary->m_vector) != nullptr && ((void *) (summary
->m_vector)) != (void *) 1 && ! ggc_set_mark (summary
->m_vector));
gt_ggc_mx (summary->m_vector);
545}

547template <typename T>
548void
549gt_pch_nx (fast_function_summary<T *, va_gc> *const &)
550{
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 551, __FUNCTION__));
552}

554template <typename T>
555void
556gt_pch_nx (fast_function_summary<T *, va_gc> *const &, gt_pointer_operator,
  void *)
558{
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 559, __FUNCTION__));
560}

562/* Base class for call_summary and fast_call_summary classes.  */

564template <class T>
565class call_summary_base
566{
567public:
/* Default construction takes SYMTAB as an argument.  */
call_summary_base (symbol_table *symtab, cgraph_edge_hook symtab_removal,
     cgraph_2edge_hook symtab_duplication CXX_MEM_STAT_INFO):
m_symtab (symtab), m_symtab_removal (symtab_removal),
m_symtab_duplication (symtab_duplication), m_symtab_duplication_hook (NULLnullptr),
m_initialize_when_cloning (false),
m_allocator ("call summary" PASS_MEM_STAT)
{
  m_symtab_removal_hook
    = m_symtab->add_edge_removal_hook (m_symtab_removal, this);
  enable_duplication_hook ();
}

/* Basic implementation of removal operation.  */
virtual void remove (cgraph_edge *, T *) {}

/* Basic implementation of duplication operation.  */
virtual void duplicate (cgraph_edge *, cgraph_edge *, T *, T *)
{
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 587, __FUNCTION__));
}

/* Enable duplication hook invocation.  */
void enable_duplication_hook ()
{
  if (m_symtab_duplication_hook == NULLnullptr)
    m_symtab_duplication_hook
= m_symtab->add_edge_duplication_hook (m_symtab_duplication,
			       this);
}

/* Enable duplication hook invocation.  */
void disable_duplication_hook ()
{
  if (m_symtab_duplication_hook != NULLnullptr)
    {
m_symtab->remove_edge_duplication_hook (m_symtab_duplication_hook);
m_symtab_duplication_hook = NULLnullptr;
    }
}

609protected:
/* Allocates new data that are stored within map.  */
T* allocate_new ()
{
  /* Call gcc_internal_because we do not want to call finalizer for
     a type T.  We call dtor explicitly.  */
  return is_ggc () ? new (ggc_internal_alloc (sizeof (T))) T ()
     : m_allocator.allocate ();
}

/* Release an item that is stored within map.  */
void release (T *item)
{
  if (is_ggc ())
    ggc_delete (item);
  else
    m_allocator.remove (item);
}

/* Unregister all call-graph hooks.  */
void unregister_hooks ();

/* Symbol table the summary is registered to.  */
symbol_table *m_symtab;

/* Removal function defined by a summary.  */
cgraph_edge_hook m_symtab_removal;
/* Duplication function defined by a summary.  */
cgraph_2edge_hook m_symtab_duplication;

/* Internal summary removal hook pointer.  */
cgraph_edge_hook_list *m_symtab_removal_hook;
/* Internal summary duplication hook pointer.  */
cgraph_2edge_hook_list *m_symtab_duplication_hook;
/* Initialize summary for an edge that is cloned.  */
bool m_initialize_when_cloning;

646private:
/* Return true when the summary uses GGC memory for allocation.  */
virtual bool is_ggc () = 0;

/* Object allocator for heap allocation.  */
object_allocator<T> m_allocator;
652};

654template <typename T>
655void
656call_summary_base<T>::unregister_hooks ()
657{
m_symtab->remove_edge_removal_hook (m_symtab_removal_hook);
disable_duplication_hook ();
660}

662/* An impossible class templated by non-pointers so, which makes sure that only
 summaries gathering pointers can be created.  */

665template <class T>
666class call_summary
667{
668private:
call_summary ();
670};

672/* Class to store auxiliary information about call graph edges.  */

674template <class T>
675class GTY((user)) call_summary <T *>: public call_summary_base<T>
676{
677public:
/* Default construction takes SYMTAB as an argument.  */
call_summary (symbol_table *symtab, bool ggc = false
CXX_MEM_STAT_INFO)
: call_summary_base<T> (symtab, call_summary::symtab_removal,
	  call_summary::symtab_duplication PASS_MEM_STAT),
  m_ggc (ggc), m_map (13, ggc, true, GATHER_STATISTICS0 PASS_MEM_STAT) {}

/* Destructor.  */
virtual ~call_summary ();

/* Traverses all summarys with an edge E called with
   ARG as argument.  */
template<typename Arg, bool (*f)(const T &, Arg)>
void traverse (Arg a) const
{
  m_map.template traverse <f> (a);
}

/* Getter for summary callgraph edge pointer.
   If a summary for an edge does not exist, it will be created.  */
T* get_create (cgraph_edge *edge)
{
  bool existed;
  T **v = &m_map.get_or_insert (edge->get_uid (), &existed);
43
←
Called C++ object pointer is null
  if (!existed)
    *v = this->allocate_new ();

  return *v;
}

/* Getter for summary callgraph edge pointer.  */
T* get (cgraph_edge *edge) ATTRIBUTE_PURE__attribute__ ((__pure__))
{
  T **v = m_map.get (edge->get_uid ());
  return v == NULLnullptr ? NULLnullptr : *v;
}

/* Remove edge from summary.  */
using call_summary_base<T>::remove;
void remove (cgraph_edge *edge)
{
  int uid = edge->get_uid ();
  T **v = m_map.get (uid);
  if (v)
    {
m_map.remove (uid);
this->release (*v);
    }
}

/* Return true if a summary for the given EDGE already exists.  */
bool exists (cgraph_edge *edge)
{
  return m_map.get (edge->get_uid ()) != NULLnullptr;
}

/* Symbol removal hook that is registered to symbol table.  */
static void symtab_removal (cgraph_edge *edge, void *data);

/* Symbol duplication hook that is registered to symbol table.  */
static void symtab_duplication (cgraph_edge *edge1, cgraph_edge *edge2,
		  void *data);

741protected:
/* Indication if we use ggc summary.  */
bool m_ggc;

745private:
/* Indication if we use ggc summary.  */
bool is_ggc () final override
{
  return m_ggc;
}

typedef int_hash <int, 0, -1> map_hash;

/* Main summary store, where summary ID is used as key.  */
hash_map <map_hash, T *> m_map;

template <typename U> friend void gt_ggc_mx (call_summary <U *> * const &);
template <typename U> friend void gt_pch_nx (call_summary <U *> * const &);
template <typename U> friend void gt_pch_nx (call_summary <U *> * const &,
    gt_pointer_operator, void *);
761};

763template <typename T>
764call_summary<T *>::~call_summary ()
765{
this->unregister_hooks ();

/* Release all summaries.  */
typedef typename hash_map <map_hash, T *>::iterator map_iterator;
for (map_iterator it = m_map.begin (); it != m_map.end (); ++it)
  this->release ((*it).second);
772}

774template <typename T>
775void
776call_summary<T *>::symtab_removal (cgraph_edge *edge, void *data)
777{
call_summary *summary = (call_summary <T *> *) (data);
summary->remove (edge);
780}

782template <typename T>
783void
784call_summary<T *>::symtab_duplication (cgraph_edge *edge1,
		       cgraph_edge *edge2, void *data)
786{
call_summary *summary = (call_summary <T *> *) (data);
T *edge1_summary = NULLnullptr;

if (summary->m_initialize_when_cloning)
  edge1_summary = summary->get_create (edge1);
else
  edge1_summary = summary->get (edge1);

if (edge1_summary)
  summary->duplicate (edge1, edge2, edge1_summary,
	summary->get_create (edge2));
798}

800template <typename T>
801void
802gt_ggc_mx(call_summary<T *>* const &summary)
803{
gcc_checking_assert (summary->m_ggc)((void)(!(summary->m_ggc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 804, __FUNCTION__), 0 : 0));
gt_ggc_mx (&summary->m_map);
806}

808template <typename T>
809void
810gt_pch_nx (call_summary<T *> *const &)
811{
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 812, __FUNCTION__));
813}

815template <typename T>
816void
817gt_pch_nx (call_summary<T *> *const &, gt_pointer_operator, void *)
818{
gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/symbol-summary.h"
, 819, __FUNCTION__));
820}

822/* We want to pass just pointer types as argument for fast_call_summary
 template class.  */

825template <class T, class V>
826class fast_call_summary
827{
828private:
fast_call_summary ();
830};

832/* Call vector summary is a fast implementation of call_summary that
 utilizes vector as primary storage of summaries.  */

835template <class T, class V>
836class GTY((user)) fast_call_summary <T *, V>: public call_summary_base<T>
837{
838public:
/* Default construction takes SYMTAB as an argument.  */
fast_call_summary (symbol_table *symtab CXX_MEM_STAT_INFO)
: call_summary_base<T> (symtab, fast_call_summary::symtab_removal,
	  fast_call_summary::symtab_duplication PASS_MEM_STAT),
  m_vector (NULLnullptr)
{
  vec_alloc (m_vector, 13 PASS_MEM_STAT);
}

/* Destructor.  */
virtual ~fast_call_summary ();

/* Traverses all summarys with an edge F called with
   ARG as argument.  */
template<typename Arg, bool (*f)(const T &, Arg)>
void traverse (Arg a) const
{
  for (unsigned i = 0; i < m_vector->length (); i++)
    if ((*m_vector[i]) != NULLnullptr)
f ((*m_vector)[i], a);
}

/* Getter for summary callgraph edge pointer.
   If a summary for an edge does not exist, it will be created.  */
T* get_create (cgraph_edge *edge)
{
  int id = edge->get_summary_id ();
  if (id == -1)
    id = this->m_symtab->assign_summary_id (edge);

  if ((unsigned)id >= m_vector->length ())
    vec_safe_grow_cleared (m_vector, this->m_symtab->edges_max_summary_id);

  if ((*m_vector)[id] == NULLnullptr)
    (*m_vector)[id] = this->allocate_new ();

  return (*m_vector)[id];
}

/* Getter for summary callgraph edge pointer.  */
T* get (cgraph_edge *edge) ATTRIBUTE_PURE__attribute__ ((__pure__))
{
  return exists (edge) ? (*m_vector)[edge->get_summary_id ()] : NULLnullptr;
}

/* Remove edge from summary.  */
using call_summary_base<T>::remove;
void remove (cgraph_edge *edge)
{
  if (exists (edge))
    {
int id = edge->get_summary_id ();
this->release ((*m_vector)[id]);
(*m_vector)[id] = NULLnullptr;
    }
}

/* Return true if a summary for the given EDGE already exists.  */
bool exists (cgraph_edge *edge)
{
  int id = edge->get_summary_id ();
  return (id != -1
   && (unsigned)id < m_vector->length ()
   && (*m_vector)[id] != NULLnullptr);
}

/* Symbol removal hook that is registered to symbol table.  */
static void symtab_removal (cgraph_edge *edge, void *data);

/* Symbol duplication hook that is registered to symbol table.  */
static void symtab_duplication (cgraph_edge *edge1, cgraph_edge *edge2,
		  void *data);

912private:
bool is_ggc () final override;

/* Summary is stored in the vector.  */
vec <T *, V> *m_vector;

template <typename U> friend void gt_ggc_mx (fast_call_summary <U *, va_gc> * const &);
template <typename U> friend void gt_pch_nx (fast_call_summary <U *, va_gc> * const &);
template <typename U> friend void gt_pch_nx (fast_call_summary <U *, va_gc> * const &,
    gt_pointer_operator, void *);
922};

924template <typename T, typename V>
925fast_call_summary<T *, V>::~fast_call_summary ()
926{
this->unregister_hooks ();

/* Release all summaries.  */
for (unsigned i = 0; i < m_vector->length (); i++)
  if ((*m_vector)[i] != NULLnullptr)
    this->release ((*m_vector)[i]);
vec_free (m_vector);
934}

936template <typename T, typename V>
937void
938fast_call_summary<T *, V>::symtab_removal (cgraph_edge *edge, void *data)
939{
fast_call_summary *summary = (fast_call_summary <T *, V> *) (data);
summary->remove (edge);
942}

944template <typename T, typename V>
945void
946fast_call_summary<T *, V>::symtab_duplication (cgraph_edge *edge1,
				 cgraph_edge *edge2, void *data)
948{
fast_call_summary *summary = (fast_call_summary <T *, V> *) (data);
T *edge1_summary = NULLnullptr;

if (summary->m_initialize_when_cloning)
  edge1_summary = summary->get_create (edge1);
else
  edge1_summary = summary->get (edge1);

if (edge1_summary)
  {
    T *duplicate = summary->get_create (edge2);
    summary->duplicate (edge1, edge2, edge1_summary, duplicate);
  }
962}

964template <typename T, typename V>
965inline bool
966fast_call_summary<T *, V>::is_ggc ()
967{
return is_same<V, va_gc>::value;
969}

971template <typename T>
972void
973gt_ggc_mx (fast_call_summary<T *, va_heap>* const &summary ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
974{
975}

977template <typename T>
978void
979gt_pch_nx (fast_call_summary<T *, va_heap>* const &summary ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
980{
981}

983template <typename T>
984void
985gt_pch_nx (fast_call_summary<T *, va_heap>* const& summary ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
  gt_p