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

Bug Summary

File:	build/gcc/ipa-prop.cc
Warning:	line 1739, column 7 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-prop.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-_es4xO.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc
/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc

→
1/* Interprocedural analyses.
 Copyright (C) 2005-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#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "backend.h"
24#include "rtl.h"
25#include "tree.h"
26#include "gimple.h"
27#include "alloc-pool.h"
28#include "tree-pass.h"
29#include "ssa.h"
30#include "tree-streamer.h"
31#include "cgraph.h"
32#include "diagnostic.h"
33#include "fold-const.h"
34#include "gimple-iterator.h"
35#include "gimple-fold.h"
36#include "tree-eh.h"
37#include "calls.h"
38#include "stor-layout.h"
39#include "print-tree.h"
40#include "gimplify.h"
41#include "gimplify-me.h"
42#include "gimple-walk.h"
43#include "symbol-summary.h"
44#include "ipa-prop.h"
45#include "tree-cfg.h"
46#include "tree-dfa.h"
47#include "tree-inline.h"
48#include "ipa-fnsummary.h"
49#include "gimple-pretty-print.h"
50#include "ipa-utils.h"
51#include "dbgcnt.h"
52#include "domwalk.h"
53#include "builtins.h"
54#include "tree-cfgcleanup.h"
55#include "options.h"
56#include "symtab-clones.h"
57#include "attr-fnspec.h"
58#include "gimple-range.h"

60/* Function summary where the parameter infos are actually stored. */
61ipa_node_params_t *ipa_node_params_sum = NULLnullptr;

63function_summary <ipcp_transformation *> *ipcp_transformation_sum = NULLnullptr;

65/* Edge summary for IPA-CP edge information.  */
66ipa_edge_args_sum_t *ipa_edge_args_sum;

68/* Traits for a hash table for reusing already existing ipa_bits. */

70struct ipa_bit_ggc_hash_traits : public ggc_cache_remove <ipa_bits *>
71{
typedef ipa_bits *value_type;
typedef ipa_bits *compare_type;
static hashval_t
hash (const ipa_bits *p)
{
  hashval_t t = (hashval_t) p->value.to_shwi ();
  return iterative_hash_host_wide_int (p->mask.to_shwi (), t);
}
static bool
equal (const ipa_bits *a, const ipa_bits *b)
  {
    return a->value == b->value && a->mask == b->mask;
  }
static const bool empty_zero_p = true;
static void
mark_empty (ipa_bits *&p)
  {
    p = NULLnullptr;
  }
static bool
is_empty (const ipa_bits *p)
  {
    return p == NULLnullptr;
  }
static bool
is_deleted (const ipa_bits *p)
  {
    return p == reinterpret_cast<const ipa_bits *> (1);
  }
static void
mark_deleted (ipa_bits *&p)
  {
    p = reinterpret_cast<ipa_bits *> (1);
  }
106};

108/* Hash table for avoid repeated allocations of equal ipa_bits.  */
109static GTY ((cache)) hash_table<ipa_bit_ggc_hash_traits> *ipa_bits_hash_table;

111/* Traits for a hash table for reusing value_ranges used for IPA.  Note that
 the equiv bitmap is not hashed and is expected to be NULL.  */

114struct ipa_vr_ggc_hash_traits : public ggc_cache_remove <value_range *>
115{
typedef value_range *value_type;
typedef value_range *compare_type;
static hashval_t
hash (const value_range *p)
  {
    inchash::hash hstate (p->kind ());
    inchash::add_expr (p->min (), hstate);
    inchash::add_expr (p->max (), hstate);
    return hstate.end ();
  }
static bool
equal (const value_range *a, const value_range *b)
  {
    return (types_compatible_p (a->type (), b->type ())
     && *a == *b);
  }
static const bool empty_zero_p = true;
static void
mark_empty (value_range *&p)
  {
    p = NULLnullptr;
  }
static bool
is_empty (const value_range *p)
  {
    return p == NULLnullptr;
  }
static bool
is_deleted (const value_range *p)
  {
    return p == reinterpret_cast<const value_range *> (1);
  }
static void
mark_deleted (value_range *&p)
  {
    p = reinterpret_cast<value_range *> (1);
  }
153};

155/* Hash table for avoid repeated allocations of equal value_ranges.  */
156static GTY ((cache)) hash_table<ipa_vr_ggc_hash_traits> *ipa_vr_hash_table;

158/* Holders of ipa cgraph hooks: */
159static struct cgraph_node_hook_list *function_insertion_hook_holder;

161/* Description of a reference to an IPA constant.  */
162struct ipa_cst_ref_desc
163{
/* Edge that corresponds to the statement which took the reference.  */
struct cgraph_edge *cs;
/* Linked list of duplicates created when call graph edges are cloned.  */
struct ipa_cst_ref_desc *next_duplicate;
/* Number of references in IPA structures, IPA_UNDESCRIBED_USE if the value
   if out of control.  */
int refcount;
171};

173/* Allocation pool for reference descriptions.  */

175static object_allocator<ipa_cst_ref_desc> ipa_refdesc_pool
("IPA-PROP ref descriptions");

178/* Return true if DECL_FUNCTION_SPECIFIC_OPTIMIZATION of the decl associated
 with NODE should prevent us from analyzing it for the purposes of IPA-CP.  */

181static bool
182ipa_func_spec_opts_forbid_analysis_p (struct cgraph_node *node)
183{
tree fs_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 184, __FUNCTION__, (FUNCTION_DECL)))->function_decl.function_specific_optimization
);

if (!fs_opts)
  return false;
return !opt_for_fn (node->decl, optimize)(opts_for_fn (node->decl)->x_optimize) || !opt_for_fn (node->decl, flag_ipa_cp)(opts_for_fn (node->decl)->x_flag_ipa_cp);
189}

191/* Return index of the formal whose tree is PTREE in function which corresponds
 to INFO.  */

194static int
195ipa_get_param_decl_index_1 (vec<ipa_param_descriptor, va_gc> *descriptors,
	    tree ptree)
197{
int i, count;

count = vec_safe_length (descriptors);
for (i = 0; i < count; i++)
  if ((*descriptors)[i].decl_or_type == ptree)
    return i;

return -1;
206}

208/* Return index of the formal whose tree is PTREE in function which corresponds
 to INFO.  */

211int
212ipa_get_param_decl_index (class ipa_node_params *info, tree ptree)
213{
return ipa_get_param_decl_index_1 (info->descriptors, ptree);
215}

217/* Populate the param_decl field in parameter DESCRIPTORS that correspond to
 NODE.  */

220static void
221ipa_populate_param_decls (struct cgraph_node *node,
	  vec<ipa_param_descriptor, va_gc> &descriptors)
223{
tree fndecl;
tree fnargs;
tree parm;
int param_num;

fndecl = node->decl;
gcc_assert (gimple_has_body_p (fndecl))((void)(!(gimple_has_body_p (fndecl)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 230, __FUNCTION__), 0 : 0));
fnargs = DECL_ARGUMENTS (fndecl)((tree_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 231, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
);
param_num = 0;
for (parm = fnargs; parm; parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 233, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 233, __FUNCTION__))->common.chain)))
  {
    descriptors[param_num].decl_or_type = parm;
    unsigned int cost = estimate_move_cost (TREE_TYPE (parm)((contains_struct_check ((parm), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 236, __FUNCTION__))->typed.type), true);
    descriptors[param_num].move_cost = cost;
    /* Watch overflow, move_cost is a bitfield.  */
    gcc_checking_assert (cost == descriptors[param_num].move_cost)((void)(!(cost == descriptors[param_num].move_cost) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 239, __FUNCTION__), 0 : 0));
    param_num++;
  }
242}

244/* Return how many formal parameters FNDECL has.  */

246int
247count_formal_params (tree fndecl)
248{
tree parm;
int count = 0;
gcc_assert (gimple_has_body_p (fndecl))((void)(!(gimple_has_body_p (fndecl)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 251, __FUNCTION__), 0 : 0));

for (parm = DECL_ARGUMENTS (fndecl)((tree_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 253, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
); parm; parm = DECL_CHAIN (parm)(((contains_struct_check (((contains_struct_check ((parm), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 253, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 253, __FUNCTION__))->common.chain)))
  count++;

return count;
257}

259/* Return the declaration of Ith formal parameter of the function corresponding
 to INFO.  Note there is no setter function as this array is built just once
 using ipa_initialize_node_params. */

263void
264ipa_dump_param (FILE *file, class ipa_node_params *info, int i)
265{
fprintf (file, "param #%i", i);
if ((*info->descriptors)[i].decl_or_type)
  {
    fprintf (file, " ");
    print_generic_expr (file, (*info->descriptors)[i].decl_or_type);
  }
272}

274/* If necessary, allocate vector of parameter descriptors in info of NODE.
 Return true if they were allocated, false if not.  */

277static bool
278ipa_alloc_node_params (struct cgraph_node *node, int param_count)
279{
ipa_node_params *info = ipa_node_params_sum->get_create (node);

if (!info->descriptors && param_count)
  {
    vec_safe_grow_cleared (info->descriptors, param_count, true);
    return true;
  }
else
  return false;
289}

291/* Initialize the ipa_node_params structure associated with NODE by counting
 the function parameters, creating the descriptors and populating their
 param_decls.  */

295void
296ipa_initialize_node_params (struct cgraph_node *node)
297{
ipa_node_params *info = ipa_node_params_sum->get_create (node);

if (!info->descriptors
    && ipa_alloc_node_params (node, count_formal_params (node->decl)))
  ipa_populate_param_decls (node, *info->descriptors);
303}

305/* Print the jump functions associated with call graph edge CS to file F.  */

307static void
308ipa_print_node_jump_functions_for_edge (FILE *f, struct cgraph_edge *cs)
309{
ipa_edge_args *args = ipa_edge_args_sum->get (cs);
int count = ipa_get_cs_argument_count (args);

for (int i = 0; i < count; i++)
  {
    struct ipa_jump_func *jump_func;
    enum jump_func_type type;

    jump_func = ipa_get_ith_jump_func (args, i);
    type = jump_func->type;

    fprintf (f, "       param %d: ", i);
    if (type == IPA_JF_UNKNOWN)
fprintf (f, "UNKNOWN\n");
    else if (type == IPA_JF_CONST)
{
 tree val = jump_func->value.constant.value;
 fprintf (f, "CONST: ");
 print_generic_expr (f, val);
 if (TREE_CODE (val)((enum tree_code) (val)->base.code) == ADDR_EXPR
     && TREE_CODE (TREE_OPERAND (val, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((val), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 330, __FUNCTION__))))))->base.code) == CONST_DECL)
   {
     fprintf (f, " -> ");
     print_generic_expr (f, DECL_INITIAL (TREE_OPERAND (val, 0))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 ((val), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 333, __FUNCTION__)))))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 333, __FUNCTION__))->decl_common.initial));
   }
 fprintf (f, "\n");
}
    else if (type == IPA_JF_PASS_THROUGH)
{
 fprintf (f, "PASS THROUGH: ");
 fprintf (f, "%d, op %s",
   jump_func->value.pass_through.formal_id,
   get_tree_code_name(jump_func->value.pass_through.operation));
 if (jump_func->value.pass_through.operation != NOP_EXPR)
   {
     fprintf (f, " ");
     print_generic_expr (f, jump_func->value.pass_through.operand);
   }
 if (jump_func->value.pass_through.agg_preserved)
   fprintf (f, ", agg_preserved");
 fprintf (f, "\n");
}
    else if (type == IPA_JF_ANCESTOR)
{
 fprintf (f, "ANCESTOR: ");
 fprintf (f, "%d, offset " HOST_WIDE_INT_PRINT_DEC"%" "l" "d",
   jump_func->value.ancestor.formal_id,
   jump_func->value.ancestor.offset);
 if (jump_func->value.ancestor.agg_preserved)
   fprintf (f, ", agg_preserved");
 if (jump_func->value.ancestor.keep_null)
   fprintf (f, ", keep_null");
 fprintf (f, "\n");
}

    if (jump_func->agg.items)
{
 struct ipa_agg_jf_item *item;
 int j;

 fprintf (f, "         Aggregate passed by %s:\n",
   jump_func->agg.by_ref ? "reference" : "value");
 FOR_EACH_VEC_ELT (*jump_func->agg.items, j, item)for (j = 0; (*jump_func->agg.items).iterate ((j), &(item
)); ++(j))
   {
     fprintf (f, "           offset: " HOST_WIDE_INT_PRINT_DEC"%" "l" "d" ", ",
       item->offset);
     fprintf (f, "type: ");
     print_generic_expr (f, item->type);
     fprintf (f, ", ");
     if (item->jftype == IPA_JF_PASS_THROUGH)
fprintf (f, "PASS THROUGH: %d,",
	 item->value.pass_through.formal_id);
     else if (item->jftype == IPA_JF_LOAD_AGG)
{
  fprintf (f, "LOAD AGG: %d",
	   item->value.pass_through.formal_id);
  fprintf (f, " [offset: " HOST_WIDE_INT_PRINT_DEC"%" "l" "d" ", by %s],",
	   item->value.load_agg.offset,
	   item->value.load_agg.by_ref ? "reference"
				       : "value");
}

     if (item->jftype == IPA_JF_PASS_THROUGH
  || item->jftype == IPA_JF_LOAD_AGG)
{
  fprintf (f, " op %s",
     get_tree_code_name (item->value.pass_through.operation));
  if (item->value.pass_through.operation != NOP_EXPR)
    {
      fprintf (f, " ");
      print_generic_expr (f, item->value.pass_through.operand);
    }
}
     else if (item->jftype == IPA_JF_CONST)
{
  fprintf (f, "CONST: ");
  print_generic_expr (f, item->value.constant);
}
     else if (item->jftype == IPA_JF_UNKNOWN)
fprintf (f, "UNKNOWN: " HOST_WIDE_INT_PRINT_DEC"%" "l" "d" " bits",
	 tree_to_uhwi (TYPE_SIZE (item->type)((tree_class_check ((item->type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 410, __FUNCTION__))->type_common.size)));
     fprintf (f, "\n");
   }
}

    class ipa_polymorphic_call_context *ctx
= ipa_get_ith_polymorhic_call_context (args, i);
    if (ctx && !ctx->useless_p ())
{
 fprintf (f, "         Context: ");
 ctx->dump (dump_file);
}

    if (jump_func->bits)
{
 fprintf (f, "         value: ");
 print_hex (jump_func->bits->value, f);
 fprintf (f, ", mask: ");
 print_hex (jump_func->bits->mask, f);
 fprintf (f, "\n");
}
    else
fprintf (f, "         Unknown bits\n");

    if (jump_func->m_vr)
{
 fprintf (f, "         VR  ");
 fprintf (f, "%s[",
   (jump_func->m_vr->kind () == VR_ANTI_RANGE) ? "~" : "");
 print_decs (wi::to_wide (jump_func->m_vr->min ()), f);
 fprintf (f, ", ");
 print_decs (wi::to_wide (jump_func->m_vr->max ()), f);
 fprintf (f, "]\n");
}
    else
fprintf (f, "         Unknown VR\n");
  }
447}


450/* Print the jump functions of all arguments on all call graph edges going from
 NODE to file F.  */

453void
454ipa_print_node_jump_functions (FILE *f, struct cgraph_node *node)
455{
struct cgraph_edge *cs;

fprintf (f, "  Jump functions of caller  %s:\n", node->dump_name ());
for (cs = node->callees; cs; cs = cs->next_callee)
  {

    fprintf (f, "    callsite  %s -> %s : \n",
      node->dump_name (),
      cs->callee->dump_name ());
    if (!ipa_edge_args_info_available_for_edge_p (cs))
fprintf (f, "       no arg info\n");
    else
      ipa_print_node_jump_functions_for_edge (f, cs);
  }

for (cs = node->indirect_calls; cs; cs = cs->next_callee)
  {
    class cgraph_indirect_call_info *ii;

    ii = cs->indirect_info;
    if (ii->agg_contents)
fprintf (f, "    indirect %s callsite, calling param %i, "
 "offset " HOST_WIDE_INT_PRINT_DEC"%" "l" "d" ", %s",
 ii->member_ptr ? "member ptr" : "aggregate",
 ii->param_index, ii->offset,
 ii->by_ref ? "by reference" : "by_value");
    else
fprintf (f, "    indirect %s callsite, calling param %i, "
 "offset " HOST_WIDE_INT_PRINT_DEC"%" "l" "d",
 ii->polymorphic ? "polymorphic" : "simple", ii->param_index,
 ii->offset);

    if (cs->call_stmt)
{
 fprintf (f, ", for stmt ");
 print_gimple_stmt (f, cs->call_stmt, 0, TDF_SLIM);
}
    else
fprintf (f, "\n");
    if (ii->polymorphic)
ii->context.dump (f);
    if (!ipa_edge_args_info_available_for_edge_p (cs))
fprintf (f, "       no arg info\n");
    else
      ipa_print_node_jump_functions_for_edge (f, cs);
  }
502}

504/* Print ipa_jump_func data structures of all nodes in the call graph to F.  */

506void
507ipa_print_all_jump_functions (FILE *f)
508{
struct cgraph_node *node;

fprintf (f, "\nJump functions:\n");
FOR_EACH_FUNCTION (node)for ((node) = symtab->first_function (); (node); (node) = symtab
->next_function ((node)))
  {
    ipa_print_node_jump_functions (f, node);
  }
516}

518/* Set jfunc to be a know-really nothing jump function.  */

520static void
521ipa_set_jf_unknown (struct ipa_jump_func *jfunc)
522{
jfunc->type = IPA_JF_UNKNOWN;
524}

526/* Set JFUNC to be a copy of another jmp (to be used by jump function
 combination code).  The two functions will share their rdesc.  */

529static void
530ipa_set_jf_cst_copy (struct ipa_jump_func *dst,
     struct ipa_jump_func *src)

533{
gcc_checking_assert (src->type == IPA_JF_CONST)((void)(!(src->type == IPA_JF_CONST) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 534, __FUNCTION__), 0 : 0));
dst->type = IPA_JF_CONST;
dst->value.constant = src->value.constant;
537}

539/* Set JFUNC to be a constant jmp function.  */

541static void
542ipa_set_jf_constant (struct ipa_jump_func *jfunc, tree constant,
     struct cgraph_edge *cs)
544{
jfunc->type = IPA_JF_CONST;
jfunc->value.constant.value = unshare_expr_without_location (constant);

if (TREE_CODE (constant)((enum tree_code) (constant)->base.code) == ADDR_EXPR
28
←
Assuming field 'code' is not equal to ADDR_EXPR→
    && (TREE_CODE (TREE_OPERAND (constant, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((constant), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 549, __FUNCTION__))))))->base.code) == FUNCTION_DECL
 || (TREE_CODE (TREE_OPERAND (constant, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((constant), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 550, __FUNCTION__))))))->base.code) == VAR_DECL
     && TREE_STATIC (TREE_OPERAND (constant, 0))(((*((const_cast<tree*> (tree_operand_check ((constant)
, (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 551, __FUNCTION__))))))->base.static_flag))))
  {
    struct ipa_cst_ref_desc *rdesc;

    rdesc = ipa_refdesc_pool.allocate ();
    rdesc->cs = cs;
    rdesc->next_duplicate = NULLnullptr;
    rdesc->refcount = 1;
    jfunc->value.constant.rdesc = rdesc;
  }
else
  jfunc->value.constant.rdesc = NULLnullptr;
563}
29
←
Returning without writing to 'jfunc->agg.items'→

565/* Set JFUNC to be a simple pass-through jump function.  */
566static void
567ipa_set_jf_simple_pass_through (struct ipa_jump_func *jfunc, int formal_id,
		bool agg_preserved)
569{
jfunc->type = IPA_JF_PASS_THROUGH;
jfunc->value.pass_through.operand = NULL_TREE(tree) nullptr;
jfunc->value.pass_through.formal_id = formal_id;
jfunc->value.pass_through.operation = NOP_EXPR;
jfunc->value.pass_through.agg_preserved = agg_preserved;
575}

577/* Set JFUNC to be an unary pass through jump function.  */

579static void
580ipa_set_jf_unary_pass_through (struct ipa_jump_func *jfunc, int formal_id,
	       enum tree_code operation)
582{
jfunc->type = IPA_JF_PASS_THROUGH;
jfunc->value.pass_through.operand = NULL_TREE(tree) nullptr;
jfunc->value.pass_through.formal_id = formal_id;
jfunc->value.pass_through.operation = operation;
jfunc->value.pass_through.agg_preserved = false;
588}
589/* Set JFUNC to be an arithmetic pass through jump function.  */

591static void
592ipa_set_jf_arith_pass_through (struct ipa_jump_func *jfunc, int formal_id,
	       tree operand, enum tree_code operation)
594{
jfunc->type = IPA_JF_PASS_THROUGH;
jfunc->value.pass_through.operand = unshare_expr_without_location (operand);
jfunc->value.pass_through.formal_id = formal_id;
jfunc->value.pass_through.operation = operation;
jfunc->value.pass_through.agg_preserved = false;
600}

602/* Set JFUNC to be an ancestor jump function.  */

604static void
605ipa_set_ancestor_jf (struct ipa_jump_func *jfunc, HOST_WIDE_INTlong offset,
     int formal_id, bool agg_preserved, bool keep_null)
607{
jfunc->type = IPA_JF_ANCESTOR;
jfunc->value.ancestor.formal_id = formal_id;
jfunc->value.ancestor.offset = offset;
jfunc->value.ancestor.agg_preserved = agg_preserved;
jfunc->value.ancestor.keep_null = keep_null;
613}

615/* Get IPA BB information about the given BB.  FBI is the context of analyzis
 of this function body.  */

618static struct ipa_bb_info *
619ipa_get_bb_info (struct ipa_func_body_info *fbi, basic_block bb)
620{
gcc_checking_assert (fbi)((void)(!(fbi) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 621, __FUNCTION__), 0 : 0));
return &fbi->bb_infos[bb->index];
623}

625/* Structure to be passed in between detect_type_change and
 check_stmt_for_type_change.  */

628struct prop_type_change_info
629{
/* Offset into the object where there is the virtual method pointer we are
   looking for.  */
HOST_WIDE_INTlong offset;
/* The declaration or SSA_NAME pointer of the base that we are checking for
   type change.  */
tree object;
/* Set to true if dynamic type change has been detected.  */
bool type_maybe_changed;
638};

640/* Return true if STMT can modify a virtual method table pointer.

 This function makes special assumptions about both constructors and
 destructors which are all the functions that are allowed to alter the VMT
 pointers.  It assumes that destructors begin with assignment into all VMT
 pointers and that constructors essentially look in the following way:

 1) The very first thing they do is that they call constructors of ancestor
 sub-objects that have them.

 2) Then VMT pointers of this and all its ancestors is set to new values
 corresponding to the type corresponding to the constructor.

 3) Only afterwards, other stuff such as constructor of member sub-objects
 and the code written by the user is run.  Only this may include calling
 virtual functions, directly or indirectly.

 There is no way to call a constructor of an ancestor sub-object in any
 other way.

 This means that we do not have to care whether constructors get the correct
 type information because they will always change it (in fact, if we define
 the type to be given by the VMT pointer, it is undefined).

 The most important fact to derive from the above is that if, for some
 statement in the section 3, we try to detect whether the dynamic type has
 changed, we can safely ignore all calls as we examine the function body
 backwards until we reach statements in section 2 because these calls cannot
 be ancestor constructors or destructors (if the input is not bogus) and so
 do not change the dynamic type (this holds true only for automatically
 allocated objects but at the moment we devirtualize only these).  We then
 must detect that statements in section 2 change the dynamic type and can try
 to derive the new type.  That is enough and we can stop, we will never see
 the calls into constructors of sub-objects in this code.  Therefore we can
 safely ignore all call statements that we traverse.
*/

677static bool
678stmt_may_be_vtbl_ptr_store (gimple *stmt)
679{
if (is_gimple_call (stmt))
  return false;
if (gimple_clobber_p (stmt))
  return false;
else if (is_gimple_assign (stmt))
  {
    tree lhs = gimple_assign_lhs (stmt);

    if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 688, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 688, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 688, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 688, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
)))
{
 if (flag_strict_aliasingglobal_options.x_flag_strict_aliasing
     && !POINTER_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 691, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 691, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
   return false;

 if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == COMPONENT_REF
     && !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 ((lhs), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 695, __FUNCTION__)))))), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 695, __FUNCTION__))->decl_common.virtual_flag))
   return false;
 /* In the future we might want to use get_ref_base_and_extent to find
    if there is a field corresponding to the offset and if so, proceed
    almost like if it was a component ref.  */
}
  }
return true;
703}

705/* Callback of walk_aliased_vdefs and a helper function for detect_type_change
 to check whether a particular statement may modify the virtual table
 pointerIt stores its result into DATA, which points to a
 prop_type_change_info structure.  */

710static bool
711check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED__attribute__ ((__unused__)), tree vdef, void *data)
712{
gimple *stmt = SSA_NAME_DEF_STMT (vdef)(tree_check ((vdef), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 713, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
struct prop_type_change_info *tci = (struct prop_type_change_info *) data;

if (stmt_may_be_vtbl_ptr_store (stmt))
  {
    tci->type_maybe_changed = true;
    return true;
  }
else
  return false;
723}

725/* See if ARG is PARAM_DECl describing instance passed by pointer
 or reference in FUNCTION.  Return false if the dynamic type may change
 in between beggining of the function until CALL is invoked.

 Generally functions are not allowed to change type of such instances,
 but they call destructors.  We assume that methods cannot destroy the THIS
 pointer.  Also as a special cases, constructor and destructors may change
 type of the THIS pointer.  */

734static bool
735param_type_may_change_p (tree function, tree arg, gimple *call)
736{
/* Pure functions cannot do any changes on the dynamic type;
   that require writting to memory.  */
if (flags_from_decl_or_type (function) & (ECF_PURE(1 << 1) | ECF_CONST(1 << 0)))
  return false;
/* We need to check if we are within inlined consturctor
   or destructor (ideally we would have way to check that the
   inline cdtor is actually working on ARG, but we don't have
   easy tie on this, so punt on all non-pure cdtors.
   We may also record the types of cdtors and once we know type
   of the instance match them.

   Also code unification optimizations may merge calls from
   different blocks making return values unreliable.  So
   do nothing during late optimization.  */
if (DECL_STRUCT_FUNCTION (function)((tree_check ((function), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 751, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f)->after_inlining)
  return true;
if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME
    && SSA_NAME_IS_DEFAULT_DEF (arg)(tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 754, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
    && TREE_CODE (SSA_NAME_VAR (arg))((enum tree_code) (((tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 755, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
 || ((enum tree_code) ((arg)->ssa_name.var)->base.code)
 == IDENTIFIER_NODE ? (tree) nullptr : (arg)->ssa_name.var
))->base.code) == PARM_DECL)
  {
    /* Normal (non-THIS) argument.  */
    if ((SSA_NAME_VAR (arg)((tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 758, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
 || ((enum tree_code) ((arg)->ssa_name.var)->base.code)
 == IDENTIFIER_NODE ? (tree) nullptr : (arg)->ssa_name.var
) != DECL_ARGUMENTS (function)((tree_check ((function), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 758, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
)
  || TREE_CODE (TREE_TYPE (function))((enum tree_code) (((contains_struct_check ((function), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 759, __FUNCTION__))->typed.type))->base.code) != METHOD_TYPE)
 /* THIS pointer of an method - here we want to watch constructors
    and destructors as those definitely may change the dynamic
    type.  */
 || (TREE_CODE (TREE_TYPE (function))((enum tree_code) (((contains_struct_check ((function), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 763, __FUNCTION__))->typed.type))->base.code) == METHOD_TYPE
     && !DECL_CXX_CONSTRUCTOR_P (function)((tree_check ((function), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 764, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_constructor
)
     && !DECL_CXX_DESTRUCTOR_P (function)((tree_check ((function), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 765, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.cxx_destructor
)
     && (SSA_NAME_VAR (arg)((tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 766, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree) nullptr
 || ((enum tree_code) ((arg)->ssa_name.var)->base.code)
 == IDENTIFIER_NODE ? (tree) nullptr : (arg)->ssa_name.var
) == DECL_ARGUMENTS (function)((tree_check ((function), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 766, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
))))
{
 /* Walk the inline stack and watch out for ctors/dtors.  */
 for (tree block = gimple_block (call); block && TREE_CODE (block)((enum tree_code) (block)->base.code) == BLOCK;
      block = BLOCK_SUPERCONTEXT (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 770, __FUNCTION__, (BLOCK)))->block.supercontext))
   if (inlined_polymorphic_ctor_dtor_block_p (block, false))
     return true;
 return false;
}
  }
return true;
777}

779/* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
 callsite CALL) by looking for assignments to its virtual table pointer.  If
 it is, return true.  ARG is the object itself (not a pointer
 to it, unless dereferenced).  BASE is the base of the memory access as
 returned by get_ref_base_and_extent, as is the offset. 

 This is helper function for detect_type_change and detect_type_change_ssa
 that does the heavy work which is usually unnecesary.  */

788static bool
789detect_type_change_from_memory_writes (ipa_func_body_info *fbi, tree arg,
		       tree base, tree comp_type, gcall *call,
		       HOST_WIDE_INTlong offset)
792{
struct prop_type_change_info tci;
ao_ref ao;

gcc_checking_assert (DECL_P (arg)((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (arg)->base.code))] == tcc_declaration
) || ((enum tree_code) (arg)->base.code) == MEM_REF || handled_component_p
 (arg)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 798, __FUNCTION__), 0 : 0))
       || TREE_CODE (arg) == MEM_REF((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (arg)->base.code))] == tcc_declaration
) || ((enum tree_code) (arg)->base.code) == MEM_REF || handled_component_p
 (arg)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 798, __FUNCTION__), 0 : 0))
       || handled_component_p (arg))((void)(!((tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) (arg)->base.code))] == tcc_declaration
) || ((enum tree_code) (arg)->base.code) == MEM_REF || handled_component_p
 (arg)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 798, __FUNCTION__), 0 : 0));

comp_type = TYPE_MAIN_VARIANT (comp_type)((tree_class_check ((comp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 800, __FUNCTION__))->type_common.main_variant);

/* Const calls cannot call virtual methods through VMT and so type changes do
   not matter.  */
if (!flag_devirtualizeglobal_options.x_flag_devirtualize || !gimple_vuse (call)
    /* Be sure expected_type is polymorphic.  */
    || !comp_type
    || TREE_CODE (comp_type)((enum tree_code) (comp_type)->base.code) != RECORD_TYPE
    || !TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type))((tree_check3 ((((tree_class_check ((comp_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 808, __FUNCTION__))->type_common.main_variant)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 808, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)
    || !BINFO_VTABLE (TYPE_BINFO (TYPE_MAIN_VARIANT (comp_type)))((tree_check ((((tree_check3 ((((tree_class_check ((comp_type
), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 809, __FUNCTION__))->type_common.main_variant)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 809, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 809, __FUNCTION__, (TREE_BINFO)))->binfo.vtable))
  return true;

if (fbi->aa_walk_budget == 0)
  return false;

ao_ref_init (&ao, arg);
ao.base = base;
ao.offset = offset;
ao.size = POINTER_SIZE(((global_options.x_ix86_isa_flags & (1UL << 58)) !=
 0) ? 32 : ((8) * (((global_options.x_ix86_isa_flags & (1UL
 << 1)) != 0) ? 8 : 4)));
ao.max_size = ao.size;

tci.offset = offset;
tci.object = get_base_address (arg);
tci.type_maybe_changed = false;

int walked
  = walk_aliased_vdefs (&ao, gimple_vuse (call), check_stmt_for_type_change,
	  &tci, NULLnullptr, NULLnullptr, fbi->aa_walk_budget);
if (walked >= 0)
  fbi->aa_walk_budget -= walked;
else
  fbi->aa_walk_budget = 0;

if (walked >= 0 && !tci.type_maybe_changed)
  return false;

return true;
837}

839/* Detect whether the dynamic type of ARG of COMP_TYPE may have changed.
 If it is, return true.  ARG is the object itself (not a pointer
 to it, unless dereferenced).  BASE is the base of the memory access as
 returned by get_ref_base_and_extent, as is the offset.  */

844static bool
845detect_type_change (ipa_func_body_info *fbi, tree arg, tree base,
    tree comp_type, gcall *call,
    HOST_WIDE_INTlong offset)
848{
if (!flag_devirtualizeglobal_options.x_flag_devirtualize)
  return false;

if (TREE_CODE	(base)((enum tree_code) (base)->base.code) == MEM_REF
    && !param_type_may_change_p (current_function_decl,
		   TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 854, __FUNCTION__))))),
		   call))
  return false;
return detect_type_change_from_memory_writes (fbi, arg, base, comp_type,
				call, offset);
859}

861/* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
 SSA name (its dereference will become the base and the offset is assumed to
 be zero).  */

865static bool
866detect_type_change_ssa (ipa_func_body_info *fbi, tree arg, tree comp_type,
	gcall *call)
868{
gcc_checking_assert (TREE_CODE (arg) == SSA_NAME)((void)(!(((enum tree_code) (arg)->base.code) == SSA_NAME)
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 869, __FUNCTION__), 0 : 0));
if (!flag_devirtualizeglobal_options.x_flag_devirtualize
    || !POINTER_TYPE_P (TREE_TYPE (arg))(((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 871, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 871, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
  return false;

if (!param_type_may_change_p (current_function_decl, arg, call))
  return false;

arg = build2 (MEM_REF, ptr_type_nodeglobal_trees[TI_PTR_TYPE], arg,
build_int_cst (ptr_type_nodeglobal_trees[TI_PTR_TYPE], 0));

return detect_type_change_from_memory_writes (fbi, arg, arg, comp_type,
				call, 0);
882}

884/* Callback of walk_aliased_vdefs.  Flags that it has been invoked to the
 boolean variable pointed to by DATA.  */

887static bool
888mark_modified (ao_ref *ao ATTRIBUTE_UNUSED__attribute__ ((__unused__)), tree vdef ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
     void *data)
890{
bool *b = (bool *) data;
*b = true;
return true;
894}

896/* Find the nearest valid aa status for parameter specified by INDEX that
 dominates BB.  */

899static struct ipa_param_aa_status *
900find_dominating_aa_status (struct ipa_func_body_info *fbi, basic_block bb,
	   int index)
902{
while (true)
  {
    bb = get_immediate_dominator (CDI_DOMINATORS, bb);
    if (!bb)
return NULLnullptr;
    struct ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
    if (!bi->param_aa_statuses.is_empty ()
 && bi->param_aa_statuses[index].valid)
return &bi->param_aa_statuses[index];
  }
913}

915/* Get AA status structure for the given BB and parameter with INDEX.  Allocate
 structures and/or intialize the result with a dominating description as
 necessary.  */

919static struct ipa_param_aa_status *
920parm_bb_aa_status_for_bb (struct ipa_func_body_info *fbi, basic_block bb,
	  int index)
922{
gcc_checking_assert (fbi)((void)(!(fbi) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 923, __FUNCTION__), 0 : 0));
struct ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
if (bi->param_aa_statuses.is_empty ())
  bi->param_aa_statuses.safe_grow_cleared (fbi->param_count, true);
struct ipa_param_aa_status *paa = &bi->param_aa_statuses[index];
if (!paa->valid)
  {
    gcc_checking_assert (!paa->parm_modified((void)(!(!paa->parm_modified && !paa->ref_modified
 && !paa->pt_modified) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 932, __FUNCTION__), 0 : 0))
	   && !paa->ref_modified((void)(!(!paa->parm_modified && !paa->ref_modified
 && !paa->pt_modified) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 932, __FUNCTION__), 0 : 0))
	   && !paa->pt_modified)((void)(!(!paa->parm_modified && !paa->ref_modified
 && !paa->pt_modified) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 932, __FUNCTION__), 0 : 0));
    struct ipa_param_aa_status *dom_paa;
    dom_paa = find_dominating_aa_status (fbi, bb, index);
    if (dom_paa)
*paa = *dom_paa;
    else
paa->valid = true;
  }

return paa;
942}

944/* Return true if a load from a formal parameter PARM_LOAD is known to retrieve
 a value known not to be modified in this function before reaching the
 statement STMT.  FBI holds information about the function we have so far
 gathered but do not survive the summary building stage.  */

949static bool
950parm_preserved_before_stmt_p (struct ipa_func_body_info *fbi, int index,
	      gimple *stmt, tree parm_load)
952{
struct ipa_param_aa_status *paa;
bool modified = false;
ao_ref refd;

tree base = get_base_address (parm_load);
gcc_assert (TREE_CODE (base) == PARM_DECL)((void)(!(((enum tree_code) (base)->base.code) == PARM_DECL
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 958, __FUNCTION__), 0 : 0));
if (TREE_READONLY (base)((non_type_check ((base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 959, __FUNCTION__))->base.readonly_flag))
  return true;

gcc_checking_assert (fbi)((void)(!(fbi) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 962, __FUNCTION__), 0 : 0));
paa = parm_bb_aa_status_for_bb (fbi, gimple_bb (stmt), index);
if (paa->parm_modified || fbi->aa_walk_budget == 0)
  return false;

gcc_checking_assert (gimple_vuse (stmt) != NULL_TREE)((void)(!(gimple_vuse (stmt) != (tree) nullptr) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 967, __FUNCTION__), 0 : 0));
ao_ref_init (&refd, parm_load);
int walked = walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified,
		   &modified, NULLnullptr, NULLnullptr,
		   fbi->aa_walk_budget);
if (walked < 0)
  {
    modified = true;
    fbi->aa_walk_budget = 0;
  }
else
  fbi->aa_walk_budget -= walked;
if (paa && modified)
  paa->parm_modified = true;
return !modified;
982}

984/* If STMT is an assignment that loads a value from an parameter declaration,
 return the index of the parameter in ipa_node_params which has not been
 modified.  Otherwise return -1.  */

988static int
989load_from_unmodified_param (struct ipa_func_body_info *fbi,
	    vec<ipa_param_descriptor, va_gc> *descriptors,
	    gimple *stmt)
992{
int index;
tree op1;

if (!gimple_assign_single_p (stmt))
  return -1;

op1 = gimple_assign_rhs1 (stmt);
if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) != PARM_DECL)
  return -1;

index = ipa_get_param_decl_index_1 (descriptors, op1);
if (index < 0
    || !parm_preserved_before_stmt_p (fbi, index, stmt, op1))
  return -1;

return index;
1009}

1011/* Return true if memory reference REF (which must be a load through parameter
 with INDEX) loads data that are known to be unmodified in this function
 before reaching statement STMT.  */

1015static bool
1016parm_ref_data_preserved_p (struct ipa_func_body_info *fbi,
	   int index, gimple *stmt, tree ref)
1018{
struct ipa_param_aa_status *paa;
bool modified = false;
ao_ref refd;

gcc_checking_assert (fbi)((void)(!(fbi) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1023, __FUNCTION__), 0 : 0));
paa = parm_bb_aa_status_for_bb (fbi, gimple_bb (stmt), index);
if (paa->ref_modified || fbi->aa_walk_budget == 0)
  return false;

gcc_checking_assert (gimple_vuse (stmt))((void)(!(gimple_vuse (stmt)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1028, __FUNCTION__), 0 : 0));
ao_ref_init (&refd, ref);
int walked = walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified,
		   &modified, NULLnullptr, NULLnullptr,
		   fbi->aa_walk_budget);
if (walked < 0)
  {
    modified = true;
    fbi->aa_walk_budget = 0;
  }
else
  fbi->aa_walk_budget -= walked;
if (modified)
  paa->ref_modified = true;
return !modified;
1043}

1045/* Return true if the data pointed to by PARM (which is a parameter with INDEX)
 is known to be unmodified in this function before reaching call statement
 CALL into which it is passed.  FBI describes the function body.  */

1049static bool
1050parm_ref_data_pass_through_p (struct ipa_func_body_info *fbi, int index,
	      gimple *call, tree parm)
1052{
bool modified = false;
ao_ref refd;

/* It's unnecessary to calculate anything about memory contnets for a const
   function because it is not goin to use it.  But do not cache the result
   either.  Also, no such calculations for non-pointers.  */
if (!gimple_vuse (call)
    || !POINTER_TYPE_P (TREE_TYPE (parm))(((enum tree_code) (((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1060, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((parm), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1060, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
  return false;

struct ipa_param_aa_status *paa = parm_bb_aa_status_for_bb (fbi,
					      gimple_bb (call),
					      index);
if (paa->pt_modified || fbi->aa_walk_budget == 0)
  return false;

ao_ref_init_from_ptr_and_size (&refd, parm, NULL_TREE(tree) nullptr);
int walked = walk_aliased_vdefs (&refd, gimple_vuse (call), mark_modified,
		   &modified, NULLnullptr, NULLnullptr,
		   fbi->aa_walk_budget);
if (walked < 0)
  {
    fbi->aa_walk_budget = 0;
    modified = true;
  }
else
  fbi->aa_walk_budget -= walked;
if (modified)
  paa->pt_modified = true;
return !modified;
1083}

1085/* Return true if we can prove that OP is a memory reference loading
 data from an aggregate passed as a parameter.

 The function works in two modes.  If GUARANTEED_UNMODIFIED is NULL, it return
 false if it cannot prove that the value has not been modified before the
 load in STMT.  If GUARANTEED_UNMODIFIED is not NULL, it will return true even
 if it cannot prove the value has not been modified, in that case it will
 store false to *GUARANTEED_UNMODIFIED, otherwise it will store true there.

 INFO and PARMS_AINFO describe parameters of the current function (but the
 latter can be NULL), STMT is the load statement.  If function returns true,
 *INDEX_P, *OFFSET_P and *BY_REF is filled with the parameter index, offset
 within the aggregate and whether it is a load from a value passed by
 reference respectively.

 Return false if the offset divided by BITS_PER_UNIT would not fit into an
 unsigned int.  */

1103bool
1104ipa_load_from_parm_agg (struct ipa_func_body_info *fbi,
	vec<ipa_param_descriptor, va_gc> *descriptors,
	gimple *stmt, tree op, int *index_p,
	HOST_WIDE_INTlong *offset_p, poly_int64 *size_p,
	bool *by_ref_p, bool *guaranteed_unmodified)
1109{
int index;
HOST_WIDE_INTlong size;
bool reverse;
tree base = get_ref_base_and_extent_hwi (op, offset_p, &size, &reverse);

if (!base
    || (*offset_p / BITS_PER_UNIT(8)) > UINT_MAX(2147483647 *2U +1U))
  return false;

/* We can not propagate across volatile loads.  */
if (TREE_THIS_VOLATILE (op)((op)->base.volatile_flag))
  return false;

if (DECL_P (base)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (base)->base.code))] == tcc_declaration))
  {
    int index = ipa_get_param_decl_index_1 (descriptors, base);
    if (index >= 0
 && parm_preserved_before_stmt_p (fbi, index, stmt, op))
{
 *index_p = index;
 *by_ref_p = false;
 if (size_p)
   *size_p = size;
 if (guaranteed_unmodified)
   *guaranteed_unmodified = true;
 return true;
}
    return false;
  }

if (TREE_CODE (base)((enum tree_code) (base)->base.code) != MEM_REF
  || TREE_CODE (TREE_OPERAND (base, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((base), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1141, __FUNCTION__))))))->base.code) != SSA_NAME
  || !integer_zerop (TREE_OPERAND (base, 1)(*((const_cast<tree*> (tree_operand_check ((base), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1142, __FUNCTION__)))))))
  return false;

if (SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base, 0))(tree_check (((*((const_cast<tree*> (tree_operand_check
 ((base), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1145, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1145, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
  {
    tree parm = SSA_NAME_VAR (TREE_OPERAND (base, 0))((tree_check (((*((const_cast<tree*> (tree_operand_check
 ((base), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1147, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1147, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) (((*((const_cast<tree*> (
tree_operand_check ((base), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1147, __FUNCTION__))))))->ssa_name.var)->base.code) ==
 IDENTIFIER_NODE ? (tree) nullptr : ((*((const_cast<tree*>
 (tree_operand_check ((base), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1147, __FUNCTION__))))))->ssa_name.var);
    index = ipa_get_param_decl_index_1 (descriptors, parm);
  }
else
  {
    /* This branch catches situations where a pointer parameter is not a
gimple register, for example:

void hip7(S*) (struct S * p)
{
void (*<T2e4>) (struct S *) D.1867;
struct S * p.1;

<bb 2>:
p.1_1 = p;
D.1867_2 = p.1_1->f;
D.1867_2 ();
gdp = &p;
    */

    gimple *def = SSA_NAME_DEF_STMT (TREE_OPERAND (base, 0))(tree_check (((*((const_cast<tree*> (tree_operand_check
 ((base), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1167, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1167, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
    index = load_from_unmodified_param (fbi, descriptors, def);
  }

if (index >= 0)
  {
    bool data_preserved = parm_ref_data_preserved_p (fbi, index, stmt, op);
    if (!data_preserved && !guaranteed_unmodified)
return false;

    *index_p = index;
    *by_ref_p = true;
    if (size_p)
*size_p = size;
    if (guaranteed_unmodified)
*guaranteed_unmodified = data_preserved;
    return true;
  }
return false;
1186}

1188/* If STMT is an assignment that loads a value from a parameter declaration,
 or from an aggregate passed as the parameter either by value or reference,
 return the index of the parameter in ipa_node_params.  Otherwise return -1.

 FBI holds gathered information about the function.  INFO describes
 parameters of the function, STMT is the assignment statement.  If it is a
 memory load from an aggregate, *OFFSET_P is filled with offset within the
 aggregate, and *BY_REF_P specifies whether the aggregate is passed by
 reference.  */

1198static int
1199load_from_unmodified_param_or_agg (struct ipa_func_body_info *fbi,
		   class ipa_node_params *info,
		   gimple *stmt,
		   HOST_WIDE_INTlong *offset_p,
		   bool *by_ref_p)
1204{
int index = load_from_unmodified_param (fbi, info->descriptors, stmt);
poly_int64 size;

/* Load value from a parameter declaration.  */
if (index >= 0)
  {
    *offset_p = -1;
    return index;
  }

if (!gimple_assign_load_p (stmt))
  return -1;

tree rhs = gimple_assign_rhs1 (stmt);

/* Skip memory reference containing VIEW_CONVERT_EXPR.  */
for (tree t = rhs; handled_component_p (t); t = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1221, __FUNCTION__))))))
  if (TREE_CODE (t)((enum tree_code) (t)->base.code) == VIEW_CONVERT_EXPR)
    return -1;

/* Skip memory reference containing bit-field.  */
if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == BIT_FIELD_REF
    || contains_bitfld_component_ref_p (rhs))
  return -1;

if (!ipa_load_from_parm_agg (fbi, info->descriptors, stmt, rhs, &index,
	       offset_p, &size, by_ref_p))
  return -1;

gcc_assert (!maybe_ne (tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (rhs))),((void)(!(!maybe_ne (tree_to_poly_int64 (((tree_class_check (
(((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1234, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1234, __FUNCTION__))->type_common.size)), size)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1235, __FUNCTION__), 0 : 0))
	 size))((void)(!(!maybe_ne (tree_to_poly_int64 (((tree_class_check (
(((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1234, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1234, __FUNCTION__))->type_common.size)), size)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1235, __FUNCTION__), 0 : 0));
if (!*by_ref_p)
  {
    tree param_type = ipa_get_type (info, index);

    if (!param_type || !AGGREGATE_TYPE_P (param_type)(((enum tree_code) (param_type)->base.code) == ARRAY_TYPE ||
 (((enum tree_code) (param_type)->base.code) == RECORD_TYPE
 || ((enum tree_code) (param_type)->base.code) == UNION_TYPE
 || ((enum tree_code) (param_type)->base.code) == QUAL_UNION_TYPE
)))
return -1;
  }
else if (TREE_THIS_VOLATILE (rhs)((rhs)->base.volatile_flag))
  return -1;

return index;
1247}

1249/* Walk pointer adjustemnts from OP (such as POINTER_PLUS and ADDR_EXPR)
 to find original pointer.  Initialize RET to the pointer which results from
 the walk.
 If offset is known return true and initialize OFFSET_RET.  */

1254bool
1255unadjusted_ptr_and_unit_offset (tree op, tree *ret, poly_int64 *offset_ret)
1256{
poly_int64 offset = 0;
bool offset_known = true;
int i;

for (i = 0; i < param_ipa_jump_function_lookupsglobal_options.x_param_ipa_jump_function_lookups; i++)
  {
    if (TREE_CODE (op)((enum tree_code) (op)->base.code) == ADDR_EXPR)
{
 poly_int64 extra_offset = 0;
 tree base = get_addr_base_and_unit_offset (TREE_OPERAND (op, 0)(*((const_cast<tree*> (tree_operand_check ((op), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1266, __FUNCTION__))))),
				     &offset);
 if (!base)
   {
     base = get_base_address (TREE_OPERAND (op, 0)(*((const_cast<tree*> (tree_operand_check ((op), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1270, __FUNCTION__))))));
     if (TREE_CODE (base)((enum tree_code) (base)->base.code) != MEM_REF)
break;
     offset_known = false;
   }
 else
   {
     if (TREE_CODE (base)((enum tree_code) (base)->base.code) != MEM_REF)
break;
     offset += extra_offset;
   }
 op = TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1281, __FUNCTION__)))));
 if (mem_ref_offset (base).to_shwi (&extra_offset))
   offset += extra_offset;
 else
   offset_known = false;
}
    else if (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME
      && !SSA_NAME_IS_DEFAULT_DEF (op)(tree_check ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1288, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
{
 gimple *pstmt = SSA_NAME_DEF_STMT (op)(tree_check ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1290, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;

 if (gimple_assign_single_p (pstmt))
   op = gimple_assign_rhs1 (pstmt);
 else if (is_gimple_assign (pstmt)
   && gimple_assign_rhs_code (pstmt) == POINTER_PLUS_EXPR)
   {
     poly_int64 extra_offset = 0;
     if (ptrdiff_tree_p (gimple_assign_rhs2 (pstmt),
  &extra_offset))
offset += extra_offset;
     else
offset_known = false;
     op = gimple_assign_rhs1 (pstmt);
   }
 else
   break;
}
    else
break;
  }
*ret = op;
*offset_ret = offset;
return offset_known;
1314}

1316/* Given that an actual argument is an SSA_NAME (given in NAME) and is a result
 of an assignment statement STMT, try to determine whether we are actually
 handling any of the following cases and construct an appropriate jump
 function into JFUNC if so:

 1) The passed value is loaded from a formal parameter which is not a gimple
 register (most probably because it is addressable, the value has to be
 scalar) and we can guarantee the value has not changed.  This case can
 therefore be described by a simple pass-through jump function.  For example:

    foo (int a)
    {
      int a.0;

      a.0_2 = a;
      bar (a.0_2);

 2) The passed value can be described by a simple arithmetic pass-through
 jump function. E.g.

    foo (int a)
    {
      int D.2064;

      D.2064_4 = a.1(D) + 4;
      bar (D.2064_4);

 This case can also occur in combination of the previous one, e.g.:

    foo (int a, int z)
    {
      int a.0;
      int D.2064;

a.0_3 = a;
D.2064_4 = a.0_3 + 4;
foo (D.2064_4);

 3) The passed value is an address of an object within another one (which
 also passed by reference).  Such situations are described by an ancestor
 jump function and describe situations such as:

   B::foo() (struct B * const this)
   {
     struct A * D.1845;

     D.1845_2 = &this_1(D)->D.1748;
     A::bar (D.1845_2);

 INFO is the structure describing individual parameters access different
 stages of IPA optimizations.  PARMS_AINFO contains the information that is
 only needed for intraprocedural analysis.  */

1369static void
1370compute_complex_assign_jump_func (struct ipa_func_body_info *fbi,
		  class ipa_node_params *info,
		  struct ipa_jump_func *jfunc,
		  gcall *call, gimple *stmt, tree name,
		  tree param_type)
1375{
HOST_WIDE_INTlong offset, size;
tree op1, tc_ssa, base, ssa;
bool reverse;
int index;

op1 = gimple_assign_rhs1 (stmt);

if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) == SSA_NAME)
  {
    if (SSA_NAME_IS_DEFAULT_DEF (op1)(tree_check ((op1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1385, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1)((tree_check ((op1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1386, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((op1)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (op1)->ssa_name
.var));
    else
index = load_from_unmodified_param (fbi, info->descriptors,
			    SSA_NAME_DEF_STMT (op1)(tree_check ((op1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1389, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt);
    tc_ssa = op1;
  }
else
  {
    index = load_from_unmodified_param (fbi, info->descriptors, stmt);
    tc_ssa = gimple_assign_lhs (stmt);
  }

if (index >= 0)
  {
    switch (gimple_assign_rhs_class (stmt))
{
case GIMPLE_BINARY_RHS:
 {
   tree op2 = gimple_assign_rhs2 (stmt);
   if (!is_gimple_ip_invariant (op2)
|| ((TREE_CODE_CLASS (gimple_assign_rhs_code (stmt))tree_code_type_tmpl <0>::tree_code_type[(int) (gimple_assign_rhs_code
 (stmt))]
     != tcc_comparison)
    && !useless_type_conversion_p (TREE_TYPE (name)((contains_struct_check ((name), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1408, __FUNCTION__))->typed.type),
				   TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1409, __FUNCTION__))->typed.type))))
     return;

   ipa_set_jf_arith_pass_through (jfunc, index, op2,
			   gimple_assign_rhs_code (stmt));
   break;
 }
case GIMPLE_SINGLE_RHS:
 {
   bool agg_p = parm_ref_data_pass_through_p (fbi, index, call,
				       tc_ssa);
   ipa_set_jf_simple_pass_through (jfunc, index, agg_p);
   break;
 }
case GIMPLE_UNARY_RHS:
 if (!CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))((gimple_assign_rhs_code (stmt)) == NOP_EXPR || (gimple_assign_rhs_code
 (stmt)) == CONVERT_EXPR))
   ipa_set_jf_unary_pass_through (jfunc, index,
			   gimple_assign_rhs_code (stmt));
default:;
}
    return;
  }

if (TREE_CODE (op1)((enum tree_code) (op1)->base.code) != ADDR_EXPR)
  return;
op1 = TREE_OPERAND (op1, 0)(*((const_cast<tree*> (tree_operand_check ((op1), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1434, __FUNCTION__)))));
base = get_ref_base_and_extent_hwi (op1, &offset, &size, &reverse);
offset_int mem_offset;
if (!base
    || TREE_CODE (base)((enum tree_code) (base)->base.code) != MEM_REF
    || !mem_ref_offset (base).is_constant (&mem_offset))
  return;
offset += mem_offset.to_short_addr () * BITS_PER_UNIT(8);
ssa = TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1442, __FUNCTION__)))));
if (TREE_CODE (ssa)((enum tree_code) (ssa)->base.code) != SSA_NAME
    || !SSA_NAME_IS_DEFAULT_DEF (ssa)(tree_check ((ssa), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1444, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
    || offset < 0)
  return;

/* Dynamic types are changed in constructors and destructors.  */
index = ipa_get_param_decl_index (info, SSA_NAME_VAR (ssa)((tree_check ((ssa), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1449, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((ssa)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (ssa)->ssa_name
.var));
if (index >= 0 && param_type && POINTER_TYPE_P (param_type)(((enum tree_code) (param_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (param_type)->base.code) == REFERENCE_TYPE
))
  ipa_set_ancestor_jf (jfunc, offset,  index,
	 parm_ref_data_pass_through_p (fbi, index, call, ssa),
	 false);
1454}

1456/* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
 it looks like:

 iftmp.1_3 = &obj_2(D)->D.1762;

 The base of the MEM_REF must be a default definition SSA NAME of a
 parameter.  Return NULL_TREE if it looks otherwise.  If case of success, the
 whole MEM_REF expression is returned and the offset calculated from any
 handled components and the MEM_REF itself is stored into *OFFSET.  The whole
 RHS stripped off the ADDR_EXPR is stored into *OBJ_P.  */

1467static tree
1468get_ancestor_addr_info (gimple *assign, tree *obj_p, HOST_WIDE_INTlong *offset)
1469{
HOST_WIDE_INTlong size;
tree expr, parm, obj;
bool reverse;

if (!gimple_assign_single_p (assign))
  return NULL_TREE(tree) nullptr;
expr = gimple_assign_rhs1 (assign);

if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) != ADDR_EXPR)
  return NULL_TREE(tree) nullptr;
expr = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1480, __FUNCTION__)))));
obj = expr;
expr = get_ref_base_and_extent_hwi (expr, offset, &size, &reverse);

offset_int mem_offset;
if (!expr
    || TREE_CODE (expr)((enum tree_code) (expr)->base.code) != MEM_REF
    || !mem_ref_offset (expr).is_constant (&mem_offset))
  return NULL_TREE(tree) nullptr;
parm = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1489, __FUNCTION__)))));
if (TREE_CODE (parm)((enum tree_code) (parm)->base.code) != SSA_NAME
    || !SSA_NAME_IS_DEFAULT_DEF (parm)(tree_check ((parm), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1491, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
    || TREE_CODE (SSA_NAME_VAR (parm))((enum tree_code) (((tree_check ((parm), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1492, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((parm)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (parm)->ssa_name
.var))->base.code) != PARM_DECL)
  return NULL_TREE(tree) nullptr;

*offset += mem_offset.to_short_addr () * BITS_PER_UNIT(8);
*obj_p = obj;
return expr;
1498}


1501/* Given that an actual argument is an SSA_NAME that is a result of a phi
 statement PHI, try to find out whether NAME is in fact a
 multiple-inheritance typecast from a descendant into an ancestor of a formal
 parameter and thus can be described by an ancestor jump function and if so,
 write the appropriate function into JFUNC.

 Essentially we want to match the following pattern:

   if (obj_2(D) != 0B)
     goto <bb 3>;
   else
     goto <bb 4>;

 <bb 3>:
   iftmp.1_3 = &obj_2(D)->D.1762;

 <bb 4>:
   # iftmp.1_1 = PHI <iftmp.1_3(3), 0B(2)>
   D.1879_6 = middleman_1 (iftmp.1_1, i_5(D));
   return D.1879_6;  */

1522static void
1523compute_complex_ancestor_jump_func (struct ipa_func_body_info *fbi,
		    class ipa_node_params *info,
		    struct ipa_jump_func *jfunc,
		    gcall *call, gphi *phi)
1527{
HOST_WIDE_INTlong offset;
gimple *assign, *cond;
basic_block phi_bb, assign_bb, cond_bb;
tree tmp, parm, expr, obj;
int index, i;

if (gimple_phi_num_args (phi) != 2)
  return;

if (integer_zerop (PHI_ARG_DEF (phi, 1)gimple_phi_arg_def ((phi), (1))))
  tmp = PHI_ARG_DEF (phi, 0)gimple_phi_arg_def ((phi), (0));
else if (integer_zerop (PHI_ARG_DEF (phi, 0)gimple_phi_arg_def ((phi), (0))))
  tmp = PHI_ARG_DEF (phi, 1)gimple_phi_arg_def ((phi), (1));
else
  return;
if (TREE_CODE (tmp)((enum tree_code) (tmp)->base.code) != SSA_NAME
    || SSA_NAME_IS_DEFAULT_DEF (tmp)(tree_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1544, __FUNCTION__, (SSA_NAME)))->base.default_def_flag
    || !POINTER_TYPE_P (TREE_TYPE (tmp))(((enum tree_code) (((contains_struct_check ((tmp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1545, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((tmp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1545, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
    || TREE_CODE (TREE_TYPE (TREE_TYPE (tmp)))((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((tmp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1546, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1546, __FUNCTION__))->typed.type))->base.code) != RECORD_TYPE)
  return;

assign = SSA_NAME_DEF_STMT (tmp)(tree_check ((tmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1549, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
assign_bb = gimple_bb (assign);
if (!single_pred_p (assign_bb))
  return;
expr = get_ancestor_addr_info (assign, &obj, &offset);
if (!expr)
  return;
parm = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1556, __FUNCTION__)))));
index = ipa_get_param_decl_index (info, SSA_NAME_VAR (parm)((tree_check ((parm), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1557, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((parm)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (parm)->ssa_name
.var));
if (index < 0)
  return;

cond_bb = single_pred (assign_bb);
cond = last_stmt (cond_bb);
if (!cond
    || gimple_code (cond) != GIMPLE_COND
    || gimple_cond_code (cond) != NE_EXPR
    || gimple_cond_lhs (cond) != parm
    || !integer_zerop (gimple_cond_rhs (cond)))
  return;

phi_bb = gimple_bb (phi);
for (i = 0; i < 2; i++)
  {
    basic_block pred = EDGE_PRED (phi_bb, i)(*(phi_bb)->preds)[(i)]->src;
    if (pred != assign_bb && pred != cond_bb)
return;
  }

ipa_set_ancestor_jf (jfunc, offset, index,
       parm_ref_data_pass_through_p (fbi, index, call, parm),
       true);
1581}

1583/* Inspect the given TYPE and return true iff it has the same structure (the
 same number of fields of the same types) as a C++ member pointer.  If
 METHOD_PTR and DELTA are non-NULL, store the trees representing the
 corresponding fields there.  */

1588static bool
1589type_like_member_ptr_p (tree type, tree *method_ptr, tree *delta)
1590{
tree fld;

if (TREE_CODE (type)((enum tree_code) (type)->base.code) != RECORD_TYPE)
  return false;

fld = TYPE_FIELDS (type)((tree_check3 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1596, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values);
if (!fld || !POINTER_TYPE_P (TREE_TYPE (fld))(((enum tree_code) (((contains_struct_check ((fld), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1597, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fld), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1597, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
    || TREE_CODE (TREE_TYPE (TREE_TYPE (fld)))((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((fld), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1598, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1598, __FUNCTION__))->typed.type))->base.code) != METHOD_TYPE
    || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld)((tree_check ((fld), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1599, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)))
  return false;

if (method_ptr)
  *method_ptr = fld;

fld = DECL_CHAIN (fld)(((contains_struct_check (((contains_struct_check ((fld), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1605, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1605, __FUNCTION__))->common.chain));
if (!fld || INTEGRAL_TYPE_P (fld)(((enum tree_code) (fld)->base.code) == ENUMERAL_TYPE || (
(enum tree_code) (fld)->base.code) == BOOLEAN_TYPE || ((enum
 tree_code) (fld)->base.code) == INTEGER_TYPE)
    || !tree_fits_uhwi_p (DECL_FIELD_OFFSET (fld)((tree_check ((fld), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1607, __FUNCTION__, (FIELD_DECL)))->field_decl.offset)))
  return false;
if (delta)
  *delta = fld;

if (DECL_CHAIN (fld)(((contains_struct_check (((contains_struct_check ((fld), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1612, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1612, __FUNCTION__))->common.chain)))
  return false;

return true;
1616}

1618/* If RHS is an SSA_NAME and it is defined by a simple copy assign statement,
 return the rhs of its defining statement, and this statement is stored in
 *RHS_STMT.  Otherwise return RHS as it is.  */

1622static inline tree
1623get_ssa_def_if_simple_copy (tree rhs, gimple **rhs_stmt)
1624{
while (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == SSA_NAME && !SSA_NAME_IS_DEFAULT_DEF (rhs)(tree_check ((rhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1625, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
  {
    gimple *def_stmt = SSA_NAME_DEF_STMT (rhs)(tree_check ((rhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1627, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;

    if (gimple_assign_single_p (def_stmt))
rhs = gimple_assign_rhs1 (def_stmt);
    else
break;
    *rhs_stmt = def_stmt;
  }
return rhs;
1636}

1638/* Simple linked list, describing contents of an aggregate before call.  */

1640struct ipa_known_agg_contents_list
1641{
/* Offset and size of the described part of the aggregate.  */
HOST_WIDE_INTlong offset, size;

/* Type of the described part of the aggregate.  */
tree type;

/* Known constant value or jump function data describing contents.  */
struct ipa_load_agg_data value;

/* Pointer to the next structure in the list.  */
struct ipa_known_agg_contents_list *next;
1653};

1655/* Add an aggregate content item into a linked list of
 ipa_known_agg_contents_list structure, in which all elements
 are sorted ascendingly by offset.  */

1659static inline void
1660add_to_agg_contents_list (struct ipa_known_agg_contents_list **plist,
	  struct ipa_known_agg_contents_list *item)
1662{
struct ipa_known_agg_contents_list *list = *plist;

for (; list; list = list->next)
50
←
Loop condition is false. Execution continues on line 1673→
  {
    if (list->offset >= item->offset)
break;

    plist = &list->next;
  }

item->next = list;
*plist = item;
51
←
The value of 'item' is assigned to 'list', which participates in a condition later→
1675}
52
←
Returning without writing to '(*plist)->value.pass_through.operand', which participates in a condition later→

1677/* Check whether a given aggregate content is clobbered by certain element in
 a linked list of ipa_known_agg_contents_list.  */

1680static inline bool
1681clobber_by_agg_contents_list_p (struct ipa_known_agg_contents_list *list,
		struct ipa_known_agg_contents_list *item)
1683{
for (; list; list = list->next)
  {
    if (list->offset >= item->offset)
return list->offset < item->offset + item->size;

    if (list->offset + list->size > item->offset)
return true;
  }

return false;
1694}

1696/* Build aggregate jump function from LIST, assuming there are exactly
 VALUE_COUNT entries there and that offset of the passed argument
 is ARG_OFFSET and store it into JFUNC.  */

1700static void
1701build_agg_jump_func_from_list (struct ipa_known_agg_contents_list *list,
	       int value_count, HOST_WIDE_INTlong arg_offset,
	       struct ipa_jump_func *jfunc)
1704{
vec_safe_reserve (jfunc->agg.items, value_count, true);
60
←
Calling 'vec_safe_reserve<ipa_agg_jf_item, va_gc>'→
69
←
Returning from 'vec_safe_reserve<ipa_agg_jf_item, va_gc>'→
for (; list; list = list->next)
70
←
Loop condition is true.  Entering loop body→
  {
    struct ipa_agg_jf_item item;
    tree operand = list->value.pass_through.operand;

    if (list->value.pass_through.formal_id70.1
Field 'formal_id' is < 0
1
Field 'formal_id' is < 0
 >= 0)
71
←
Taking false branch→
{
 /* Content value is derived from some formal paramerter.  */
 if (list->value.offset >= 0)
   item.jftype = IPA_JF_LOAD_AGG;
 else
   item.jftype = IPA_JF_PASS_THROUGH;

 item.value.load_agg = list->value;
 if (operand)
   item.value.pass_through.operand
     = unshare_expr_without_location (operand);
}
    else if (operand71.1
'operand' is non-null
1
'operand' is non-null
)
72
←
Taking true branch→
{
 /* Content value is known constant.  */
 item.jftype = IPA_JF_CONST;
 item.value.constant = unshare_expr_without_location (operand);
}
    else
continue;

    item.type = list->type;
    gcc_assert (tree_to_shwi (TYPE_SIZE (list->type)) == list->size)((void)(!(tree_to_shwi (((tree_class_check ((list->type), (
tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1734, __FUNCTION__))->type_common.size)) == list->size
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1734, __FUNCTION__), 0 : 0));
73
←
Assuming the condition is true→
74
←
'?' condition is false→

    item.offset = list->offset - arg_offset;
    gcc_assert ((item.offset % BITS_PER_UNIT) == 0)((void)(!((item.offset % (8)) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1737, __FUNCTION__), 0 : 0));
75
←
Assuming the condition is true→
76
←
'?' condition is false→

    jfunc->agg.items->quick_push (item);
77
←
Called C++ object pointer is null
  }
1741}

1743/* Given an assignment statement STMT, try to collect information into
 AGG_VALUE that will be used to construct jump function for RHS of the
 assignment, from which content value of an aggregate part comes.

 Besides constant and simple pass-through jump functions, also try to
 identify whether it matches the following pattern that can be described by
 a load-value-from-aggregate jump function, which is a derivative of simple
 pass-through jump function.

   foo (int *p)
   {
     ...

     *(q_5 + 4) = *(p_3(D) + 28) op 1;
     bar (q_5);
   }

 Here IPA_LOAD_AGG_DATA data structure is informative enough to describe
 constant, simple pass-through and load-vale-from-aggregate. If value
 is constant, it will be kept in field OPERAND, and field FORMAL_ID is
 set to -1. For simple pass-through and load-value-from-aggregate, field
 FORMAL_ID specifies the related formal parameter index, and field
 OFFSET can be used to distinguish them, -1 means simple pass-through,
 otherwise means load-value-from-aggregate.  */

1768static void
1769analyze_agg_content_value (struct ipa_func_body_info *fbi,
	   struct ipa_load_agg_data *agg_value,
	   gimple *stmt)
1772{
tree lhs = gimple_assign_lhs (stmt);
tree rhs1 = gimple_assign_rhs1 (stmt);
enum tree_code code;
int index = -1;

/* Initialize jump function data for the aggregate part.  */
memset (agg_value, 0, sizeof (*agg_value));
agg_value->pass_through.operation = NOP_EXPR;
agg_value->pass_through.formal_id = -1;
agg_value->offset = -1;

if (AGGREGATE_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1784, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1784, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1784, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1784, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))  /* TODO: Support aggregate type.  */
    || TREE_THIS_VOLATILE (lhs)((lhs)->base.volatile_flag)
    || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == BIT_FIELD_REF
    || contains_bitfld_component_ref_p (lhs))
  return;

/* Skip SSA copies.  */
while (gimple_assign_rhs_class (stmt) == GIMPLE_SINGLE_RHS)
  {
    if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) != SSA_NAME || SSA_NAME_IS_DEFAULT_DEF (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1793, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
break;

    stmt = SSA_NAME_DEF_STMT (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1796, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
    if (!is_gimple_assign (stmt))
break;

    rhs1 = gimple_assign_rhs1 (stmt);
  }

if (gphi *phi = dyn_cast<gphi *> (stmt))
  {
    /* Also special case like the following (a is a formal parameter):

  _12 = *a_11(D).dim[0].stride;
  ...
  # iftmp.22_9 = PHI <_12(2), 1(3)>
  ...
  parm.6.dim[0].stride = iftmp.22_9;
  ...
  __x_MOD_foo (&parm.6, b_31(D));

The aggregate function describing parm.6.dim[0].stride is encoded as a
PASS-THROUGH jump function with ASSERT_EXPR operation whith operand 1
(the constant from the PHI node).  */

    if (gimple_phi_num_args (phi) != 2)
return;
    tree arg0 = gimple_phi_arg_def (phi, 0);
    tree arg1 = gimple_phi_arg_def (phi, 1);
    tree operand;

    if (is_gimple_ip_invariant (arg1))
{
 operand = arg1;
 rhs1 = arg0;
}
    else if (is_gimple_ip_invariant (arg0))
{
 operand = arg0;
 rhs1 = arg1;
}
    else
return;

    rhs1 = get_ssa_def_if_simple_copy (rhs1, &stmt);
    if (!is_gimple_assign (stmt))
return;

    code = ASSERT_EXPR;
    agg_value->pass_through.operand = operand;
  }
else if (is_gimple_assign (stmt))
  {
    code = gimple_assign_rhs_code (stmt);
    switch (gimple_assign_rhs_class (stmt))
{
case GIMPLE_SINGLE_RHS:
 if (is_gimple_ip_invariant (rhs1))
   {
     agg_value->pass_through.operand = rhs1;
     return;
   }
 code = NOP_EXPR;
 break;

case GIMPLE_UNARY_RHS:
 /* NOTE: A GIMPLE_UNARY_RHS operation might not be tcc_unary
    (truth_not_expr is example), GIMPLE_BINARY_RHS does not imply
    tcc_binary, this subtleness is somewhat misleading.

    Since tcc_unary is widely used in IPA-CP code to check an operation
    with one operand, here we only allow tc_unary operation to avoid
    possible problem.  Then we can use (opclass == tc_unary) or not to
    distinguish unary and binary.  */
 if (TREE_CODE_CLASS (code)tree_code_type_tmpl <0>::tree_code_type[(int) (code)] != tcc_unary || CONVERT_EXPR_CODE_P (code)((code) == NOP_EXPR || (code) == CONVERT_EXPR))
   return;

 rhs1 = get_ssa_def_if_simple_copy (rhs1, &stmt);
 break;

case GIMPLE_BINARY_RHS:
 {
   gimple *rhs1_stmt = stmt;
   gimple *rhs2_stmt = stmt;
   tree rhs2 = gimple_assign_rhs2 (stmt);

   rhs1 = get_ssa_def_if_simple_copy (rhs1, &rhs1_stmt);
   rhs2 = get_ssa_def_if_simple_copy (rhs2, &rhs2_stmt);

   if (is_gimple_ip_invariant (rhs2))
     {
agg_value->pass_through.operand = rhs2;
stmt = rhs1_stmt;
     }
   else if (is_gimple_ip_invariant (rhs1))
     {
if (TREE_CODE_CLASS (code)tree_code_type_tmpl <0>::tree_code_type[(int) (code)] == tcc_comparison)
  code = swap_tree_comparison (code);
else if (!commutative_tree_code (code))
  return;

agg_value->pass_through.operand = rhs1;
stmt = rhs2_stmt;
rhs1 = rhs2;
     }
   else
     return;

   if (TREE_CODE_CLASS (code)tree_code_type_tmpl <0>::tree_code_type[(int) (code)] != tcc_comparison
&& !useless_type_conversion_p (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1903, __FUNCTION__))->typed.type),
			       TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1904, __FUNCTION__))->typed.type)))
     return;
 }
 break;

default:
 return;
}
  }
else
  return;

if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) != SSA_NAME)
  index = load_from_unmodified_param_or_agg (fbi, fbi->info, stmt,
			       &agg_value->offset,
			       &agg_value->by_ref);
else if (SSA_NAME_IS_DEFAULT_DEF (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1920, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
  index = ipa_get_param_decl_index (fbi->info, SSA_NAME_VAR (rhs1)((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1921, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((rhs1)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (rhs1)->ssa_name
.var));

if (index >= 0)
  {
    if (agg_value->offset >= 0)
agg_value->type = TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1926, __FUNCTION__))->typed.type);
    agg_value->pass_through.formal_id = index;
    agg_value->pass_through.operation = code;
  }
else
  agg_value->pass_through.operand = NULL_TREE(tree) nullptr;
1932}

1934/* If STMT is a memory store to the object whose address is BASE, extract
 information (offset, size, and value) into CONTENT, and return true,
 otherwise we conservatively assume the whole object is modified with
 unknown content, and return false.  CHECK_REF means that access to object
 is expected to be in form of MEM_REF expression.  */

1940static bool
1941extract_mem_content (struct ipa_func_body_info *fbi,
     gimple *stmt, tree base, bool check_ref,
     struct ipa_known_agg_contents_list *content)
1944{
HOST_WIDE_INTlong lhs_offset, lhs_size;
bool reverse;

if (!is_gimple_assign (stmt))
  return false;

tree lhs = gimple_assign_lhs (stmt);
tree lhs_base = get_ref_base_and_extent_hwi (lhs, &lhs_offset, &lhs_size,
			       &reverse);
if (!lhs_base)
  return false;

if (check_ref)
  {
    if (TREE_CODE (lhs_base)((enum tree_code) (lhs_base)->base.code) != MEM_REF
 || TREE_OPERAND (lhs_base, 0)(*((const_cast<tree*> (tree_operand_check ((lhs_base), (
0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1960, __FUNCTION__))))) != base
 || !integer_zerop (TREE_OPERAND (lhs_base, 1)(*((const_cast<tree*> (tree_operand_check ((lhs_base), (
1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1961, __FUNCTION__)))))))
return false;
  }
else if (lhs_base != base)
  return false;

content->offset = lhs_offset;
content->size = lhs_size;
content->type = TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 1969, __FUNCTION__))->typed.type);
content->next = NULLnullptr;

analyze_agg_content_value (fbi, &content->value, stmt);
return true;
1974}

1976/* Traverse statements from CALL backwards, scanning whether an aggregate given
 in ARG is filled in constants or values that are derived from caller's
 formal parameter in the way described by some kinds of jump functions.  FBI
 is the context of the caller function for interprocedural analysis.  ARG can
 either be an aggregate expression or a pointer to an aggregate.  ARG_TYPE is
 the type of the aggregate, JFUNC is the jump function for the aggregate.  */

1983static void
1984determine_known_aggregate_parts (struct ipa_func_body_info *fbi,
		 gcall *call, tree arg,
		 tree arg_type,
		 struct ipa_jump_func *jfunc)
1988{
struct ipa_known_agg_contents_list *list = NULLnullptr, *all_list = NULLnullptr;
bitmap visited = NULLnullptr;
int item_count = 0, value_count = 0;
HOST_WIDE_INTlong arg_offset, arg_size;
tree arg_base;
bool check_ref, by_ref;
ao_ref r;
int max_agg_items = opt_for_fn (fbi->node->decl, param_ipa_max_agg_items)(opts_for_fn (fbi->node->decl)->x_param_ipa_max_agg_items
);

if (max_agg_items == 0)
34
←
Assuming 'max_agg_items' is not equal to 0→
  return;

/* The function operates in three stages.  First, we prepare check_ref, r,
   arg_base and arg_offset based on what is actually passed as an actual
   argument.  */

if (POINTER_TYPE_P (arg_type)(((enum tree_code) (arg_type)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (arg_type)->base.code) == REFERENCE_TYPE
))
35
←
Taking false branch→
36
←
Taking false branch→
  {
    by_ref = true;
    if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME)
{
 tree type_size;
        if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (arg_type))((tree_class_check ((((contains_struct_check ((arg_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2011, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2011, __FUNCTION__))->type_common.size))
     || !POINTER_TYPE_P (TREE_TYPE (arg))(((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2012, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2012, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
          return;
 check_ref = true;
 arg_base = arg;
 arg_offset = 0;
 type_size = TYPE_SIZE (TREE_TYPE (arg_type))((tree_class_check ((((contains_struct_check ((arg_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2017, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2017, __FUNCTION__))->type_common.size);
 arg_size = tree_to_uhwi (type_size);
 ao_ref_init_from_ptr_and_size (&r, arg_base, NULL_TREE(tree) nullptr);
}
    else if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == ADDR_EXPR)
{
 bool reverse;

 arg = TREE_OPERAND (arg, 0)(*((const_cast<tree*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2025, __FUNCTION__)))));
 arg_base = get_ref_base_and_extent_hwi (arg, &arg_offset,
				  &arg_size, &reverse);
 if (!arg_base)
   return;
 if (DECL_P (arg_base)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (arg_base)->base.code))] == tcc_declaration))
   {
     check_ref = false;
     ao_ref_init (&r, arg_base);
   }
 else
   return;
}
    else
return;
  }
else
  {
    bool reverse;

    gcc_checking_assert (AGGREGATE_TYPE_P (TREE_TYPE (arg)))((void)(!((((enum tree_code) (((contains_struct_check ((arg),
 (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2045, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2045, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2045, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2045, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2045, __FUNCTION__), 0 : 0));
37
←
'?' condition is false→

    by_ref = false;
    check_ref = false;
    arg_base = get_ref_base_and_extent_hwi (arg, &arg_offset,
			      &arg_size, &reverse);
    if (!arg_base)
38
←
Assuming 'arg_base' is non-null→
39
←
Taking false branch→
return;

    ao_ref_init (&r, arg);
  }

/* Second stage traverses virtual SSA web backwards starting from the call
   statement, only looks at individual dominating virtual operand (its
   definition dominates the call), as long as it is confident that content
   of the aggregate is affected by definition of the virtual operand, it
   builds a sorted linked list of ipa_agg_jf_list describing that.  */

for (tree dom_vuse = gimple_vuse (call);
42
←
Loop condition is true.  Entering loop body→
     dom_vuse && fbi->aa_walk_budget > 0;)
40
←
Assuming 'dom_vuse' is non-null→
41
←
Assuming field 'aa_walk_budget' is > 0→
  {
    gimple *stmt = SSA_NAME_DEF_STMT (dom_vuse)(tree_check ((dom_vuse), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2066, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;

    if (gimple_code (stmt) == GIMPLE_PHI)
43
←
Assuming the condition is false→
44
←
Taking false branch→
{
 dom_vuse = get_continuation_for_phi (stmt, &r, true,
			       fbi->aa_walk_budget,
			       &visited, false, NULLnullptr, NULLnullptr);
 continue;
}

    fbi->aa_walk_budget--;
    if (stmt_may_clobber_ref_p_1 (stmt, &r))
45
←
Assuming the condition is true→
46
←
Taking true branch→
{
 struct ipa_known_agg_contents_list *content
	= XALLOCA (struct ipa_known_agg_contents_list)((struct ipa_known_agg_contents_list *) __builtin_alloca(sizeof
 (struct ipa_known_agg_contents_list)));

 if (!extract_mem_content (fbi, stmt, arg_base, check_ref, content))
   break;

 /* Now we get a dominating virtual operand, and need to check
    whether its value is clobbered any other dominating one.  */
 if ((content->value.pass_through.formal_id46.1
Field 'formal_id' is < 0
1
Field 'formal_id' is < 0
 >= 0
48
←
Taking true branch→
      || content->value.pass_through.operand)
47
←
Assuming field 'operand' is non-null→
     && !clobber_by_agg_contents_list_p (all_list, content))
   {
     struct ipa_known_agg_contents_list *copy
	= XALLOCA (struct ipa_known_agg_contents_list)((struct ipa_known_agg_contents_list *) __builtin_alloca(sizeof
 (struct ipa_known_agg_contents_list)));

     /* Add to the list consisting of only dominating virtual
 operands, whose definitions can finally reach the call.  */
     add_to_agg_contents_list (&list, (*copy = *content, copy));
49
←
Calling 'add_to_agg_contents_list'→
53
←
Returning from 'add_to_agg_contents_list'→

     if (++value_count == max_agg_items)
54
←
Assuming the condition is true→
55
←
Taking true branch→
break;
   }

 /* Add to the list consisting of all dominating virtual operands.  */
 add_to_agg_contents_list (&all_list, content);

 if (++item_count == 2 * max_agg_items)
   break;
}
    dom_vuse = gimple_vuse (stmt);
 }

if (visited56.1
'visited' is null
1
'visited' is null
)
56
←
 Execution continues on line 2111→
57
←
Taking false branch→
  BITMAP_FREE (visited)((void) (bitmap_obstack_free ((bitmap) visited), (visited) = (
bitmap) nullptr));

/* Third stage just goes over the list and creates an appropriate vector of
   ipa_agg_jf_item structures out of it, of course only if there are
   any meaningful items to begin with.  */

if (value_count57.1
'value_count' is 1
1
'value_count' is 1
)
58
←
Taking true branch→
  {
    jfunc->agg.by_ref = by_ref;
    build_agg_jump_func_from_list (list, value_count, arg_offset, jfunc);
59
←
Calling 'build_agg_jump_func_from_list'→
  }
2123}


2126/* Return the Ith param type of callee associated with call graph
 edge E.  */

2129tree
2130ipa_get_callee_param_type (struct cgraph_edge *e, int i)
2131{
int n;
tree type = (e->callee
      ? TREE_TYPE (e->callee->decl)((contains_struct_check ((e->callee->decl), (TS_TYPED),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2134, __FUNCTION__))->typed.type)
      : gimple_call_fntype (e->call_stmt));
tree t = TYPE_ARG_TYPES (type)((tree_check2 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2136, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values);

for (n = 0; n < i; n++)
  {
    if (!t)
      break;
    t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2142, __FUNCTION__))->common.chain);
  }
if (t)
  return TREE_VALUE (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2145, __FUNCTION__, (TREE_LIST)))->list.value);
if (!e->callee)
  return NULLnullptr;
t = DECL_ARGUMENTS (e->callee->decl)((tree_check ((e->callee->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2148, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
);
for (n = 0; n < i; n++)
  {
    if (!t)
return NULLnullptr;
    t = TREE_CHAIN (t)((contains_struct_check ((t), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2153, __FUNCTION__))->common.chain);
  }
if (t)
  return TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2156, __FUNCTION__))->typed.type);
return NULLnullptr;
2158}

2160/* Return ipa_bits with VALUE and MASK values, which can be either a newly
 allocated structure or a previously existing one shared with other jump
 functions and/or transformation summaries.  */

2164ipa_bits *
2165ipa_get_ipa_bits_for_value (const widest_int &value, const widest_int &mask)
2166{
ipa_bits tmp;
tmp.value = value;
tmp.mask = mask;

ipa_bits **slot = ipa_bits_hash_table->find_slot (&tmp, INSERT);
if (*slot)
  return *slot;

ipa_bits *res = ggc_alloc<ipa_bits> ();
res->value = value;
res->mask = mask;
*slot = res;

return res;
2181}

2183/* Assign to JF a pointer to ipa_bits structure with VALUE and MASK.  Use hash
 table in order to avoid creating multiple same ipa_bits structures.  */

2186static void
2187ipa_set_jfunc_bits (ipa_jump_func *jf, const widest_int &value,
    const widest_int &mask)
2189{
jf->bits = ipa_get_ipa_bits_for_value (value, mask);
2191}

2193/* Return a pointer to a value_range just like *TMP, but either find it in
 ipa_vr_hash_table or allocate it in GC memory.  TMP->equiv must be NULL.  */

2196static value_range *
2197ipa_get_value_range (value_range *tmp)
2198{
value_range **slot = ipa_vr_hash_table->find_slot (tmp, INSERT);
if (*slot)
  return *slot;

value_range *vr = new (ggc_alloc<value_range> ()) value_range;
*vr = *tmp;
*slot = vr;

return vr;
2208}

2210/* Return a pointer to a value range consisting of TYPE, MIN, MAX and an empty
 equiv set. Use hash table in order to avoid creating multiple same copies of
 value_ranges.  */

2214static value_range *
2215ipa_get_value_range (enum value_range_kind kind, tree min, tree max)
2216{
value_range tmp (min, max, kind);
return ipa_get_value_range (&tmp);
2219}

2221/* Assign to JF a pointer to a value_range structure with TYPE, MIN and MAX and
 a NULL equiv bitmap.  Use hash table in order to avoid creating multiple
 same value_range structures.  */

2225static void
2226ipa_set_jfunc_vr (ipa_jump_func *jf, enum value_range_kind type,
  tree min, tree max)
2228{
jf->m_vr = ipa_get_value_range (type, min, max);
2230}

2232/* Assign to JF a pointer to a value_range just like TMP but either fetch a
 copy from ipa_vr_hash_table or allocate a new on in GC memory.  */

2235static void
2236ipa_set_jfunc_vr (ipa_jump_func *jf, value_range *tmp)
2237{
jf->m_vr = ipa_get_value_range (tmp);
2239}

2241/* Compute jump function for all arguments of callsite CS and insert the
 information in the jump_functions array in the ipa_edge_args corresponding
 to this callsite.  */

2245static void
2246ipa_compute_jump_functions_for_edge (struct ipa_func_body_info *fbi,
		     struct cgraph_edge *cs)
2248{
ipa_node_params *info = ipa_node_params_sum->get (cs->caller);
ipa_edge_args *args = ipa_edge_args_sum->get_create (cs);
gcall *call = cs->call_stmt;
int n, arg_num = gimple_call_num_args (call);
bool useful_context = false;
value_range vr;

if (arg_num == 0 || args->jump_functions)
1
Assuming 'arg_num' is not equal to 0→
2
←
Assuming field 'jump_functions' is null→
3
←
Taking false branch→
  return;
vec_safe_grow_cleared (args->jump_functions, arg_num, true);
if (flag_devirtualizeglobal_options.x_flag_devirtualize)
4
←
Assuming field 'x_flag_devirtualize' is 0→
5
←
Taking false branch→
  vec_safe_grow_cleared (args->polymorphic_call_contexts, arg_num, true);

if (gimple_call_internal_p (call))
6
←
Taking false branch→
  return;
if (ipa_func_spec_opts_forbid_analysis_p (cs->caller))
7
←
Taking false branch→
  return;

for (n = 0; n7.1
'n' is < 'arg_num'
1
'n' is < 'arg_num'
 < arg_num; n++)
8
←
Loop condition is true.  Entering loop body→
  {
    struct ipa_jump_func *jfunc = ipa_get_ith_jump_func (args, n);
    tree arg = gimple_call_arg (call, n);
    tree param_type = ipa_get_callee_param_type (cs, n);
    if (flag_devirtualizeglobal_options.x_flag_devirtualize && POINTER_TYPE_P (TREE_TYPE (arg))(((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2272, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2272, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
9
←
Assuming field 'x_flag_devirtualize' is 0→
{
 tree instance;
 class ipa_polymorphic_call_context context (cs->caller->decl,
				       arg, cs->call_stmt,
				       &instance);
 context.get_dynamic_type (instance, arg, NULLnullptr, cs->call_stmt,
		    &fbi->aa_walk_budget);
 *ipa_get_ith_polymorhic_call_context (args, n) = context;
 if (!context.useless_p ())
   useful_context = true;
}

    if (POINTER_TYPE_P (TREE_TYPE (arg))(((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2285, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2285, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
10
←
Assuming field 'code' is not equal to POINTER_TYPE→
11
←
Assuming field 'code' is not equal to REFERENCE_TYPE→
{
 bool addr_nonzero = false;
 bool strict_overflow = false;

 if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME
     && param_type
     && get_range_query (cfun(cfun + 0))->range_of_expr (vr, arg)
     && vr.nonzero_p ())
   addr_nonzero = true;
 else if (tree_single_nonzero_warnv_p (arg, &strict_overflow))
   addr_nonzero = true;

 if (addr_nonzero)
   {
     tree z = build_int_cst (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2300, __FUNCTION__))->typed.type), 0);
     ipa_set_jfunc_vr (jfunc, VR_ANTI_RANGE, z, z);
   }
 else
   gcc_assert (!jfunc->m_vr)((void)(!(!jfunc->m_vr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2304, __FUNCTION__), 0 : 0));
}
    else
{
 if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME
12
←
Taking false branch→
13
←
Assuming field 'code' is not equal to SSA_NAME→
     && param_type
     /* Limit the ranger query to integral types as the rest
 of this file uses value_range's, which only hold
 integers and pointers.  */
     && irange::supports_p (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2313, __FUNCTION__))->typed.type))
     && get_range_query (cfun(cfun + 0))->range_of_expr (vr, arg)
     && !vr.undefined_p ())
   {
     value_range resvr;
     range_fold_unary_expr (&resvr, NOP_EXPR, param_type,
		     &vr, TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2319, __FUNCTION__))->typed.type));
     if (!resvr.undefined_p () && !resvr.varying_p ())
ipa_set_jfunc_vr (jfunc, &resvr);
     else
gcc_assert (!jfunc->m_vr)((void)(!(!jfunc->m_vr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2323, __FUNCTION__), 0 : 0));
   }
 else
   gcc_assert (!jfunc->m_vr)((void)(!(!jfunc->m_vr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2326, __FUNCTION__), 0 : 0));
14
←
Assuming field 'm_vr' is null→
15
←
'?' condition is false→
}

    if (INTEGRAL_TYPE_P (TREE_TYPE (arg))(((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2329, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2329, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2329, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
16
←
Assuming field 'code' is not equal to ENUMERAL_TYPE→
17
←
Assuming field 'code' is not equal to BOOLEAN_TYPE→
18
←
Assuming field 'code' is not equal to INTEGER_TYPE→
 && (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME || TREE_CODE (arg)((enum tree_code) (arg)->base.code) == INTEGER_CST))
{
 if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME)
   ipa_set_jfunc_bits (jfunc, 0,
		widest_int::from (get_nonzero_bits (arg),
				  TYPE_SIGN (TREE_TYPE (arg))((signop) ((tree_class_check ((((contains_struct_check ((arg)
, (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2335, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2335, __FUNCTION__))->base.u.bits.unsigned_flag))));
 else
   ipa_set_jfunc_bits (jfunc, wi::to_widest (arg), 0);
}
    else if (POINTER_TYPE_P (TREE_TYPE (arg))(((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2339, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2339, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
19
←
Taking false branch→
{
 unsigned HOST_WIDE_INTlong bitpos;
 unsigned align;

 get_pointer_alignment_1 (arg, &align, &bitpos);
 widest_int mask = wi::bit_and_not
   (wi::mask<widest_int> (TYPE_PRECISION (TREE_TYPE (arg))((tree_class_check ((((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2346, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2346, __FUNCTION__))->type_common.precision), false),
    align / BITS_PER_UNIT(8) - 1);
 widest_int value = bitpos / BITS_PER_UNIT(8);
 ipa_set_jfunc_bits (jfunc, value, mask);
}
    else
gcc_assert (!jfunc->bits)((void)(!(!jfunc->bits) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2352, __FUNCTION__), 0 : 0));
20
←
Assuming field 'bits' is null→
21
←
'?' condition is false→

    if (is_gimple_ip_invariant (arg)
22
←
Assuming the condition is false→
26
←
Taking true branch→
 || (VAR_P (arg)(((enum tree_code) (arg)->base.code) == VAR_DECL)
23
←
Assuming field 'code' is equal to VAR_DECL→
     && is_global_var (arg)
24
←
Assuming the condition is true→
     && TREE_READONLY (arg)((non_type_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2357, __FUNCTION__))->base.readonly_flag)))
25
←
Assuming field 'readonly_flag' is not equal to 0→
ipa_set_jf_constant (jfunc, arg, cs);
27
←
Calling 'ipa_set_jf_constant'→
30
←
Returning from 'ipa_set_jf_constant'→
    else if (!is_gimple_reg_type (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2359, __FUNCTION__))->typed.type))
      && TREE_CODE (arg)((enum tree_code) (arg)->base.code) == PARM_DECL)
{
 int index = ipa_get_param_decl_index (info, arg);

 gcc_assert (index >=0)((void)(!(index >=0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2364, __FUNCTION__), 0 : 0));
 /* Aggregate passed by value, check for pass-through, otherwise we
    will attempt to fill in aggregate contents later in this
    for cycle.  */
 if (parm_preserved_before_stmt_p (fbi, index, call, arg))
   {
     ipa_set_jf_simple_pass_through (jfunc, index, false);
     continue;
   }
}
    else if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == SSA_NAME)
{
 if (SSA_NAME_IS_DEFAULT_DEF (arg)(tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2376, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
   {
     int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg)((tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2378, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((arg)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (arg)->ssa_name
.var));
     if (index >= 0)
{
  bool agg_p;
  agg_p = parm_ref_data_pass_through_p (fbi, index, call, arg);
  ipa_set_jf_simple_pass_through (jfunc, index, agg_p);
}
   }
 else
   {
     gimple *stmt = SSA_NAME_DEF_STMT (arg)(tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2388, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
     if (is_gimple_assign (stmt))
compute_complex_assign_jump_func (fbi, info, jfunc,
				  call, stmt, arg, param_type);
     else if (gimple_code (stmt) == GIMPLE_PHI)
compute_complex_ancestor_jump_func (fbi, info, jfunc,
				    call,
				    as_a <gphi *> (stmt));
   }
}

    /* If ARG is pointer, we cannot use its type to determine the type of aggregate
passed (because type conversions are ignored in gimple).  Usually we can
safely get type from function declaration, but in case of K&R prototypes or
variadic functions we can try our luck with type of the pointer passed.
TODO: Since we look for actual initialization of the memory object, we may better
work out the type based on the memory stores we find.  */
    if (!param_type30.1
'param_type' is null
1
'param_type' is null
)
31
←
Taking true branch→
param_type = TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2406, __FUNCTION__))->typed.type);

    if ((jfunc->type31.1
Field 'type' is not equal to IPA_JF_PASS_THROUGH
1
Field 'type' is not equal to IPA_JF_PASS_THROUGH
 != IPA_JF_PASS_THROUGH
     || !ipa_get_jf_pass_through_agg_preserved (jfunc))
 && (jfunc->type31.2
Field 'type' is not equal to IPA_JF_ANCESTOR
2
Field 'type' is not equal to IPA_JF_ANCESTOR
 != IPA_JF_ANCESTOR
     || !ipa_get_jf_ancestor_agg_preserved (jfunc))
 && (AGGREGATE_TYPE_P (TREE_TYPE (arg))(((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2412, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2412, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2412, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((arg), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2412, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))
32
←
Assuming field 'code' is equal to ARRAY_TYPE→
     || POINTER_TYPE_P (param_type)(((enum tree_code) (param_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (param_type)->base.code) == REFERENCE_TYPE
)))
determine_known_aggregate_parts (fbi, call, arg, param_type, jfunc);
33
←
Calling 'determine_known_aggregate_parts'→
  }
if (!useful_context)
  vec_free (args->polymorphic_call_contexts);
2418}

2420/* Compute jump functions for all edges - both direct and indirect - outgoing
 from BB.  */

2423static void
2424ipa_compute_jump_functions_for_bb (struct ipa_func_body_info *fbi, basic_block bb)
2425{
struct ipa_bb_info *bi = ipa_get_bb_info (fbi, bb);
int i;
struct cgraph_edge *cs;

FOR_EACH_VEC_ELT_REVERSE (bi->cg_edges, i, cs)for (i = (bi->cg_edges).length () - 1; (bi->cg_edges).iterate
 ((i), &(cs)); (i)--)
  {
    struct cgraph_node *callee = cs->callee;

    if (callee)
{
 callee = callee->ultimate_alias_target ();
 /* We do not need to bother analyzing calls to unknown functions
    unless they may become known during lto/whopr.  */
 if (!callee->definition && !flag_ltoglobal_options.x_flag_lto
     && !gimple_call_fnspec (cs->call_stmt).known_p ())
   continue;
}
    ipa_compute_jump_functions_for_edge (fbi, cs);
  }
2445}

2447/* If STMT looks like a statement loading a value from a member pointer formal
 parameter, return that parameter and store the offset of the field to
 *OFFSET_P, if it is non-NULL.  Otherwise return NULL (but *OFFSET_P still
 might be clobbered).  If USE_DELTA, then we look for a use of the delta
 field rather than the pfn.  */

2453static tree
2454ipa_get_stmt_member_ptr_load_param (gimple *stmt, bool use_delta,
		    HOST_WIDE_INTlong *offset_p)
2456{
tree rhs, rec, ref_field, ref_offset, fld, ptr_field, delta_field;

if (!gimple_assign_single_p (stmt))
  return NULL_TREE(tree) nullptr;

rhs = gimple_assign_rhs1 (stmt);
if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) == COMPONENT_REF)
  {
    ref_field = TREE_OPERAND (rhs, 1)(*((const_cast<tree*> (tree_operand_check ((rhs), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2465, __FUNCTION__)))));
    rhs = TREE_OPERAND (rhs, 0)(*((const_cast<tree*> (tree_operand_check ((rhs), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2466, __FUNCTION__)))));
  }
else
  ref_field = NULL_TREE(tree) nullptr;
if (TREE_CODE (rhs)((enum tree_code) (rhs)->base.code) != MEM_REF)
  return NULL_TREE(tree) nullptr;
rec = TREE_OPERAND (rhs, 0)(*((const_cast<tree*> (tree_operand_check ((rhs), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2472, __FUNCTION__)))));
if (TREE_CODE (rec)((enum tree_code) (rec)->base.code) != ADDR_EXPR)
  return NULL_TREE(tree) nullptr;
rec = TREE_OPERAND (rec, 0)(*((const_cast<tree*> (tree_operand_check ((rec), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2475, __FUNCTION__)))));
if (TREE_CODE (rec)((enum tree_code) (rec)->base.code) != PARM_DECL
    || !type_like_member_ptr_p (TREE_TYPE (rec)((contains_struct_check ((rec), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2477, __FUNCTION__))->typed.type), &ptr_field, &delta_field))
  return NULL_TREE(tree) nullptr;
ref_offset = TREE_OPERAND (rhs, 1)(*((const_cast<tree*> (tree_operand_check ((rhs), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2479, __FUNCTION__)))));

if (use_delta)
  fld = delta_field;
else
  fld = ptr_field;
if (offset_p)
  *offset_p = int_bit_position (fld);

if (ref_field)
  {
    if (integer_nonzerop (ref_offset))
return NULL_TREE(tree) nullptr;
    return ref_field == fld ? rec : NULL_TREE(tree) nullptr;
  }
else
  return tree_int_cst_equal (byte_position (fld), ref_offset) ? rec
    : NULL_TREE(tree) nullptr;
2497}

2499/* Returns true iff T is an SSA_NAME defined by a statement.  */

2501static bool
2502ipa_is_ssa_with_stmt_def (tree t)
2503{
if (TREE_CODE (t)((enum tree_code) (t)->base.code) == SSA_NAME
    && !SSA_NAME_IS_DEFAULT_DEF (t)(tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2505, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
  return true;
else
  return false;
2509}

2511/* Find the indirect call graph edge corresponding to STMT and mark it as a
 call to a parameter number PARAM_INDEX.  NODE is the caller.  Return the
 indirect call graph edge.
 If POLYMORPHIC is true record is as a destination of polymorphic call.  */

2516static struct cgraph_edge *
2517ipa_note_param_call (struct cgraph_node *node, int param_index,
     gcall *stmt, bool polymorphic)
2519{
struct cgraph_edge *cs;

cs = node->get_edge (stmt);
cs->indirect_info->param_index = param_index;
cs->indirect_info->agg_contents = 0;
cs->indirect_info->member_ptr = 0;
cs->indirect_info->guaranteed_unmodified = 0;
ipa_node_params *info = ipa_node_params_sum->get (node);
ipa_set_param_used_by_indirect_call (info, param_index, true);
if (cs->indirect_info->polymorphic || polymorphic)
  ipa_set_param_used_by_polymorphic_call (info, param_index, true);
return cs;
2532}

2534/* Analyze the CALL and examine uses of formal parameters of the caller NODE
 (described by INFO).  PARMS_AINFO is a pointer to a vector containing
 intermediate information about each formal parameter.  Currently it checks
 whether the call calls a pointer that is a formal parameter and if so, the
 parameter is marked with the called flag and an indirect call graph edge
 describing the call is created.  This is very simple for ordinary pointers
 represented in SSA but not-so-nice when it comes to member pointers.  The
 ugly part of this function does nothing more than trying to match the
 pattern of such a call.  An example of such a pattern is the gimple dump
 below, the call is on the last line:

   <bb 2>:
     f$__delta_5 = f.__delta;
     f$__pfn_24 = f.__pfn;

 or
   <bb 2>:
     f$__delta_5 = MEM[(struct  *)&f];
     f$__pfn_24 = MEM[(struct  *)&f + 4B];

 and a few lines below:

   <bb 5>
     D.2496_3 = (int) f$__pfn_24;
     D.2497_4 = D.2496_3 & 1;
     if (D.2497_4 != 0)
       goto <bb 3>;
     else
       goto <bb 4>;

   <bb 6>:
     D.2500_7 = (unsigned int) f$__delta_5;
     D.2501_8 = &S + D.2500_7;
     D.2502_9 = (int (*__vtbl_ptr_type) (void) * *) D.2501_8;
     D.2503_10 = *D.2502_9;
     D.2504_12 = f$__pfn_24 + -1;
     D.2505_13 = (unsigned int) D.2504_12;
     D.2506_14 = D.2503_10 + D.2505_13;
     D.2507_15 = *D.2506_14;
     iftmp.11_16 = (String:: *) D.2507_15;

   <bb 7>:
     # iftmp.11_1 = PHI <iftmp.11_16(3), f$__pfn_24(2)>
     D.2500_19 = (unsigned int) f$__delta_5;
     D.2508_20 = &S + D.2500_19;
     D.2493_21 = iftmp.11_1 (D.2508_20, 4);

 Such patterns are results of simple calls to a member pointer:

   int doprinting (int (MyString::* f)(int) const)
   {
     MyString S ("somestring");

     return (S.*f)(4);
   }

 Moreover, the function also looks for called pointers loaded from aggregates
 passed by value or reference.  */

2593static void
2594ipa_analyze_indirect_call_uses (struct ipa_func_body_info *fbi, gcall *call,
		tree target)
2596{
class ipa_node_params *info = fbi->info;
HOST_WIDE_INTlong offset;
bool by_ref;

if (SSA_NAME_IS_DEFAULT_DEF (target)(tree_check ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2601, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
  {
    tree var = SSA_NAME_VAR (target)((tree_check ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2603, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((target)->ssa_name.var)->
base.code) == IDENTIFIER_NODE ? (tree) nullptr : (target)->
ssa_name.var);
    int index = ipa_get_param_decl_index (info, var);
    if (index >= 0)
ipa_note_param_call (fbi->node, index, call, false);
    return;
  }

int index;
gimple *def = SSA_NAME_DEF_STMT (target)(tree_check ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2611, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
bool guaranteed_unmodified;
if (gimple_assign_single_p (def)
    && ipa_load_from_parm_agg (fbi, info->descriptors, def,
		 gimple_assign_rhs1 (def), &index, &offset,
		 NULLnullptr, &by_ref, &guaranteed_unmodified))
  {
    struct cgraph_edge *cs = ipa_note_param_call (fbi->node, index,
					    call, false);
    cs->indirect_info->offset = offset;
    cs->indirect_info->agg_contents = 1;
    cs->indirect_info->by_ref = by_ref;
    cs->indirect_info->guaranteed_unmodified = guaranteed_unmodified;
    return;
  }

/* Now we need to try to match the complex pattern of calling a member
   pointer. */
if (gimple_code (def) != GIMPLE_PHI
    || gimple_phi_num_args (def) != 2
    || !POINTER_TYPE_P (TREE_TYPE (target))(((enum tree_code) (((contains_struct_check ((target), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2631, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((target), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2631, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
    || TREE_CODE (TREE_TYPE (TREE_TYPE (target)))((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((target), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2632, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2632, __FUNCTION__))->typed.type))->base.code) != METHOD_TYPE)
  return;

/* First, we need to check whether one of these is a load from a member
   pointer that is a parameter to this function. */
tree n1 = PHI_ARG_DEF (def, 0)gimple_phi_arg_def ((def), (0));
tree n2 = PHI_ARG_DEF (def, 1)gimple_phi_arg_def ((def), (1));
if (!ipa_is_ssa_with_stmt_def (n1) || !ipa_is_ssa_with_stmt_def (n2))
  return;
gimple *d1 = SSA_NAME_DEF_STMT (n1)(tree_check ((n1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2641, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
gimple *d2 = SSA_NAME_DEF_STMT (n2)(tree_check ((n2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2642, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;

tree rec;
basic_block bb, virt_bb;
basic_block join = gimple_bb (def);
if ((rec = ipa_get_stmt_member_ptr_load_param (d1, false, &offset)))
  {
    if (ipa_get_stmt_member_ptr_load_param (d2, false, NULLnullptr))
return;

    bb = EDGE_PRED (join, 0)(*(join)->preds)[(0)]->src;
    virt_bb = gimple_bb (d2);
  }
else if ((rec = ipa_get_stmt_member_ptr_load_param (d2, false, &offset)))
  {
    bb = EDGE_PRED (join, 1)(*(join)->preds)[(1)]->src;
    virt_bb = gimple_bb (d1);
  }
else
  return;

/* Second, we need to check that the basic blocks are laid out in the way
   corresponding to the pattern. */

if (!single_pred_p (virt_bb) || !single_succ_p (virt_bb)
    || single_pred (virt_bb) != bb
    || single_succ (virt_bb) != join)
  return;

/* Third, let's see that the branching is done depending on the least
   significant bit of the pfn. */

gimple *branch = last_stmt (bb);
if (!branch || gimple_code (branch) != GIMPLE_COND)
  return;

if ((gimple_cond_code (branch) != NE_EXPR
     && gimple_cond_code (branch) != EQ_EXPR)
    || !integer_zerop (gimple_cond_rhs (branch)))
  return;

tree cond = gimple_cond_lhs (branch);
if (!ipa_is_ssa_with_stmt_def (cond))
  return;

def = SSA_NAME_DEF_STMT (cond)(tree_check ((cond), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2687, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
if (!is_gimple_assign (def)
    || gimple_assign_rhs_code (def) != BIT_AND_EXPR
    || !integer_onep (gimple_assign_rhs2 (def)))
  return;

cond = gimple_assign_rhs1 (def);
if (!ipa_is_ssa_with_stmt_def (cond))
  return;

def = SSA_NAME_DEF_STMT (cond)(tree_check ((cond), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2697, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;

if (is_gimple_assign (def)
    && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def))((gimple_assign_rhs_code (def)) == NOP_EXPR || (gimple_assign_rhs_code
 (def)) == CONVERT_EXPR))
  {
    cond = gimple_assign_rhs1 (def);
    if (!ipa_is_ssa_with_stmt_def (cond))
return;
    def = SSA_NAME_DEF_STMT (cond)(tree_check ((cond), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2705, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
  }

tree rec2;
rec2 = ipa_get_stmt_member_ptr_load_param (def,
			     (TARGET_PTRMEMFUNC_VBIT_LOCATIONptrmemfunc_vbit_in_pfn
			      == ptrmemfunc_vbit_in_delta),
			     NULLnullptr);
if (rec != rec2)
  return;

index = ipa_get_param_decl_index (info, rec);
if (index >= 0
    && parm_preserved_before_stmt_p (fbi, index, call, rec))
  {
    struct cgraph_edge *cs = ipa_note_param_call (fbi->node, index,
					    call, false);
    cs->indirect_info->offset = offset;
    cs->indirect_info->agg_contents = 1;
    cs->indirect_info->member_ptr = 1;
    cs->indirect_info->guaranteed_unmodified = 1;
  }

return;
2729}

2731/* Analyze a CALL to an OBJ_TYPE_REF which is passed in TARGET and if the
 object referenced in the expression is a formal parameter of the caller
 FBI->node (described by FBI->info), create a call note for the
 statement.  */

2736static void
2737ipa_analyze_virtual_call_uses (struct ipa_func_body_info *fbi,
	       gcall *call, tree target)
2739{
tree obj = OBJ_TYPE_REF_OBJECT (target)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2740, __FUNCTION__, (OBJ_TYPE_REF)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2740, __FUNCTION__)))));
int index;
HOST_WIDE_INTlong anc_offset;

if (!flag_devirtualizeglobal_options.x_flag_devirtualize)
  return;

if (TREE_CODE (obj)((enum tree_code) (obj)->base.code) != SSA_NAME)
  return;

class ipa_node_params *info = fbi->info;
if (SSA_NAME_IS_DEFAULT_DEF (obj)(tree_check ((obj), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2751, __FUNCTION__, (SSA_NAME)))->base.default_def_flag)
  {
    if (TREE_CODE (SSA_NAME_VAR (obj))((enum tree_code) (((tree_check ((obj), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2753, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((obj)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (obj)->ssa_name
.var))->base.code) != PARM_DECL)
return;

    anc_offset = 0;
    index = ipa_get_param_decl_index (info, SSA_NAME_VAR (obj)((tree_check ((obj), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2757, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((obj)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (obj)->ssa_name
.var));
    gcc_assert (index >= 0)((void)(!(index >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2758, __FUNCTION__), 0 : 0));
    if (detect_type_change_ssa (fbi, obj, obj_type_ref_class (target),
		  call))
return;
  }
else
  {
    gimple *stmt = SSA_NAME_DEF_STMT (obj)(tree_check ((obj), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2765, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
    tree expr;

    expr = get_ancestor_addr_info (stmt, &obj, &anc_offset);
    if (!expr)
return;
    index = ipa_get_param_decl_index (info,
			SSA_NAME_VAR (TREE_OPERAND (expr, 0))((tree_check (((*((const_cast<tree*> (tree_operand_check
 ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2772, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2772, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) (((*((const_cast<tree*> (
tree_operand_check ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2772, __FUNCTION__))))))->ssa_name.var)->base.code) ==
 IDENTIFIER_NODE ? (tree) nullptr : ((*((const_cast<tree*>
 (tree_operand_check ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2772, __FUNCTION__))))))->ssa_name.var));
    gcc_assert (index >= 0)((void)(!(index >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2773, __FUNCTION__), 0 : 0));
    if (detect_type_change (fbi, obj, expr, obj_type_ref_class (target),
	      call, anc_offset))
return;
  }

struct cgraph_edge *cs = ipa_note_param_call (fbi->node, index,
   						call, true);
class cgraph_indirect_call_info *ii = cs->indirect_info;
ii->offset = anc_offset;
ii->otr_token = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (target)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2783, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2783, __FUNCTION__))))));
ii->otr_type = obj_type_ref_class (target);
ii->polymorphic = 1;
2786}

2788/* Analyze a call statement CALL whether and how it utilizes formal parameters
 of the caller (described by INFO).  PARMS_AINFO is a pointer to a vector
 containing intermediate information about each formal parameter.  */

2792static void
2793ipa_analyze_call_uses (struct ipa_func_body_info *fbi, gcall *call)
2794{
tree target = gimple_call_fn (call);

if (!target
    || (TREE_CODE (target)((enum tree_code) (target)->base.code) != SSA_NAME
        && !virtual_method_call_p (target)))
  return;

struct cgraph_edge *cs = fbi->node->get_edge (call);
/* If we previously turned the call into a direct call, there is
   no need to analyze.  */
if (cs && !cs->indirect_unknown_callee)
  return;

if (cs->indirect_info->polymorphic && flag_devirtualizeglobal_options.x_flag_devirtualize)
  {
    tree instance;
    tree target = gimple_call_fn (call);
    ipa_polymorphic_call_context context (current_function_decl,
			    target, call, &instance);

    gcc_checking_assert (cs->indirect_info->otr_type((void)(!(cs->indirect_info->otr_type == obj_type_ref_class
 (target)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2816, __FUNCTION__), 0 : 0))
	   == obj_type_ref_class (target))((void)(!(cs->indirect_info->otr_type == obj_type_ref_class
 (target)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2816, __FUNCTION__), 0 : 0));
    gcc_checking_assert (cs->indirect_info->otr_token((void)(!(cs->indirect_info->otr_token == tree_to_shwi (
(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2818, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2818, __FUNCTION__))))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2818, __FUNCTION__), 0 : 0))
	   == tree_to_shwi (OBJ_TYPE_REF_TOKEN (target)))((void)(!(cs->indirect_info->otr_token == tree_to_shwi (
(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2818, __FUNCTION__, (OBJ_TYPE_REF)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2818, __FUNCTION__))))))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2818, __FUNCTION__), 0 : 0));

    cs->indirect_info->vptr_changed
= !context.get_dynamic_type (instance,
		     OBJ_TYPE_REF_OBJECT (target)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2822, __FUNCTION__, (OBJ_TYPE_REF)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2822, __FUNCTION__))))),
		     obj_type_ref_class (target), call,
		     &fbi->aa_walk_budget);
    cs->indirect_info->context = context;
  }

if (TREE_CODE (target)((enum tree_code) (target)->base.code) == SSA_NAME)
  ipa_analyze_indirect_call_uses (fbi, call, target);
else if (virtual_method_call_p (target))
  ipa_analyze_virtual_call_uses (fbi, call, target);
2832}


2835/* Analyze the call statement STMT with respect to formal parameters (described
 in INFO) of caller given by FBI->NODE.  Currently it only checks whether
 formal parameters are called.  */

2839static void
2840ipa_analyze_stmt_uses (struct ipa_func_body_info *fbi, gimple *stmt)
2841{
if (is_gimple_call (stmt))
  ipa_analyze_call_uses (fbi, as_a <gcall *> (stmt));
2844}

2846/* Callback of walk_stmt_load_store_addr_ops for the visit_load.
 If OP is a parameter declaration, mark it as used in the info structure
 passed in DATA.  */

2850static bool
2851visit_ref_for_mod_analysis (gimple *, tree op, tree, void *data)
2852{
class ipa_node_params *info = (class ipa_node_params *) data;

op = get_base_address (op);
if (op
    && TREE_CODE (op)((enum tree_code) (op)->base.code) == PARM_DECL)
  {
    int index = ipa_get_param_decl_index (info, op);
    gcc_assert (index >= 0)((void)(!(index >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2860, __FUNCTION__), 0 : 0));
    ipa_set_param_used (info, index, true);
  }

return false;
2865}

2867/* Scan the statements in BB and inspect the uses of formal parameters.  Store
 the findings in various structures of the associated ipa_node_params
 structure, such as parameter flags, notes etc.  FBI holds various data about
 the function being analyzed.  */

2872static void
2873ipa_analyze_params_uses_in_bb (struct ipa_func_body_info *fbi, basic_block bb)
2874{
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
  {
    gimple *stmt = gsi_stmt (gsi);

    if (is_gimple_debug (stmt))
continue;

    ipa_analyze_stmt_uses (fbi, stmt);
    walk_stmt_load_store_addr_ops (stmt, fbi->info,
		     visit_ref_for_mod_analysis,
		     visit_ref_for_mod_analysis,
		     visit_ref_for_mod_analysis);
  }
for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
  walk_stmt_load_store_addr_ops (gsi_stmt (gsi), fbi->info,
		   visit_ref_for_mod_analysis,
		   visit_ref_for_mod_analysis,
		   visit_ref_for_mod_analysis);
2894}

2896/* Return true EXPR is a load from a dereference of SSA_NAME NAME.  */

2898static bool
2899load_from_dereferenced_name (tree expr, tree name)
2900{
tree base = get_base_address (expr);
return (TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF
 && TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2903, __FUNCTION__))))) == name);
2904}

2906/* Calculate controlled uses of parameters of NODE.  */

2908static void
2909ipa_analyze_controlled_uses (struct cgraph_node *node)
2910{
ipa_node_params *info = ipa_node_params_sum->get (node);

for (int i = 0; i < ipa_get_param_count (info); i++)
  {
    tree parm = ipa_get_param (info, i);
    int call_uses = 0;
    bool load_dereferenced = false;

    /* For SSA regs see if parameter is used.  For non-SSA we compute
the flag during modification analysis.  */
    if (is_gimple_reg (parm))
{
 tree ddef = ssa_default_def (DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 2923, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f),
		       parm);
 if (ddef && !has_zero_uses (ddef))
   {
     imm_use_iterator imm_iter;
     gimple *stmt;

     ipa_set_param_used (info, i, true);
     FOR_EACH_IMM_USE_STMT (stmt, imm_iter, ddef)for (struct auto_end_imm_use_stmt_traverse auto_end_imm_use_stmt_traverse
 ((((stmt) = first_imm_use_stmt (&(imm_iter), (ddef))), &
(imm_iter))); !end_imm_use_stmt_p (&(imm_iter)); (void) (
(stmt) = next_imm_use_stmt (&(imm_iter))))
{
  if (is_gimple_debug (stmt))
    continue;

  int all_stmt_uses = 0;
  use_operand_p use_p;
  FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)for ((use_p) = first_imm_use_on_stmt (&(imm_iter)); !end_imm_use_on_stmt_p
 (&(imm_iter)); (void) ((use_p) = next_imm_use_on_stmt (&
(imm_iter))))
    all_stmt_uses++;

  if (is_gimple_call (stmt))
    {
      if (gimple_call_internal_p (stmt))
	{
	  call_uses = IPA_UNDESCRIBED_USE-1;
	  break;
	}
      int recognized_stmt_uses;
      if (gimple_call_fn (stmt) == ddef)
	recognized_stmt_uses = 1;
      else
	recognized_stmt_uses = 0;
      unsigned arg_count = gimple_call_num_args (stmt);
      for (unsigned i = 0; i < arg_count; i++)
	{
	  tree arg = gimple_call_arg (stmt, i);
	  if (arg == ddef)
	    recognized_stmt_uses++;
	  else if (load_from_dereferenced_name (arg, ddef))
	    {
	      load_dereferenced = true;
	      recognized_stmt_uses++;
	    }
	}

      if (recognized_stmt_uses != all_stmt_uses)
	{
	  call_uses = IPA_UNDESCRIBED_USE-1;
	  break;
	}
      if (call_uses >= 0)
	call_uses += all_stmt_uses;
    }
  else if (gimple_assign_single_p (stmt))
    {
      tree rhs = gimple_assign_rhs1 (stmt);
      if (all_stmt_uses != 1
	  || !load_from_dereferenced_name (rhs, ddef))
	{
	  call_uses = IPA_UNDESCRIBED_USE-1;
	  break;
	}
      load_dereferenced = true;
    }
  else
    {
      call_uses = IPA_UNDESCRIBED_USE-1;
      break;
    }
}
   }
 else
   call_uses = 0;
}
    else
call_uses = IPA_UNDESCRIBED_USE-1;
    ipa_set_controlled_uses (info, i, call_uses);
    ipa_set_param_load_dereferenced (info, i, load_dereferenced);
  }
3000}

3002/* Free stuff in BI.  */

3004static void
3005free_ipa_bb_info (struct ipa_bb_info *bi)
3006{
bi->cg_edges.release ();
bi->param_aa_statuses.release ();
3009}

3011/* Dominator walker driving the analysis.  */

3013class analysis_dom_walker : public dom_walker
3014{
3015public:
analysis_dom_walker (struct ipa_func_body_info *fbi)
  : dom_walker (CDI_DOMINATORS), m_fbi (fbi) {}

edge before_dom_children (basic_block) final override;

3021private:
struct ipa_func_body_info *m_fbi;
3023};

3025edge
3026analysis_dom_walker::before_dom_children (basic_block bb)
3027{
ipa_analyze_params_uses_in_bb (m_fbi, bb);
ipa_compute_jump_functions_for_bb (m_fbi, bb);
return NULLnullptr;
3031}

3033/* Release body info FBI.  */

3035void
3036ipa_release_body_info (struct ipa_func_body_info *fbi)
3037{
int i;
struct ipa_bb_info *bi;

FOR_EACH_VEC_ELT (fbi->bb_infos, i, bi)for (i = 0; (fbi->bb_infos).iterate ((i), &(bi)); ++(i
))
  free_ipa_bb_info (bi);
fbi->bb_infos.release ();
3044}

3046/* Initialize the array describing properties of formal parameters
 of NODE, analyze their uses and compute jump functions associated
 with actual arguments of calls from within NODE.  */

3050void
3051ipa_analyze_node (struct cgraph_node *node)
3052{
struct ipa_func_body_info fbi;
class ipa_node_params *info;

ipa_check_create_node_params ();
ipa_check_create_edge_args ();
info = ipa_node_params_sum->get_create (node);

if (info->analysis_done)
  return;
info->analysis_done = 1;

if (ipa_func_spec_opts_forbid_analysis_p (node)
    || (count_formal_params (node->decl)
 >= (1 << IPA_PROP_ARG_INDEX_LIMIT_BITS16)))
  {
    gcc_assert (!ipa_get_param_count (info))((void)(!(!ipa_get_param_count (info)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3068, __FUNCTION__), 0 : 0));
    return;
  }

struct function *func = DECL_STRUCT_FUNCTION (node->decl)((tree_check ((node->decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3072, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);
push_cfun (func);
calculate_dominance_info (CDI_DOMINATORS);
ipa_initialize_node_params (node);
ipa_analyze_controlled_uses (node);

fbi.node = node;
fbi.info = info;
fbi.bb_infos = vNULL;
fbi.bb_infos.safe_grow_cleared (last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block), true);
fbi.param_count = ipa_get_param_count (info);
fbi.aa_walk_budget = opt_for_fn (node->decl, param_ipa_max_aa_steps)(opts_for_fn (node->decl)->x_param_ipa_max_aa_steps);

for (struct cgraph_edge *cs = node->callees; cs; cs = cs->next_callee)
  {
    ipa_bb_info *bi = ipa_get_bb_info (&fbi, gimple_bb (cs->call_stmt));
    bi->cg_edges.safe_push (cs);
  }

for (struct cgraph_edge *cs = node->indirect_calls; cs; cs = cs->next_callee)
  {
    ipa_bb_info *bi = ipa_get_bb_info (&fbi, gimple_bb (cs->call_stmt));
    bi->cg_edges.safe_push (cs);
  }

analysis_dom_walker (&fbi).walk (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr));

ipa_release_body_info (&fbi);
free_dominance_info (CDI_DOMINATORS);
pop_cfun ();
3102}

3104/* Update the jump functions associated with call graph edge E when the call
 graph edge CS is being inlined, assuming that E->caller is already (possibly
 indirectly) inlined into CS->callee and that E has not been inlined.  */

3108static void
3109update_jump_functions_after_inlining (struct cgraph_edge *cs,
		      struct cgraph_edge *e)
3111{
ipa_edge_args *top = ipa_edge_args_sum->get (cs);
ipa_edge_args *args = ipa_edge_args_sum->get (e);
if (!args)
  return;
int count = ipa_get_cs_argument_count (args);
int i;

for (i = 0; i < count; i++)
  {
    struct ipa_jump_func *dst = ipa_get_ith_jump_func (args, i);
    class ipa_polymorphic_call_context *dst_ctx
= ipa_get_ith_polymorhic_call_context (args, i);

    if (dst->agg.items)
{
 struct ipa_agg_jf_item *item;
 int j;

 FOR_EACH_VEC_ELT (*dst->agg.items, j, item)for (j = 0; (*dst->agg.items).iterate ((j), &(item)); ++
(j))
   {
     int dst_fid;
     struct ipa_jump_func *src;

     if (item->jftype != IPA_JF_PASS_THROUGH
  && item->jftype != IPA_JF_LOAD_AGG)
continue;

     dst_fid = item->value.pass_through.formal_id;
     if (!top || dst_fid >= ipa_get_cs_argument_count (top))
{
  item->jftype = IPA_JF_UNKNOWN;
  continue;
}

     item->value.pass_through.formal_id = -1;
     src = ipa_get_ith_jump_func (top, dst_fid);
     if (src->type == IPA_JF_CONST)
{
  if (item->jftype == IPA_JF_PASS_THROUGH
      && item->value.pass_through.operation == NOP_EXPR)
    {
      item->jftype = IPA_JF_CONST;
      item->value.constant = src->value.constant.value;
      continue;
    }
}
     else if (src->type == IPA_JF_PASS_THROUGH
       && src->value.pass_through.operation == NOP_EXPR)
{
  if (item->jftype == IPA_JF_PASS_THROUGH
      || !item->value.load_agg.by_ref
      || src->value.pass_through.agg_preserved)
    item->value.pass_through.formal_id
		= src->value.pass_through.formal_id;
}
     else if (src->type == IPA_JF_ANCESTOR)
{
  if (item->jftype == IPA_JF_PASS_THROUGH)
    {
      if (!src->value.ancestor.offset)
	item->value.pass_through.formal_id
		= src->value.ancestor.formal_id;
    }
  else if (src->value.ancestor.agg_preserved)
    {
      gcc_checking_assert (item->value.load_agg.by_ref)((void)(!(item->value.load_agg.by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3177, __FUNCTION__), 0 : 0));

      item->value.pass_through.formal_id
		 = src->value.ancestor.formal_id;
      item->value.load_agg.offset
		+= src->value.ancestor.offset;
    }
}

     if (item->value.pass_through.formal_id < 0)
item->jftype = IPA_JF_UNKNOWN;
   }
}

    if (!top)
{
 ipa_set_jf_unknown (dst);
 continue;
}

    if (dst->type == IPA_JF_ANCESTOR)
{
 struct ipa_jump_func *src;
 int dst_fid = dst->value.ancestor.formal_id;
 class ipa_polymorphic_call_context *src_ctx
   = ipa_get_ith_polymorhic_call_context (top, dst_fid);

 /* Variable number of arguments can cause havoc if we try to access
    one that does not exist in the inlined edge.  So make sure we
    don't.  */
 if (dst_fid >= ipa_get_cs_argument_count (top))
   {
     ipa_set_jf_unknown (dst);
     continue;
   }

 src = ipa_get_ith_jump_func (top, dst_fid);

 if (src_ctx && !src_ctx->useless_p ())
   {
     class ipa_polymorphic_call_context ctx = *src_ctx;

     /* TODO: Make type preserved safe WRT contexts.  */
     if (!ipa_get_jf_ancestor_type_preserved (dst))
ctx.possible_dynamic_type_change (e->in_polymorphic_cdtor);
     ctx.offset_by (dst->value.ancestor.offset);
     if (!ctx.useless_p ())
{
  if (!dst_ctx)
    {
      vec_safe_grow_cleared (args->polymorphic_call_contexts,
			     count, true);
      dst_ctx = ipa_get_ith_polymorhic_call_context (args, i);
    }

  dst_ctx->combine_with (ctx);
}
   }

 /* Parameter and argument in ancestor jump function must be pointer
    type, which means access to aggregate must be by-reference.  */
 gcc_assert (!src->agg.items || src->agg.by_ref)((void)(!(!src->agg.items || src->agg.by_ref) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3238, __FUNCTION__), 0 : 0));

 if (src->agg.items && dst->value.ancestor.agg_preserved)
   {
     struct ipa_agg_jf_item *item;
     int j;

     /* Currently we do not produce clobber aggregate jump functions,
 replace with merging when we do.  */
     gcc_assert (!dst->agg.items)((void)(!(!dst->agg.items) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3247, __FUNCTION__), 0 : 0));

     dst->agg.items = vec_safe_copy (src->agg.items);
     dst->agg.by_ref = src->agg.by_ref;
     FOR_EACH_VEC_SAFE_ELT (dst->agg.items, j, item)for (j = 0; vec_safe_iterate ((dst->agg.items), (j), &
(item)); ++(j))
item->offset -= dst->value.ancestor.offset;
   }

 if (src->type == IPA_JF_PASS_THROUGH
     && src->value.pass_through.operation == NOP_EXPR)
   {
     dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
     dst->value.ancestor.agg_preserved &=
src->value.pass_through.agg_preserved;
   }
 else if (src->type == IPA_JF_ANCESTOR)
   {
     dst->value.ancestor.formal_id = src->value.ancestor.formal_id;
     dst->value.ancestor.offset += src->value.ancestor.offset;
     dst->value.ancestor.agg_preserved &=
src->value.ancestor.agg_preserved;
     dst->value.ancestor.keep_null |= src->value.ancestor.keep_null;
   }
 else
   ipa_set_jf_unknown (dst);
}
    else if (dst->type == IPA_JF_PASS_THROUGH)
{
 struct ipa_jump_func *src;
 /* We must check range due to calls with variable number of arguments
    and we cannot combine jump functions with operations.  */
 if (dst->value.pass_through.operation == NOP_EXPR
     && (top && dst->value.pass_through.formal_id
  < ipa_get_cs_argument_count (top)))
   {
     int dst_fid = dst->value.pass_through.formal_id;
     src = ipa_get_ith_jump_func (top, dst_fid);
     bool dst_agg_p = ipa_get_jf_pass_through_agg_preserved (dst);
     class ipa_polymorphic_call_context *src_ctx
= ipa_get_ith_polymorhic_call_context (top, dst_fid);

     if (src_ctx && !src_ctx->useless_p ())
{
  class ipa_polymorphic_call_context ctx = *src_ctx;

  /* TODO: Make type preserved safe WRT contexts.  */
  if (!ipa_get_jf_pass_through_type_preserved (dst))
    ctx.possible_dynamic_type_change (e->in_polymorphic_cdtor);
  if (!ctx.useless_p ())
    {
      if (!dst_ctx)
	{
	  vec_safe_grow_cleared (args->polymorphic_call_contexts,
				 count, true);
	  dst_ctx = ipa_get_ith_polymorhic_call_context (args, i);
	}
      dst_ctx->combine_with (ctx);
    }
}
     switch (src->type)
{
case IPA_JF_UNKNOWN:
  ipa_set_jf_unknown (dst);
  break;
case IPA_JF_CONST:
  ipa_set_jf_cst_copy (dst, src);
  break;

case IPA_JF_PASS_THROUGH:
  {
    int formal_id = ipa_get_jf_pass_through_formal_id (src);
    enum tree_code operation;
    operation = ipa_get_jf_pass_through_operation (src);

    if (operation == NOP_EXPR)
      {
	bool agg_p;
	agg_p = dst_agg_p
	  && ipa_get_jf_pass_through_agg_preserved (src);
	ipa_set_jf_simple_pass_through (dst, formal_id, agg_p);
      }
    else if (TREE_CODE_CLASS (operation)tree_code_type_tmpl <0>::tree_code_type[(int) (operation
)] == tcc_unary)
      ipa_set_jf_unary_pass_through (dst, formal_id, operation);
    else
      {
	tree operand = ipa_get_jf_pass_through_operand (src);
	ipa_set_jf_arith_pass_through (dst, formal_id, operand,
				       operation);
      }
    break;
  }
case IPA_JF_ANCESTOR:
  {
    bool agg_p;
    agg_p = dst_agg_p
      && ipa_get_jf_ancestor_agg_preserved (src);
    ipa_set_ancestor_jf (dst,
			 ipa_get_jf_ancestor_offset (src),
			 ipa_get_jf_ancestor_formal_id (src),
			 agg_p,
			 ipa_get_jf_ancestor_keep_null (src));
    break;
  }
default:
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3351, __FUNCTION__));
}

     if (src->agg.items
  && (dst_agg_p || !src->agg.by_ref))
{
  /* Currently we do not produce clobber aggregate jump
     functions, replace with merging when we do.  */
  gcc_assert (!dst->agg.items)((void)(!(!dst->agg.items) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3359, __FUNCTION__), 0 : 0));

  dst->agg.by_ref = src->agg.by_ref;
  dst->agg.items = vec_safe_copy (src->agg.items);
}
   }
 else
   ipa_set_jf_unknown (dst);
}
  }
3369}

3371/* If TARGET is an addr_expr of a function declaration, make it the 
 (SPECULATIVE)destination of an indirect edge IE and return the edge.
 Otherwise, return NULL.  */

3375struct cgraph_edge *
3376ipa_make_edge_direct_to_target (struct cgraph_edge *ie, tree target,
		bool speculative)
3378{
struct cgraph_node *callee;
bool unreachable = false;

if (TREE_CODE (target)((enum tree_code) (target)->base.code) == ADDR_EXPR)
  target = TREE_OPERAND (target, 0)(*((const_cast<tree*> (tree_operand_check ((target), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3383, __FUNCTION__)))));
if (TREE_CODE (target)((enum tree_code) (target)->base.code) != FUNCTION_DECL)
  {
    target = canonicalize_constructor_val (target, NULLnullptr);
    if (!target || TREE_CODE (target)((enum tree_code) (target)->base.code) != FUNCTION_DECL)
{
 /* Member pointer call that goes through a VMT lookup.  */
 if (ie->indirect_info->member_ptr
     /* Or if target is not an invariant expression and we do not
 know if it will evaulate to function at runtime.
 This can happen when folding through &VAR, where &VAR
 is IP invariant, but VAR itself is not.

 TODO: Revisit this when GCC 5 is branched.  It seems that
 member_ptr check is not needed and that we may try to fold
 the expression and see if VAR is readonly.  */
     || !is_gimple_ip_invariant (target))
   {
     if (dump_enabled_p ())
{
  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, ie->call_stmt,
		   "discovered direct call non-invariant %s\n",
		   ie->caller->dump_name ());
}
     return NULLnullptr;
   }


        if (dump_enabled_p ())
   {
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, ie->call_stmt,
	       "discovered direct call to non-function in %s, "
	       "making it __builtin_unreachable\n",
	       ie->caller->dump_name ());
   }

 target = builtin_decl_unreachable ();
 callee = cgraph_node::get_create (target);
 unreachable = true;
}
    else
callee = cgraph_node::get (target);
  }
else
  callee = cgraph_node::get (target);

/* Because may-edges are not explicitely represented and vtable may be external,
   we may create the first reference to the object in the unit.  */
if (!callee || callee->inlined_to)
  {

    /* We are better to ensure we can refer to it.
In the case of static functions we are out of luck, since we already	
removed its body.  In the case of public functions we may or may
not introduce the reference.  */
    if (!canonicalize_constructor_val (target, NULLnullptr)
 || !TREE_PUBLIC (target)((target)->base.public_flag))
{
 if (dump_file)
   fprintf (dump_file, "ipa-prop: Discovered call to a known target "
     "(%s -> %s) but cannot refer to it.  Giving up.\n",
     ie->caller->dump_name (),
     ie->callee->dump_name ());
 return NULLnullptr;
}
    callee = cgraph_node::get_create (target);
  }

/* If the edge is already speculated.  */
if (speculative && ie->speculative)
  {
    if (dump_file)
{
 cgraph_edge *e2 = ie->speculative_call_for_target (callee);
 if (!e2)
   {
     if (dump_file)
fprintf (dump_file, "ipa-prop: Discovered call to a "
	 "speculative target (%s -> %s) but the call is "
	 "already speculated to different target.  "
	 "Giving up.\n",
	 ie->caller->dump_name (), callee->dump_name ());
   }
 else
   {
     if (dump_file)
fprintf (dump_file,
	 "ipa-prop: Discovered call to a speculative target "
	 "(%s -> %s) this agree with previous speculation.\n",
	 ie->caller->dump_name (), callee->dump_name ());
   }
}
    return NULLnullptr;
  }

if (!dbg_cnt (devirt))
  return NULLnullptr;

ipa_check_create_node_params ();

/* We cannot make edges to inline clones.  It is bug that someone removed
   the cgraph node too early.  */
gcc_assert (!callee->inlined_to)((void)(!(!callee->inlined_to) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3485, __FUNCTION__), 0 : 0));

if (dump_file && !unreachable)
  {
    fprintf (dump_file, "ipa-prop: Discovered %s call to a %s target "
      "(%s -> %s), for stmt ",
      ie->indirect_info->polymorphic ? "a virtual" : "an indirect",
      speculative ? "speculative" : "known",
      ie->caller->dump_name (),
      callee->dump_name ());
    if (ie->call_stmt)
print_gimple_stmt (dump_file, ie->call_stmt, 2, TDF_SLIM);
    else
fprintf (dump_file, "with uid %i\n", ie->lto_stmt_uid);
   }
if (dump_enabled_p ())
  {
    dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, ie->call_stmt,
       "converting indirect call in %s to direct call to %s\n",
       ie->caller->dump_name (), callee->dump_name ());
  }
if (!speculative)
  {
    struct cgraph_edge *orig = ie;
    ie = cgraph_edge::make_direct (ie, callee);
    /* If we resolved speculative edge the cost is already up to date
for direct call (adjusted by inline_edge_duplication_hook).  */
    if (ie == orig)
{
 ipa_call_summary *es = ipa_call_summaries->get (ie);
 es->call_stmt_size -= (eni_size_weights.indirect_call_cost
		 - eni_size_weights.call_cost);
 es->call_stmt_time -= (eni_time_weights.indirect_call_cost
		 - eni_time_weights.call_cost);
}
  }
else
  {
    if (!callee->can_be_discarded_p ())
{
 cgraph_node *alias;
 alias = dyn_cast<cgraph_node *> (callee->noninterposable_alias ());
 if (alias)
   callee = alias;
}
    /* make_speculative will update ie's cost to direct call cost. */
    ie = ie->make_speculative
    (callee, ie->count.apply_scale (8, 10));
  }

return ie;
3536}

3538/* Attempt to locate an interprocedural constant at a given REQ_OFFSET in
 CONSTRUCTOR and return it.  Return NULL if the search fails for some
 reason.  */

3542static tree
3543find_constructor_constant_at_offset (tree constructor, HOST_WIDE_INTlong req_offset)
3544{
tree type = TREE_TYPE (constructor)((contains_struct_check ((constructor), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3545, __FUNCTION__))->typed.type);
if (TREE_CODE (type)((enum tree_code) (type)->base.code) != ARRAY_TYPE
    && TREE_CODE (type)((enum tree_code) (type)->base.code) != RECORD_TYPE)
  return NULLnullptr;

unsigned ix;
tree index, val;
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (constructor), ix, index, val)for (ix = 0; (ix >= vec_safe_length (((tree_check ((constructor
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3552, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
 ? false : (((void) (val = (*((tree_check ((constructor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3552, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
ix].value)), (index = (*((tree_check ((constructor), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3552, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
ix].index), true); (ix)++)
  {
    HOST_WIDE_INTlong elt_offset;
    if (TREE_CODE (type)((enum tree_code) (type)->base.code) == ARRAY_TYPE)
     {
       offset_int off;
       tree unit_size = TYPE_SIZE_UNIT (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3558, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3558, __FUNCTION__))->type_common.size_unit);
       gcc_assert (TREE_CODE (unit_size) == INTEGER_CST)((void)(!(((enum tree_code) (unit_size)->base.code) == INTEGER_CST
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3559, __FUNCTION__), 0 : 0));

       if (index)
         {
    if (TREE_CODE (index)((enum tree_code) (index)->base.code) == RANGE_EXPR)
      off = wi::to_offset (TREE_OPERAND (index, 0)(*((const_cast<tree*> (tree_operand_check ((index), (0)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3564, __FUNCTION__))))));
    else
      off = wi::to_offset (index);
           if (TYPE_DOMAIN (type)((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3567, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
) && TYPE_MIN_VALUE (TYPE_DOMAIN (type))((tree_check5 ((((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3567, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3567, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
))
             {
               tree low_bound = TYPE_MIN_VALUE (TYPE_DOMAIN (type))((tree_check5 ((((tree_check ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3569, __FUNCTION__, (ARRAY_TYPE)))->type_non_common.values
)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3569, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
);
               gcc_assert (TREE_CODE (unit_size) == INTEGER_CST)((void)(!(((enum tree_code) (unit_size)->base.code) == INTEGER_CST
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3570, __FUNCTION__), 0 : 0));
               off = wi::sext (off - wi::to_offset (low_bound),
                               TYPE_PRECISION (TREE_TYPE (index))((tree_class_check ((((contains_struct_check ((index), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3572, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3572, __FUNCTION__))->type_common.precision));
             }
           off *= wi::to_offset (unit_size);
    /* ???  Handle more than just the first index of a
       RANGE_EXPR.  */
         }
       else
         off = wi::to_offset (unit_size) * ix;

       off = wi::lshift (off, LOG2_BITS_PER_UNIT3);
       if (!wi::fits_shwi_p (off) || wi::neg_p (off))
         continue;
       elt_offset = off.to_shwi ();
     }
    else if (TREE_CODE (type)((enum tree_code) (type)->base.code) == RECORD_TYPE)
     {
       gcc_checking_assert (index && TREE_CODE (index) == FIELD_DECL)((void)(!(index && ((enum tree_code) (index)->base
.code) == FIELD_DECL) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3588, __FUNCTION__), 0 : 0));
       if (DECL_BIT_FIELD (index)((tree_check ((index), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3589, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
))
         continue;
       elt_offset = int_bit_position (index);
     }
    else
     gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3594, __FUNCTION__));

    if (elt_offset > req_offset)
return NULLnullptr;

    if (TREE_CODE (val)((enum tree_code) (val)->base.code) == CONSTRUCTOR)
return find_constructor_constant_at_offset (val,
				    req_offset - elt_offset);

    if (elt_offset == req_offset
 && is_gimple_reg_type (TREE_TYPE (val)((contains_struct_check ((val), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3604, __FUNCTION__))->typed.type))
 && is_gimple_ip_invariant (val))
return val;
  }
return NULLnullptr;
3609}

3611/* Check whether SCALAR could be used to look up an aggregate interprocedural
 invariant from a static constructor and if so, return it.  Otherwise return
 NULL. */

3615tree
3616ipa_find_agg_cst_from_init (tree scalar, HOST_WIDE_INTlong offset, bool by_ref)
3617{
if (by_ref)
  {
    if (TREE_CODE (scalar)((enum tree_code) (scalar)->base.code) != ADDR_EXPR)
return NULLnullptr;
    scalar = TREE_OPERAND (scalar, 0)(*((const_cast<tree*> (tree_operand_check ((scalar), (0
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3622, __FUNCTION__)))));
  }

if (!VAR_P (scalar)(((enum tree_code) (scalar)->base.code) == VAR_DECL)
    || !is_global_var (scalar)
    || !TREE_READONLY (scalar)((non_type_check ((scalar), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3627, __FUNCTION__))->base.readonly_flag)
    || !DECL_INITIAL (scalar)((contains_struct_check ((scalar), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3628, __FUNCTION__))->decl_common.initial)
    || TREE_CODE (DECL_INITIAL (scalar))((enum tree_code) (((contains_struct_check ((scalar), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3629, __FUNCTION__))->decl_common.initial))->base.code
) != CONSTRUCTOR)
  return NULLnullptr;

return find_constructor_constant_at_offset (DECL_INITIAL (scalar)((contains_struct_check ((scalar), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3632, __FUNCTION__))->decl_common.initial), offset);
3633}

3635/* Retrieve value from AGG_JFUNC for the given OFFSET or return NULL if there
 is none.  BY_REF specifies whether the value has to be passed by reference
 or by value.  */

3639static tree
3640ipa_find_agg_cst_from_jfunc_items (struct ipa_agg_jump_function *agg_jfunc,
		   ipa_node_params *src_info,
		   cgraph_node *src_node,
		   HOST_WIDE_INTlong offset, bool by_ref)
3644{
if (by_ref != agg_jfunc->by_ref)
  return NULL_TREE(tree) nullptr;

for (const ipa_agg_jf_item &item : agg_jfunc->items)
  if (item.offset == offset)
    return ipa_agg_value_from_jfunc (src_info, src_node, &item);

return NULL_TREE(tree) nullptr;
3653}

3655/* Remove a reference to SYMBOL from the list of references of a node given by
 reference description RDESC.  Return true if the reference has been
 successfully found and removed.  */

3659static bool
3660remove_described_reference (symtab_node *symbol, struct ipa_cst_ref_desc *rdesc)
3661{
struct ipa_ref *to_del;
struct cgraph_edge *origin;

origin = rdesc->cs;
if (!origin)
  return false;
to_del = origin->caller->find_reference (symbol, origin->call_stmt,
			   origin->lto_stmt_uid);
if (!to_del)
  return false;

to_del->remove_reference ();
if (dump_file)
  fprintf (dump_file, "ipa-prop: Removed a reference from %s to %s.\n",
    origin->caller->dump_name (), symbol->dump_name ());
return true;
3678}

3680/* If JFUNC has a reference description with refcount different from
 IPA_UNDESCRIBED_USE, return the reference description, otherwise return
 NULL.  JFUNC must be a constant jump function.  */

3684static struct ipa_cst_ref_desc *
3685jfunc_rdesc_usable (struct ipa_jump_func *jfunc)
3686{
struct ipa_cst_ref_desc *rdesc = ipa_get_jf_constant_rdesc (jfunc);
if (rdesc && rdesc->refcount != IPA_UNDESCRIBED_USE-1)
  return rdesc;
else
  return NULLnullptr;
3692}

3694/* If the value of constant jump function JFUNC is an address of a function
 declaration, return the associated call graph node.  Otherwise return
 NULL.  */

3698static symtab_node *
3699symtab_node_for_jfunc (struct ipa_jump_func *jfunc)
3700{
gcc_checking_assert (jfunc->type == IPA_JF_CONST)((void)(!(jfunc->type == IPA_JF_CONST) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3701, __FUNCTION__), 0 : 0));
tree cst = ipa_get_jf_constant (jfunc);
if (TREE_CODE (cst)((enum tree_code) (cst)->base.code) != ADDR_EXPR
    || (TREE_CODE (TREE_OPERAND (cst, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3704, __FUNCTION__))))))->base.code) != FUNCTION_DECL
 && TREE_CODE (TREE_OPERAND (cst, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3705, __FUNCTION__))))))->base.code) != VAR_DECL))
  return NULLnullptr;

return symtab_node::get (TREE_OPERAND (cst, 0)(*((const_cast<tree*> (tree_operand_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3708, __FUNCTION__))))));
3709}


3712/* If JFUNC is a constant jump function with a usable rdesc, decrement its
 refcount and if it hits zero, remove reference to SYMBOL from the caller of
 the edge specified in the rdesc.  Return false if either the symbol or the
 reference could not be found, otherwise return true.  */

3717static bool
3718try_decrement_rdesc_refcount (struct ipa_jump_func *jfunc)
3719{
struct ipa_cst_ref_desc *rdesc;
if (jfunc->type == IPA_JF_CONST
    && (rdesc = jfunc_rdesc_usable (jfunc))
    && --rdesc->refcount == 0)
  {
    symtab_node *symbol = symtab_node_for_jfunc (jfunc);
    if (!symbol)
return false;

    return remove_described_reference (symbol, rdesc);
  }
return true;
3732}

3734/* Try to find a destination for indirect edge IE that corresponds to a simple
 call or a call of a member function pointer and where the destination is a
 pointer formal parameter described by jump function JFUNC.  TARGET_TYPE is
 the type of the parameter to which the result of JFUNC is passed.  If it can
 be determined, return the newly direct edge, otherwise return NULL.
 NEW_ROOT and NEW_ROOT_INFO is the node and its info that JFUNC lattices are
 relative to.  */

3742static struct cgraph_edge *
3743try_make_edge_direct_simple_call (struct cgraph_edge *ie,
		  struct ipa_jump_func *jfunc, tree target_type,
		  struct cgraph_node *new_root,
		  class ipa_node_params *new_root_info)
3747{
struct cgraph_edge *cs;
tree target = NULL_TREE(tree) nullptr;
bool agg_contents = ie->indirect_info->agg_contents;
tree scalar = ipa_value_from_jfunc (new_root_info, jfunc, target_type);
if (agg_contents)
  {
    if (scalar)
target = ipa_find_agg_cst_from_init (scalar, ie->indirect_info->offset,
			     ie->indirect_info->by_ref);
    if (!target && ie->indirect_info->guaranteed_unmodified)
target = ipa_find_agg_cst_from_jfunc_items (&jfunc->agg, new_root_info,
				    new_root,
				    ie->indirect_info->offset,
				    ie->indirect_info->by_ref);
  }
else
  target = scalar;
if (!target)
  return NULLnullptr;
cs = ipa_make_edge_direct_to_target (ie, target);

if (cs && !agg_contents)
  {
    bool ok;
    gcc_checking_assert (cs->callee((void)(!(cs->callee && (cs != ie || jfunc->type
 != IPA_JF_CONST || !symtab_node_for_jfunc (jfunc) || cs->
callee == symtab_node_for_jfunc (jfunc))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3776, __FUNCTION__), 0 : 0))
	   && (cs != ie((void)(!(cs->callee && (cs != ie || jfunc->type
 != IPA_JF_CONST || !symtab_node_for_jfunc (jfunc) || cs->
callee == symtab_node_for_jfunc (jfunc))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3776, __FUNCTION__), 0 : 0))
	       || jfunc->type != IPA_JF_CONST((void)(!(cs->callee && (cs != ie || jfunc->type
 != IPA_JF_CONST || !symtab_node_for_jfunc (jfunc) || cs->
callee == symtab_node_for_jfunc (jfunc))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3776, __FUNCTION__), 0 : 0))
	       || !symtab_node_for_jfunc (jfunc)((void)(!(cs->callee && (cs != ie || jfunc->type
 != IPA_JF_CONST || !symtab_node_for_jfunc (jfunc) || cs->
callee == symtab_node_for_jfunc (jfunc))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3776, __FUNCTION__), 0 : 0))
	       || cs->callee == symtab_node_for_jfunc (jfunc)))((void)(!(cs->callee && (cs != ie || jfunc->type
 != IPA_JF_CONST || !symtab_node_for_jfunc (jfunc) || cs->
callee == symtab_node_for_jfunc (jfunc))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3776, __FUNCTION__), 0 : 0));
    ok = try_decrement_rdesc_refcount (jfunc);
    gcc_checking_assert (ok)((void)(!(ok) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3778, __FUNCTION__), 0 : 0));
  }

return cs;
3782}

3784/* Return the target to be used in cases of impossible devirtualization.  IE
 and target (the latter can be NULL) are dumped when dumping is enabled.  */

3787tree
3788ipa_impossible_devirt_target (struct cgraph_edge *ie, tree target)
3789{
if (dump_file)
  {
    if (target)
fprintf (dump_file,
 "Type inconsistent devirtualization: %s->%s\n",
 ie->caller->dump_name (),
 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (target))((const char *) (tree_check ((decl_assembler_name (target)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3796, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
    else
fprintf (dump_file,
 "No devirtualization target in %s\n",
 ie->caller->dump_name ());
  }
tree new_target = builtin_decl_unreachable ();
cgraph_node::get_create (new_target);
return new_target;
3805}

3807/* Try to find a destination for indirect edge IE that corresponds to a virtual
 call based on a formal parameter which is described by jump function JFUNC
 and if it can be determined, make it direct and return the direct edge.
 Otherwise, return NULL.  CTX describes the polymorphic context that the
 parameter the call is based on brings along with it.  NEW_ROOT and
 NEW_ROOT_INFO is the node and its info that JFUNC lattices are relative
 to.  */

3815static struct cgraph_edge *
3816try_make_edge_direct_virtual_call (struct cgraph_edge *ie,
		   struct ipa_jump_func *jfunc,
		   class ipa_polymorphic_call_context ctx,
		   struct cgraph_node *new_root,
		   class ipa_node_params *new_root_info)
3821{
tree target = NULLnullptr;
bool speculative = false;

if (!opt_for_fn (ie->caller->decl, flag_devirtualize)(opts_for_fn (ie->caller->decl)->x_flag_devirtualize
))
  return NULLnullptr;

gcc_assert (!ie->indirect_info->by_ref)((void)(!(!ie->indirect_info->by_ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 3828, __FUNCTION__), 0 : 0));

/* Try to do lookup via known virtual table pointer value.  */
if (!ie->indirect_info->vptr_changed
    || opt_for_fn (ie->caller->decl, flag_devirtualize_speculatively)(opts_for_fn (ie->caller->decl)->x_flag_devirtualize_speculatively
))
  {
    tree vtable;
    unsigned HOST_WIDE_INTlong offset;
    tree t = NULL_TREE(tree) nullptr;
    if (jfunc->type == IPA_JF_CONST)
t = ipa_find_agg_cst_from_init (ipa_get_jf_constant (jfunc),
			ie->indirect_info->offset, true);
    if (!t)
t = ipa_find_agg_cst_from_jfunc_items (&jfunc->agg, new_root_info,
			       new_root,
			       ie->indirect_info->offset, true);
    if (t && vtable_pointer_value_to_vtable (t, &vtable, &offset))
{
 bool can_refer;
 t = gimple_get_virt_method_for_vtable (ie->indirect_info->otr_token,
				 vtable, offset, &can_refer);
 if (can_refer)
   {
     if (!t
  || fndecl_built_in_p (t, BUILT_IN_UNREACHABLE)
  || fndecl_built_in_p (t, BUILT_IN_UNREACHABLE_TRAP)
  || !possible_polymorphic_call_target_p
       (ie, cgraph_node::get (t)))
{
  /* Do not speculate builtin_unreachable, it is stupid!  */
  if (!ie->indirect_info->vptr_changed)
    target = ipa_impossible_devirt_target (ie, target);
  else
    target = NULLnullptr;
}
     else
{
  target = t;
  speculative = ie->indirect_info->vptr_changed;
}
   }
}
  }

ipa_polymorphic_call_context ie_context (ie);
vec <cgraph_node *>targets;
bool final;

ctx.offset_by (ie->indirect_info->offset);
if (ie->indirect_info->vptr_changed)
  ctx.possible_dynamic_type_change (ie->in_polymorphic_cdtor,
		      ie->indirect_info->otr_type);
ctx.combine_with (ie_context, ie->indirect_info->otr_type);
targets = possible_polymorphic_call_targets
  (ie->indirect_info->otr_type,
   ie->indirect_info->otr_token,
   ctx, &final);
if (final && targets.length () <= 1)
  {
    speculative = false;
    if (targets.length () == 1)
target = targets[0]->decl;
    else
target = ipa_impossible_devirt_target (ie, NULL_TREE(tree) nullptr);
  }
else if (!target && opt_for_fn (ie->caller->decl, flag_devirtualize_speculatively)(opts_for_fn (ie->caller->decl)->x_flag_devirtualize_speculatively
)
  && !ie->speculative && ie->maybe_hot_p ())
  {
    cgraph_node *n;
    n = try_speculative_devirtualization (ie->indirect_info->otr_type,
			    ie->indirect_info->otr_token,
			    ie->indirect_info->context);
    if (n)
{
 target = n->decl;
 speculative = true;
}
  }

if (target)
  {
    if (!possible_polymorphic_call_target_p
 (ie, cgraph_node::get_create (target)))
{
 if (speculative)
   return NULLnullptr;
 target = ipa_impossible_devirt_target (ie, target);
}
    return ipa_make_edge_direct_to_target (ie, target, speculative);
  }
else
  return NULLnullptr;
3920}

3922/* Update the param called notes associated with NODE when CS is being inlined,
 assuming NODE is (potentially indirectly) inlined into CS->callee.
 Moreover, if the callee is discovered to be constant, create a new cgraph
 edge for it.  Newly discovered indirect edges will be added to *NEW_EDGES,
 unless NEW_EDGES is NULL.  Return true iff a new edge(s) were created.  */

3928static bool
3929update_indirect_edges_after_inlining (struct cgraph_edge *cs,
		      struct cgraph_node *node,
		      vec<cgraph_edge *> *new_edges)
3932{
class ipa_edge_args *top;
struct cgraph_edge *ie, *next_ie, *new_direct_edge;
struct cgraph_node *new_root;
class ipa_node_params *new_root_info, *inlined_node_info;
bool res = false;

ipa_check_create_edge_args ();
top = ipa_edge_args_sum->get (cs);
new_root = cs->caller->inlined_to
? cs->caller->inlined_to : cs->caller;
new_root_info = ipa_node_params_sum->get (new_root);
inlined_node_info = ipa_node_params_sum->get (cs->callee->function_symbol ());

for (ie = node->indirect_calls; ie; ie = next_ie)
  {
    class cgraph_indirect_call_info *ici = ie->indirect_info;
    struct ipa_jump_func *jfunc;
    int param_index;

    next_ie = ie->next_callee;

    if (ici->param_index == -1)
continue;

    /* We must check range due to calls with variable number of arguments:  */
    if (!top || ici->param_index >= ipa_get_cs_argument_count (top))
{
 ici->param_index = -1;
 continue;
}

    param_index = ici->param_index;
    jfunc = ipa_get_ith_jump_func (top, param_index);

    auto_vec<cgraph_node *, 4> spec_targets;
    if (ie->speculative)
for (cgraph_edge *direct = ie->first_speculative_call_target ();
    direct;
    direct = direct->next_speculative_call_target ())
 spec_targets.safe_push (direct->callee);

    if (!opt_for_fn (node->decl, flag_indirect_inlining)(opts_for_fn (node->decl)->x_flag_indirect_inlining))
new_direct_edge = NULLnullptr;
    else if (ici->polymorphic)
{
        ipa_polymorphic_call_context ctx;
 ctx = ipa_context_from_jfunc (new_root_info, cs, param_index, jfunc);
 new_direct_edge = try_make_edge_direct_virtual_call (ie, jfunc, ctx,
					       new_root,
					       new_root_info);
}
    else
{
 tree target_type =  ipa_get_type (inlined_node_info, param_index);
 new_direct_edge = try_make_edge_direct_simple_call (ie, jfunc,
					      target_type,
					      new_root,
					      new_root_info);
}

    /* If speculation was removed, then we need to do nothing.  */
    if (new_direct_edge && new_direct_edge != ie
 && spec_targets.contains (new_direct_edge->callee))
{
 new_direct_edge->indirect_inlining_edge = 1;
 res = true;
 if (!new_direct_edge->speculative)
   continue;
}
    else if (new_direct_edge)
{
 new_direct_edge->indirect_inlining_edge = 1;
 if (new_edges)
   {
     new_edges->safe_push (new_direct_edge);
     res = true;
   }
 /* If speculative edge was introduced we still need to update
    call info of the indirect edge.  */
 if (!new_direct_edge->speculative)
   continue;
}
    if (jfunc->type == IPA_JF_PASS_THROUGH
        && ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
{
 if (ici->agg_contents
     && !ipa_get_jf_pass_through_agg_preserved (jfunc)
     && !ici->polymorphic)
   ici->param_index = -1;
 else
   {
     ici->param_index = ipa_get_jf_pass_through_formal_id (jfunc);
     if (ici->polymorphic
  && !ipa_get_jf_pass_through_type_preserved (jfunc))
ici->vptr_changed = true;
     ipa_set_param_used_by_indirect_call (new_root_info,
	     			   ici->param_index, true);
     if (ici->polymorphic)
ipa_set_param_used_by_polymorphic_call (new_root_info,
				        ici->param_index, true);
   }
}
    else if (jfunc->type == IPA_JF_ANCESTOR)
{
 if (ici->agg_contents
     && !ipa_get_jf_ancestor_agg_preserved (jfunc)
     && !ici->polymorphic)
   ici->param_index = -1;
 else
   {
     ici->param_index = ipa_get_jf_ancestor_formal_id (jfunc);
     ici->offset += ipa_get_jf_ancestor_offset (jfunc);
     if (ici->polymorphic
  && !ipa_get_jf_ancestor_type_preserved (jfunc))
ici->vptr_changed = true;
     ipa_set_param_used_by_indirect_call (new_root_info,
	     			   ici->param_index, true);
     if (ici->polymorphic)
ipa_set_param_used_by_polymorphic_call (new_root_info,
				        ici->param_index, true);
   }
}
    else
/* Either we can find a destination for this edge now or never. */
ici->param_index = -1;
  }

return res;
4061}

4063/* Recursively traverse subtree of NODE (including node) made of inlined
 cgraph_edges when CS has been inlined and invoke
 update_indirect_edges_after_inlining on all nodes and
 update_jump_functions_after_inlining on all non-inlined edges that lead out
 of this subtree.  Newly discovered indirect edges will be added to
 *NEW_EDGES, unless NEW_EDGES is NULL.  Return true iff a new edge(s) were
 created.  */

4071static bool
4072propagate_info_to_inlined_callees (struct cgraph_edge *cs,
		   struct cgraph_node *node,
		   vec<cgraph_edge *> *new_edges)
4075{
struct cgraph_edge *e;
bool res;

res = update_indirect_edges_after_inlining (cs, node, new_edges);

for (e = node->callees; e; e = e->next_callee)
  if (!e->inline_failed)
    res |= propagate_info_to_inlined_callees (cs, e->callee, new_edges);
  else
    update_jump_functions_after_inlining (cs, e);
for (e = node->indirect_calls; e; e = e->next_callee)
  update_jump_functions_after_inlining (cs, e);

return res;
4090}

4092/* Combine two controlled uses counts as done during inlining.  */

4094static int
4095combine_controlled_uses_counters (int c, int d)
4096{
if (c == IPA_UNDESCRIBED_USE-1 || d == IPA_UNDESCRIBED_USE-1)
  return IPA_UNDESCRIBED_USE-1;
else
  return c + d - 1;
4101}

4103/* Propagate number of controlled users from CS->caleee to the new root of the
 tree of inlined nodes.  */

4106static void
4107propagate_controlled_uses (struct cgraph_edge *cs)
4108{
ipa_edge_args *args = ipa_edge_args_sum->get (cs);
if (!args)
  return;
struct cgraph_node *new_root = cs->caller->inlined_to
  ? cs->caller->inlined_to : cs->caller;
ipa_node_params *new_root_info = ipa_node_params_sum->get (new_root);
ipa_node_params *old_root_info = ipa_node_params_sum->get (cs->callee);
int count, i;

if (!old_root_info)
  return;

count = MIN (ipa_get_cs_argument_count (args),((ipa_get_cs_argument_count (args)) < (ipa_get_param_count
 (old_root_info)) ? (ipa_get_cs_argument_count (args)) : (ipa_get_param_count
 (old_root_info)))
      ipa_get_param_count (old_root_info))((ipa_get_cs_argument_count (args)) < (ipa_get_param_count
 (old_root_info)) ? (ipa_get_cs_argument_count (args)) : (ipa_get_param_count
 (old_root_info)));
for (i = 0; i < count; i++)
  {
    struct ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);
    struct ipa_cst_ref_desc *rdesc;

    if (jf->type == IPA_JF_PASS_THROUGH)
{
 int src_idx, c, d;
 src_idx = ipa_get_jf_pass_through_formal_id (jf);
 c = ipa_get_controlled_uses (new_root_info, src_idx);
 d = ipa_get_controlled_uses (old_root_info, i);

 gcc_checking_assert (ipa_get_jf_pass_through_operation (jf)((void)(!(ipa_get_jf_pass_through_operation (jf) == NOP_EXPR ||
 c == -1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4136, __FUNCTION__), 0 : 0))
	       == NOP_EXPR || c == IPA_UNDESCRIBED_USE)((void)(!(ipa_get_jf_pass_through_operation (jf) == NOP_EXPR ||
 c == -1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4136, __FUNCTION__), 0 : 0));
 c = combine_controlled_uses_counters (c, d);
 ipa_set_controlled_uses (new_root_info, src_idx, c);
 bool lderef = true;
 if (c != IPA_UNDESCRIBED_USE-1)
   {
     lderef = (ipa_get_param_load_dereferenced (new_root_info, src_idx)
	|| ipa_get_param_load_dereferenced (old_root_info, i));
     ipa_set_param_load_dereferenced (new_root_info, src_idx, lderef);
   }

 if (c == 0 && !lderef && new_root_info->ipcp_orig_node)
   {
     struct cgraph_node *n;
     struct ipa_ref *ref;
     tree t = new_root_info->known_csts[src_idx];

     if (t && TREE_CODE (t)((enum tree_code) (t)->base.code) == ADDR_EXPR
  && TREE_CODE (TREE_OPERAND (t, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4154, __FUNCTION__))))))->base.code) == FUNCTION_DECL
  && (n = cgraph_node::get (TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4155, __FUNCTION__)))))))
  && (ref = new_root->find_reference (n, NULLnullptr, 0)))
{
  if (dump_file)
    fprintf (dump_file, "ipa-prop: Removing cloning-created "
	     "reference from %s to %s.\n",
	     new_root->dump_name (),
	     n->dump_name ());
  ref->remove_reference ();
}
   }
}
    else if (jf->type == IPA_JF_CONST
      && (rdesc = jfunc_rdesc_usable (jf)))
{
 int d = ipa_get_controlled_uses (old_root_info, i);
 int c = rdesc->refcount;
 tree cst = ipa_get_jf_constant (jf);
 rdesc->refcount = combine_controlled_uses_counters (c, d);
 if (rdesc->refcount != IPA_UNDESCRIBED_USE-1
     && ipa_get_param_load_dereferenced (old_root_info, i)
     && TREE_CODE (cst)((enum tree_code) (cst)->base.code) == ADDR_EXPR
     && TREE_CODE (TREE_OPERAND (cst, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4177, __FUNCTION__))))))->base.code) == VAR_DECL)
   {
     symtab_node *n = symtab_node::get (TREE_OPERAND (cst, 0)(*((const_cast<tree*> (tree_operand_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4179, __FUNCTION__))))));
     new_root->create_reference (n, IPA_REF_LOAD, NULLnullptr);
     if (dump_file)
fprintf (dump_file, "ipa-prop: Address IPA constant will reach "
	 "a load so adding LOAD reference from %s to %s.\n",
	 new_root->dump_name (), n->dump_name ());
   }
 if (rdesc->refcount == 0)
   {
     gcc_checking_assert (TREE_CODE (cst) == ADDR_EXPR((void)(!(((enum tree_code) (cst)->base.code) == ADDR_EXPR
 && ((((enum tree_code) ((*((const_cast<tree*> (
tree_operand_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4189, __FUNCTION__))))))->base.code) == FUNCTION_DECL) ||
 (((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4191, __FUNCTION__))))))->base.code) == VAR_DECL))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4192, __FUNCTION__), 0 : 0))
		   && ((TREE_CODE (TREE_OPERAND (cst, 0))((void)(!(((enum tree_code) (cst)->base.code) == ADDR_EXPR
 && ((((enum tree_code) ((*((const_cast<tree*> (
tree_operand_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4189, __FUNCTION__))))))->base.code) == FUNCTION_DECL) ||
 (((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4191, __FUNCTION__))))))->base.code) == VAR_DECL))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4192, __FUNCTION__), 0 : 0))
			== FUNCTION_DECL)((void)(!(((enum tree_code) (cst)->base.code) == ADDR_EXPR
 && ((((enum tree_code) ((*((const_cast<tree*> (
tree_operand_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4189, __FUNCTION__))))))->base.code) == FUNCTION_DECL) ||
 (((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4191, __FUNCTION__))))))->base.code) == VAR_DECL))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4192, __FUNCTION__), 0 : 0))
		       || (TREE_CODE (TREE_OPERAND (cst, 0))((void)(!(((enum tree_code) (cst)->base.code) == ADDR_EXPR
 && ((((enum tree_code) ((*((const_cast<tree*> (
tree_operand_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4189, __FUNCTION__))))))->base.code) == FUNCTION_DECL) ||
 (((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4191, __FUNCTION__))))))->base.code) == VAR_DECL))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4192, __FUNCTION__), 0 : 0))
			   == VAR_DECL)))((void)(!(((enum tree_code) (cst)->base.code) == ADDR_EXPR
 && ((((enum tree_code) ((*((const_cast<tree*> (
tree_operand_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4189, __FUNCTION__))))))->base.code) == FUNCTION_DECL) ||
 (((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4191, __FUNCTION__))))))->base.code) == VAR_DECL))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4192, __FUNCTION__), 0 : 0));

     symtab_node *n = symtab_node::get (TREE_OPERAND (cst, 0)(*((const_cast<tree*> (tree_operand_check ((cst), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4194, __FUNCTION__))))));
     if (n)
{
  remove_described_reference (n, rdesc);
  cgraph_node *clone = cs->caller;
  while (clone->inlined_to
	 && clone->ipcp_clone
	 && clone != rdesc->cs->caller)
    {
      struct ipa_ref *ref;
      ref = clone->find_reference (n, NULLnullptr, 0);
      if (ref)
	{
	  if (dump_file)
	    fprintf (dump_file, "ipa-prop: Removing "
		     "cloning-created reference "
		     "from %s to %s.\n",
		     clone->dump_name (),
		     n->dump_name ());
	  ref->remove_reference ();
	}
      clone = clone->callers->caller;
    }
}
   }
}
  }

for (i = ipa_get_param_count (old_root_info);
     i < ipa_get_cs_argument_count (args);
     i++)
  {
    struct ipa_jump_func *jf = ipa_get_ith_jump_func (args, i);

    if (jf->type == IPA_JF_CONST)
{
 struct ipa_cst_ref_desc *rdesc = jfunc_rdesc_usable (jf);
 if (rdesc)
   rdesc->refcount = IPA_UNDESCRIBED_USE-1;
}
    else if (jf->type == IPA_JF_PASS_THROUGH)
ipa_set_controlled_uses (new_root_info,
		 jf->value.pass_through.formal_id,
		 IPA_UNDESCRIBED_USE-1);
  }
4239}

4241/* Update jump functions and call note functions on inlining the call site CS.
 CS is expected to lead to a node already cloned by
 cgraph_clone_inline_nodes.  Newly discovered indirect edges will be added to
 *NEW_EDGES, unless NEW_EDGES is NULL.  Return true iff a new edge(s) were +
 created.  */

4247bool
4248ipa_propagate_indirect_call_infos (struct cgraph_edge *cs,
		   vec<cgraph_edge *> *new_edges)
4250{
bool changed;
/* Do nothing if the preparation phase has not been carried out yet
   (i.e. during early inlining).  */
if (!ipa_node_params_sum)
  return false;
gcc_assert (ipa_edge_args_sum)((void)(!(ipa_edge_args_sum) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4256, __FUNCTION__), 0 : 0));

propagate_controlled_uses (cs);
changed = propagate_info_to_inlined_callees (cs, cs->callee, new_edges);
ipa_node_params_sum->remove (cs->callee);

ipa_edge_args *args = ipa_edge_args_sum->get (cs);
if (args)
  {
    bool ok = true;
    if (args->jump_functions)
{
 struct ipa_jump_func *jf;
 int i;
 FOR_EACH_VEC_ELT (*args->jump_functions, i, jf)for (i = 0; (*args->jump_functions).iterate ((i), &(jf
)); ++(i))
   if (jf->type == IPA_JF_CONST
&& ipa_get_jf_constant_rdesc (jf))
     {
ok = false;
break;
     }
}
    if (ok)
      ipa_edge_args_sum->remove (cs);
  }
if (ipcp_transformation_sum)
  ipcp_transformation_sum->remove (cs->callee);

return changed;
4285}

4287/* Ensure that array of edge arguments infos is big enough to accommodate a
 structure for all edges and reallocates it if not.  Also, allocate
 associated hash tables is they do not already exist.  */

4291void
4292ipa_check_create_edge_args (void)
4293{
if (!ipa_edge_args_sum)
  ipa_edge_args_sum
    = (new (ggc_alloc_no_dtor<ipa_edge_args_sum_t> ())
ipa_edge_args_sum_t (symtab, true));
if (!ipa_bits_hash_table)
  ipa_bits_hash_table = hash_table<ipa_bit_ggc_hash_traits>::create_ggc (37);
if (!ipa_vr_hash_table)
  ipa_vr_hash_table = hash_table<ipa_vr_ggc_hash_traits>::create_ggc (37);
4302}

4304/* Free all ipa_edge structures.  */

4306void
4307ipa_free_all_edge_args (void)
4308{
if (!ipa_edge_args_sum)
  return;

ggc_delete (ipa_edge_args_sum);
ipa_edge_args_sum = NULLnullptr;
4314}

4316/* Free all ipa_node_params structures.  */

4318void
4319ipa_free_all_node_params (void)
4320{
if (ipa_node_params_sum)
  ggc_delete (ipa_node_params_sum);
ipa_node_params_sum = NULLnullptr;
4324}

4326/* Initialize IPA CP transformation summary and also allocate any necessary hash
 tables if they do not already exist.  */

4329void
4330ipcp_transformation_initialize (void)
4331{
if (!ipa_bits_hash_table)
  ipa_bits_hash_table = hash_table<ipa_bit_ggc_hash_traits>::create_ggc (37);
if (!ipa_vr_hash_table)
  ipa_vr_hash_table = hash_table<ipa_vr_ggc_hash_traits>::create_ggc (37);
if (ipcp_transformation_sum == NULLnullptr)
  {
    ipcp_transformation_sum = ipcp_transformation_t::create_ggc (symtab);
    ipcp_transformation_sum->disable_insertion_hook ();
  }
4341}

4343/* Release the IPA CP transformation summary.  */

4345void
4346ipcp_free_transformation_sum (void)
4347{
if (!ipcp_transformation_sum)
  return;

ipcp_transformation_sum->~function_summary<ipcp_transformation *> ();
ggc_free (ipcp_transformation_sum);
ipcp_transformation_sum = NULLnullptr;
4354}

4356/* Set the aggregate replacements of NODE to be AGGVALS.  */

4358void
4359ipa_set_node_agg_value_chain (struct cgraph_node *node,
	      vec<ipa_argagg_value, va_gc> *aggs)
4361{
ipcp_transformation_initialize ();
ipcp_transformation *s = ipcp_transformation_sum->get_create (node);
s->m_agg_values = aggs;
4365}

4367/* Hook that is called by cgraph.cc when an edge is removed.  Adjust reference
 count data structures accordingly.  */

4370void
4371ipa_edge_args_sum_t::remove (cgraph_edge *cs, ipa_edge_args *args)
4372{
if (args->jump_functions)
  {
    struct ipa_jump_func *jf;
    int i;
    FOR_EACH_VEC_ELT (*args->jump_functions, i, jf)for (i = 0; (*args->jump_functions).iterate ((i), &(jf
)); ++(i))
{
 struct ipa_cst_ref_desc *rdesc;
 try_decrement_rdesc_refcount (jf);
 if (jf->type == IPA_JF_CONST
     && (rdesc = ipa_get_jf_constant_rdesc (jf))
     && rdesc->cs == cs)
   rdesc->cs = NULLnullptr;
}
  }
4387}

4389/* Method invoked when an edge is duplicated.  Copy ipa_edge_args and adjust
 reference count data strucutres accordingly.  */

4392void
4393ipa_edge_args_sum_t::duplicate (cgraph_edge *src, cgraph_edge *dst,
		ipa_edge_args *old_args, ipa_edge_args *new_args)
4395{
unsigned int i;

new_args->jump_functions = vec_safe_copy (old_args->jump_functions);
if (old_args->polymorphic_call_contexts)
  new_args->polymorphic_call_contexts
    = vec_safe_copy (old_args->polymorphic_call_contexts);

for (i = 0; i < vec_safe_length (old_args->jump_functions); i++)
  {
    struct ipa_jump_func *src_jf = ipa_get_ith_jump_func (old_args, i);
    struct ipa_jump_func *dst_jf = ipa_get_ith_jump_func (new_args, i);

    dst_jf->agg.items = vec_safe_copy (dst_jf->agg.items);

    if (src_jf->type == IPA_JF_CONST)
{
 struct ipa_cst_ref_desc *src_rdesc = jfunc_rdesc_usable (src_jf);

 if (!src_rdesc)
   dst_jf->value.constant.rdesc = NULLnullptr;
 else if (src->caller == dst->caller)
   {
     /* Creation of a speculative edge.  If the source edge is the one
 grabbing a reference, we must create a new (duplicate)
 reference description.  Otherwise they refer to the same
 description corresponding to a reference taken in a function
 src->caller is inlined to.  In that case we just must
 increment the refcount.  */
     if (src_rdesc->cs == src)
{
   symtab_node *n = symtab_node_for_jfunc (src_jf);
   gcc_checking_assert (n)((void)(!(n) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4427, __FUNCTION__), 0 : 0));
   ipa_ref *ref
     = src->caller->find_reference (n, src->call_stmt,
				    src->lto_stmt_uid);
   gcc_checking_assert (ref)((void)(!(ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4431, __FUNCTION__), 0 : 0));
   dst->caller->clone_reference (ref, ref->stmt);

   ipa_cst_ref_desc *dst_rdesc = ipa_refdesc_pool.allocate ();
   dst_rdesc->cs = dst;
   dst_rdesc->refcount = src_rdesc->refcount;
   dst_rdesc->next_duplicate = NULLnullptr;
   dst_jf->value.constant.rdesc = dst_rdesc;
}
     else
{
  src_rdesc->refcount++;
  dst_jf->value.constant.rdesc = src_rdesc;
}
   }
 else if (src_rdesc->cs == src)
   {
     struct ipa_cst_ref_desc *dst_rdesc = ipa_refdesc_pool.allocate ();
     dst_rdesc->cs = dst;
     dst_rdesc->refcount = src_rdesc->refcount;
     dst_rdesc->next_duplicate = src_rdesc->next_duplicate;
     src_rdesc->next_duplicate = dst_rdesc;
     dst_jf->value.constant.rdesc = dst_rdesc;
   }
 else
   {
     struct ipa_cst_ref_desc *dst_rdesc;
     /* This can happen during inlining, when a JFUNC can refer to a
 reference taken in a function up in the tree of inline clones.
 We need to find the duplicate that refers to our tree of
 inline clones.  */

     gcc_assert (dst->caller->inlined_to)((void)(!(dst->caller->inlined_to) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4463, __FUNCTION__), 0 : 0));
     for (dst_rdesc = src_rdesc->next_duplicate;
   dst_rdesc;
   dst_rdesc = dst_rdesc->next_duplicate)
{
  struct cgraph_node *top;
  top = dst_rdesc->cs->caller->inlined_to
    ? dst_rdesc->cs->caller->inlined_to
    : dst_rdesc->cs->caller;
  if (dst->caller->inlined_to == top)
    break;
}
     gcc_assert (dst_rdesc)((void)(!(dst_rdesc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4475, __FUNCTION__), 0 : 0));
     dst_jf->value.constant.rdesc = dst_rdesc;
   }
}
    else if (dst_jf->type == IPA_JF_PASS_THROUGH
      && src->caller == dst->caller)
{
 struct cgraph_node *inline_root = dst->caller->inlined_to
   ? dst->caller->inlined_to : dst->caller;
 ipa_node_params *root_info = ipa_node_params_sum->get (inline_root);
 int idx = ipa_get_jf_pass_through_formal_id (dst_jf);

 int c = ipa_get_controlled_uses (root_info, idx);
 if (c != IPA_UNDESCRIBED_USE-1)
   {
     c++;
     ipa_set_controlled_uses (root_info, idx, c);
   }
}
  }
4495}

4497/* Analyze newly added function into callgraph.  */

4499static void
4500ipa_add_new_function (cgraph_node *node, void *data ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
4501{
if (node->has_gimple_body_p ())
  ipa_analyze_node (node);
4504}

4506/* Hook that is called by summary when a node is duplicated.  */

4508void
4509ipa_node_params_t::duplicate(cgraph_node *, cgraph_node *,
	     ipa_node_params *old_info,
	     ipa_node_params *new_info)
4512{
new_info->descriptors = vec_safe_copy (old_info->descriptors);
new_info->lattices = NULLnullptr;
new_info->ipcp_orig_node = old_info->ipcp_orig_node;
new_info->known_csts = old_info->known_csts.copy ();
new_info->known_contexts = old_info->known_contexts.copy ();

new_info->analysis_done = old_info->analysis_done;
new_info->node_enqueued = old_info->node_enqueued;
new_info->versionable = old_info->versionable;
4522}

4524/* Duplication of ipcp transformation summaries.  */

4526void
4527ipcp_transformation_t::duplicate(cgraph_node *, cgraph_node *dst,
	         ipcp_transformation *src_trans,
	         ipcp_transformation *dst_trans)
4530{
/* Avoid redundant work of duplicating vectors we will never use.  */
if (dst->inlined_to)
  return;
dst_trans->m_agg_values = vec_safe_copy (src_trans->m_agg_values);
dst_trans->bits = vec_safe_copy (src_trans->bits);
dst_trans->m_vr = vec_safe_copy (src_trans->m_vr);
4537}

4539/* Register our cgraph hooks if they are not already there.  */

4541void
4542ipa_register_cgraph_hooks (void)
4543{
ipa_check_create_node_params ();
ipa_check_create_edge_args ();

function_insertion_hook_holder =
    symtab->add_cgraph_insertion_hook (&ipa_add_new_function, NULLnullptr);
4549}

4551/* Unregister our cgraph hooks if they are not already there.  */

4553static void
4554ipa_unregister_cgraph_hooks (void)
4555{
if (function_insertion_hook_holder)
  symtab->remove_cgraph_insertion_hook (function_insertion_hook_holder);
function_insertion_hook_holder = NULLnullptr;
4559}

4561/* Free all ipa_node_params and all ipa_edge_args structures if they are no
 longer needed after ipa-cp.  */

4564void
4565ipa_free_all_structures_after_ipa_cp (void)
4566{
if (!optimizeglobal_options.x_optimize && !in_lto_pglobal_options.x_in_lto_p)
  {
    ipa_free_all_edge_args ();
    ipa_free_all_node_params ();
    ipcp_sources_pool.release ();
    ipcp_cst_values_pool.release ();
    ipcp_poly_ctx_values_pool.release ();
    ipcp_agg_lattice_pool.release ();
    ipa_unregister_cgraph_hooks ();
    ipa_refdesc_pool.release ();
  }
4578}

4580/* Free all ipa_node_params and all ipa_edge_args structures if they are no
 longer needed after indirect inlining.  */

4583void
4584ipa_free_all_structures_after_iinln (void)
4585{
ipa_free_all_edge_args ();
ipa_free_all_node_params ();
ipa_unregister_cgraph_hooks ();
ipcp_sources_pool.release ();
ipcp_cst_values_pool.release ();
ipcp_poly_ctx_values_pool.release ();
ipcp_agg_lattice_pool.release ();
ipa_refdesc_pool.release ();
4594}

4596/* Print ipa_tree_map data structures of all functions in the
 callgraph to F.  */

4599void
4600ipa_print_node_params (FILE *f, struct cgraph_node *node)
4601{
int i, count;
class ipa_node_params *info;

if (!node->definition)
  return;
info = ipa_node_params_sum->get (node);
fprintf (f, "  function  %s parameter descriptors:\n", node->dump_name ());
if (!info)
  {
    fprintf (f, " no params return\n");
    return;
  }
count = ipa_get_param_count (info);
for (i = 0; i < count; i++)
  {
    int c;

    fprintf (f, "    ");
    ipa_dump_param (f, info, i);
    if (ipa_is_param_used (info, i))
fprintf (f, " used");
    if (ipa_is_param_used_by_ipa_predicates (info, i))
fprintf (f, " used_by_ipa_predicates");
    if (ipa_is_param_used_by_indirect_call (info, i))
fprintf (f, " used_by_indirect_call");
    if (ipa_is_param_used_by_polymorphic_call (info, i))
fprintf (f, " used_by_polymorphic_call");
    c = ipa_get_controlled_uses (info, i);
    if (c == IPA_UNDESCRIBED_USE-1)
fprintf (f, " undescribed_use");
    else
fprintf (f, "  controlled_uses=%i %s", c,
 ipa_get_param_load_dereferenced (info, i)
 ? "(load_dereferenced)" : "");
    fprintf (f, "\n");
  }
4638}

4640/* Print ipa_tree_map data structures of all functions in the
 callgraph to F.  */

4643void
4644ipa_print_all_params (FILE * f)
4645{
struct cgraph_node *node;

fprintf (f, "\nFunction parameters:\n");
FOR_EACH_FUNCTION (node)for ((node) = symtab->first_function (); (node); (node) = symtab
->next_function ((node)))
  ipa_print_node_params (f, node);
4651}

4653/* Stream out jump function JUMP_FUNC to OB.  */

4655static void
4656ipa_write_jump_function (struct output_block *ob,
	 struct ipa_jump_func *jump_func)
4658{
struct ipa_agg_jf_item *item;
struct bitpack_d bp;
int i, count;
int flag = 0;

/* ADDR_EXPRs are very comon IP invariants; save some streamer data
   as well as WPA memory by handling them specially.  */
if (jump_func->type == IPA_JF_CONST
    && TREE_CODE (jump_func->value.constant.value)((enum tree_code) (jump_func->value.constant.value)->base
.code) == ADDR_EXPR)
  flag = 1;

streamer_write_uhwi (ob, jump_func->type * 2 + flag);
switch (jump_func->type)
  {
  case IPA_JF_UNKNOWN:
    break;
  case IPA_JF_CONST:
    gcc_assert (((void)(!(((((jump_func->value.constant.value)) &&
 ((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) ((jump_func->value.constant.value))->base.code
))]) >= tcc_reference && (tree_code_type_tmpl <
0>::tree_code_type[(int) (((enum tree_code) ((jump_func->
value.constant.value))->base.code))]) <= tcc_expression
)) ? (jump_func->value.constant.value)->exp.locus : ((location_t
) 0)) == ((location_t) 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4677, __FUNCTION__), 0 : 0))
 EXPR_LOCATION (jump_func->value.constant.value) == UNKNOWN_LOCATION)((void)(!(((((jump_func->value.constant.value)) &&
 ((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) ((jump_func->value.constant.value))->base.code
))]) >= tcc_reference && (tree_code_type_tmpl <
0>::tree_code_type[(int) (((enum tree_code) ((jump_func->
value.constant.value))->base.code))]) <= tcc_expression
)) ? (jump_func->value.constant.value)->exp.locus : ((location_t
) 0)) == ((location_t) 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4677, __FUNCTION__), 0 : 0));
    stream_write_tree (ob,streamer_hooks.write_tree (ob, flag ? (*((const_cast<tree*
> (tree_operand_check ((jump_func->value.constant.value
), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4680, __FUNCTION__))))) : jump_func->value.constant.value
, true, true)
	 flagstreamer_hooks.write_tree (ob, flag ? (*((const_cast<tree*
> (tree_operand_check ((jump_func->value.constant.value
), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4680, __FUNCTION__))))) : jump_func->value.constant.value
, true, true)
	 ? TREE_OPERAND (jump_func->value.constant.value, 0)streamer_hooks.write_tree (ob, flag ? (*((const_cast<tree*
> (tree_operand_check ((jump_func->value.constant.value
), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4680, __FUNCTION__))))) : jump_func->value.constant.value
, true, true)
	 : jump_func->value.constant.value, true)streamer_hooks.write_tree (ob, flag ? (*((const_cast<tree*
> (tree_operand_check ((jump_func->value.constant.value
), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4680, __FUNCTION__))))) : jump_func->value.constant.value
, true, true);
    break;
  case IPA_JF_PASS_THROUGH:
    streamer_write_uhwi (ob, jump_func->value.pass_through.operation);
    if (jump_func->value.pass_through.operation == NOP_EXPR)
{
 streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
 bp = bitpack_create (ob->main_stream);
 bp_pack_value (&bp, jump_func->value.pass_through.agg_preserved, 1);
 streamer_write_bitpack (&bp);
}
    else if (TREE_CODE_CLASS (jump_func->value.pass_through.operation)tree_code_type_tmpl <0>::tree_code_type[(int) (jump_func
->value.pass_through.operation)]
      == tcc_unary)
streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
    else
{
 stream_write_tree (ob, jump_func->value.pass_through.operand, true)streamer_hooks.write_tree (ob, jump_func->value.pass_through
.operand, true, true);
 streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
}
    break;
  case IPA_JF_ANCESTOR:
    streamer_write_uhwi (ob, jump_func->value.ancestor.offset);
    streamer_write_uhwi (ob, jump_func->value.ancestor.formal_id);
    bp = bitpack_create (ob->main_stream);
    bp_pack_value (&bp, jump_func->value.ancestor.agg_preserved, 1);
    bp_pack_value (&bp, jump_func->value.ancestor.keep_null, 1);
    streamer_write_bitpack (&bp);
    break;
  default:
    fatal_error (UNKNOWN_LOCATION((location_t) 0), "invalid jump function in LTO stream");
  }

count = vec_safe_length (jump_func->agg.items);
streamer_write_uhwi (ob, count);
if (count)
  {
    bp = bitpack_create (ob->main_stream);
    bp_pack_value (&bp, jump_func->agg.by_ref, 1);
    streamer_write_bitpack (&bp);
  }

FOR_EACH_VEC_SAFE_ELT (jump_func->agg.items, i, item)for (i = 0; vec_safe_iterate ((jump_func->agg.items), (i),
 &(item)); ++(i))
  {
    stream_write_tree (ob, item->type, true)streamer_hooks.write_tree (ob, item->type, true, true);
    streamer_write_uhwi (ob, item->offset);
    streamer_write_uhwi (ob, item->jftype);
    switch (item->jftype)
{
case IPA_JF_UNKNOWN:
 break;
case IPA_JF_CONST:
 stream_write_tree (ob, item->value.constant, true)streamer_hooks.write_tree (ob, item->value.constant, true,
 true);
 break;
case IPA_JF_PASS_THROUGH:
case IPA_JF_LOAD_AGG:
 streamer_write_uhwi (ob, item->value.pass_through.operation);
 streamer_write_uhwi (ob, item->value.pass_through.formal_id);
 if (TREE_CODE_CLASS (item->value.pass_through.operation)tree_code_type_tmpl <0>::tree_code_type[(int) (item->
value.pass_through.operation)]
					!= tcc_unary)
   stream_write_tree (ob, item->value.pass_through.operand, true)streamer_hooks.write_tree (ob, item->value.pass_through.operand
, true, true);
 if (item->jftype == IPA_JF_LOAD_AGG)
   {
     stream_write_tree (ob, item->value.load_agg.type, true)streamer_hooks.write_tree (ob, item->value.load_agg.type, true
, true);
     streamer_write_uhwi (ob, item->value.load_agg.offset);
     bp = bitpack_create (ob->main_stream);
     bp_pack_value (&bp, item->value.load_agg.by_ref, 1);
     streamer_write_bitpack (&bp);
   }
 break;
default:
 fatal_error (UNKNOWN_LOCATION((location_t) 0),
       "invalid jump function in LTO stream");
}
  }

bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, !!jump_func->bits, 1);
streamer_write_bitpack (&bp);
if (jump_func->bits)
  {
    streamer_write_widest_int (ob, jump_func->bits->value);
    streamer_write_widest_int (ob, jump_func->bits->mask);
  }
bp_pack_value (&bp, !!jump_func->m_vr, 1);
streamer_write_bitpack (&bp);
if (jump_func->m_vr)
  {
    streamer_write_enum (ob->main_stream, value_rang_type,streamer_write_hwi_in_range ((ob->main_stream), 0, (int)(VR_LAST
) - 1, (int)(jump_func->m_vr->kind ()))
	   VR_LAST, jump_func->m_vr->kind ())streamer_write_hwi_in_range ((ob->main_stream), 0, (int)(VR_LAST
) - 1, (int)(jump_func->m_vr->kind ()));
    stream_write_tree (ob, jump_func->m_vr->min (), true)streamer_hooks.write_tree (ob, jump_func->m_vr->min (),
 true, true);
    stream_write_tree (ob, jump_func->m_vr->max (), true)streamer_hooks.write_tree (ob, jump_func->m_vr->max (),
 true, true);
  }
4773}

4775/* Read in jump function JUMP_FUNC from IB.  */

4777static void
4778ipa_read_jump_function (class lto_input_block *ib,
	struct ipa_jump_func *jump_func,
	struct cgraph_edge *cs,
	class data_in *data_in,
	bool prevails)
4783{
enum jump_func_type jftype;
enum tree_code operation;
int i, count;
int val = streamer_read_uhwi (ib);
bool flag = val & 1;

jftype = (enum jump_func_type) (val / 2);
switch (jftype)
  {
  case IPA_JF_UNKNOWN:
    ipa_set_jf_unknown (jump_func);
    break;
  case IPA_JF_CONST:
    {
tree t = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
if (flag && prevails)
 t = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4800, __FUNCTION__))->typed.type)), t);
ipa_set_jf_constant (jump_func, t, cs);
    }
    break;
  case IPA_JF_PASS_THROUGH:
    operation = (enum tree_code) streamer_read_uhwi (ib);
    if (operation == NOP_EXPR)
{
 int formal_id =  streamer_read_uhwi (ib);
 struct bitpack_d bp = streamer_read_bitpack (ib);
 bool agg_preserved = bp_unpack_value (&bp, 1);
 ipa_set_jf_simple_pass_through (jump_func, formal_id, agg_preserved);
}
    else if (TREE_CODE_CLASS (operation)tree_code_type_tmpl <0>::tree_code_type[(int) (operation
)] == tcc_unary)
{
 int formal_id =  streamer_read_uhwi (ib);
 ipa_set_jf_unary_pass_through (jump_func, formal_id, operation);
}
    else
{
 tree operand = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
 int formal_id =  streamer_read_uhwi (ib);
 ipa_set_jf_arith_pass_through (jump_func, formal_id, operand,
			 operation);
}
    break;
  case IPA_JF_ANCESTOR:
    {
HOST_WIDE_INTlong offset = streamer_read_uhwi (ib);
int formal_id = streamer_read_uhwi (ib);
struct bitpack_d bp = streamer_read_bitpack (ib);
bool agg_preserved = bp_unpack_value (&bp, 1);
bool keep_null = bp_unpack_value (&bp, 1);
ipa_set_ancestor_jf (jump_func, offset, formal_id, agg_preserved,
	     keep_null);
break;
    }
  default:
    fatal_error (UNKNOWN_LOCATION((location_t) 0), "invalid jump function in LTO stream");
  }

count = streamer_read_uhwi (ib);
if (prevails)
  {
    jump_func->agg.items = NULLnullptr;
    vec_safe_reserve (jump_func->agg.items, count, true);
  }
if (count)
  {
    struct bitpack_d bp = streamer_read_bitpack (ib);
    jump_func->agg.by_ref = bp_unpack_value (&bp, 1);
  }
for (i = 0; i < count; i++)
  {
    struct ipa_agg_jf_item item;
    item.type = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
    item.offset = streamer_read_uhwi (ib);
    item.jftype = (enum jump_func_type) streamer_read_uhwi (ib);

    switch (item.jftype)
{
case IPA_JF_UNKNOWN:
 break;
case IPA_JF_CONST:
 item.value.constant = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
 break;
case IPA_JF_PASS_THROUGH:
case IPA_JF_LOAD_AGG:
 operation = (enum tree_code) streamer_read_uhwi (ib);
 item.value.pass_through.operation = operation;
 item.value.pass_through.formal_id = streamer_read_uhwi (ib);
 if (TREE_CODE_CLASS (operation)tree_code_type_tmpl <0>::tree_code_type[(int) (operation
)] == tcc_unary)
   item.value.pass_through.operand = NULL_TREE(tree) nullptr;
 else
   item.value.pass_through.operand = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
 if (item.jftype == IPA_JF_LOAD_AGG)
   {
     struct bitpack_d bp;
     item.value.load_agg.type = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
     item.value.load_agg.offset = streamer_read_uhwi (ib);
     bp = streamer_read_bitpack (ib);
     item.value.load_agg.by_ref = bp_unpack_value (&bp, 1);
   }
 break;
default:
 fatal_error (UNKNOWN_LOCATION((location_t) 0),
       "invalid jump function in LTO stream");
}
    if (prevails)
      jump_func->agg.items->quick_push (item);
  }

struct bitpack_d bp = streamer_read_bitpack (ib);
bool bits_known = bp_unpack_value (&bp, 1);
if (bits_known)
  {
    widest_int value = streamer_read_widest_int (ib);
    widest_int mask = streamer_read_widest_int (ib);
    if (prevails)
      ipa_set_jfunc_bits (jump_func, value, mask);
  }
else
  jump_func->bits = NULLnullptr;

struct bitpack_d vr_bp = streamer_read_bitpack (ib);
bool vr_known = bp_unpack_value (&vr_bp, 1);
if (vr_known)
  {
    enum value_range_kind type = streamer_read_enum (ib, value_range_kind,(enum value_range_kind)streamer_read_hwi_in_range ((ib), "value_range_kind"
, 0, (int)(VR_LAST) - 1)
				       VR_LAST)(enum value_range_kind)streamer_read_hwi_in_range ((ib), "value_range_kind"
, 0, (int)(VR_LAST) - 1);
    tree min = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
    tree max = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
    if (prevails)
      ipa_set_jfunc_vr (jump_func, type, min, max);
  }
else
  jump_func->m_vr = NULLnullptr;
4917}

4919/* Stream out parts of cgraph_indirect_call_info corresponding to CS that are
 relevant to indirect inlining to OB.  */

4922static void
4923ipa_write_indirect_edge_info (struct output_block *ob,
	      struct cgraph_edge *cs)
4925{
class cgraph_indirect_call_info *ii = cs->indirect_info;
struct bitpack_d bp;

streamer_write_hwi (ob, ii->param_index);
bp = bitpack_create (ob->main_stream);
bp_pack_value (&bp, ii->polymorphic, 1);
bp_pack_value (&bp, ii->agg_contents, 1);
bp_pack_value (&bp, ii->member_ptr, 1);
bp_pack_value (&bp, ii->by_ref, 1);
bp_pack_value (&bp, ii->guaranteed_unmodified, 1);
bp_pack_value (&bp, ii->vptr_changed, 1);
streamer_write_bitpack (&bp);
if (ii->agg_contents || ii->polymorphic)
  streamer_write_hwi (ob, ii->offset);
else
  gcc_assert (ii->offset == 0)((void)(!(ii->offset == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 4941, __FUNCTION__), 0 : 0));

if (ii->polymorphic)
  {
    streamer_write_hwi (ob, ii->otr_token);
    stream_write_tree (ob, ii->otr_type, true)streamer_hooks.write_tree (ob, ii->otr_type, true, true);
    ii->context.stream_out (ob);
  }
4949}

4951/* Read in parts of cgraph_indirect_call_info corresponding to CS that are
 relevant to indirect inlining from IB.  */

4954static void
4955ipa_read_indirect_edge_info (class lto_input_block *ib,
	     class data_in *data_in,
	     struct cgraph_edge *cs,
	     class ipa_node_params *info)
4959{
class cgraph_indirect_call_info *ii = cs->indirect_info;
struct bitpack_d bp;

ii->param_index = (int) streamer_read_hwi (ib);
bp = streamer_read_bitpack (ib);
ii->polymorphic = bp_unpack_value (&bp, 1);
ii->agg_contents = bp_unpack_value (&bp, 1);
ii->member_ptr = bp_unpack_value (&bp, 1);
ii->by_ref = bp_unpack_value (&bp, 1);
ii->guaranteed_unmodified = bp_unpack_value (&bp, 1);
ii->vptr_changed = bp_unpack_value (&bp, 1);
if (ii->agg_contents || ii->polymorphic)
  ii->offset = (HOST_WIDE_INTlong) streamer_read_hwi (ib);
else
  ii->offset = 0;
if (ii->polymorphic)
  {
    ii->otr_token = (HOST_WIDE_INTlong) streamer_read_hwi (ib);
    ii->otr_type = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
    ii->context.stream_in (ib, data_in);
  }
if (info && ii->param_index >= 0)
  {
    if (ii->polymorphic)
ipa_set_param_used_by_polymorphic_call (info,
				ii->param_index , true);
    ipa_set_param_used_by_indirect_call (info,
			   ii->param_index, true);
  }
4989}

4991/* Stream out NODE info to OB.  */

4993static void
4994ipa_write_node_info (struct output_block *ob, struct cgraph_node *node)
4995{
int node_ref;
lto_symtab_encoder_t encoder;
ipa_node_params *info = ipa_node_params_sum->get (node);
int j;
struct cgraph_edge *e;
struct bitpack_d bp;

encoder = ob->decl_state->symtab_node_encoder;
node_ref = lto_symtab_encoder_encode (encoder, node);
streamer_write_uhwi (ob, node_ref);

streamer_write_uhwi (ob, ipa_get_param_count (info));
for (j = 0; j < ipa_get_param_count (info); j++)
  streamer_write_uhwi (ob, ipa_get_param_move_cost (info, j));
bp = bitpack_create (ob->main_stream);
gcc_assert (info->analysis_done((void)(!(info->analysis_done || ipa_get_param_count (info
) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5012, __FUNCTION__), 0 : 0))
     || ipa_get_param_count (info) == 0)((void)(!(info->analysis_done || ipa_get_param_count (info
) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5012, __FUNCTION__), 0 : 0));
gcc_assert (!info->node_enqueued)((void)(!(!info->node_enqueued) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5013, __FUNCTION__), 0 : 0));
gcc_assert (!info->ipcp_orig_node)((void)(!(!info->ipcp_orig_node) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5014, __FUNCTION__), 0 : 0));
for (j = 0; j < ipa_get_param_count (info); j++)
  {
    /* TODO: We could just not stream the bit in the undescribed case. */
    bool d = (ipa_get_controlled_uses (info, j) != IPA_UNDESCRIBED_USE-1)
? ipa_get_param_load_dereferenced (info, j) : true;
    bp_pack_value (&bp, d, 1);
    bp_pack_value (&bp, ipa_is_param_used (info, j), 1);
  }
streamer_write_bitpack (&bp);
for (j = 0; j < ipa_get_param_count (info); j++)
  {
    streamer_write_hwi (ob, ipa_get_controlled_uses (info, j));
    stream_write_tree (ob, ipa_get_type (info, j), true)streamer_hooks.write_tree (ob, ipa_get_type (info, j), true, true
);
  }
for (e = node->callees; e; e = e->next_callee)
  {
    ipa_edge_args *args = ipa_edge_args_sum->get (e);

    if (!args)
{
 streamer_write_uhwi (ob, 0);
 continue;
}

    streamer_write_uhwi (ob,
	   ipa_get_cs_argument_count (args) * 2
	   + (args->polymorphic_call_contexts != NULLnullptr));
    for (j = 0; j < ipa_get_cs_argument_count (args); j++)
{
 ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
 if (args->polymorphic_call_contexts != NULLnullptr)
   ipa_get_ith_polymorhic_call_context (args, j)->stream_out (ob);
}
  }
for (e = node->indirect_calls; e; e = e->next_callee)
  {
    ipa_edge_args *args = ipa_edge_args_sum->get (e);
    if (!args)
streamer_write_uhwi (ob, 0);
    else
{
 streamer_write_uhwi (ob,
	       ipa_get_cs_argument_count (args) * 2
	       + (args->polymorphic_call_contexts != NULLnullptr));
 for (j = 0; j < ipa_get_cs_argument_count (args); j++)
   {
     ipa_write_jump_function (ob, ipa_get_ith_jump_func (args, j));
     if (args->polymorphic_call_contexts != NULLnullptr)
ipa_get_ith_polymorhic_call_context (args, j)->stream_out (ob);
   }
}
    ipa_write_indirect_edge_info (ob, e);
  }
5068}

5070/* Stream in edge E from IB.  */

5072static void
5073ipa_read_edge_info (class lto_input_block *ib,
    class data_in *data_in,
    struct cgraph_edge *e, bool prevails)
5076{
int count = streamer_read_uhwi (ib);
bool contexts_computed = count & 1;

count /= 2;
if (!count)
  return;
if (prevails
    && (e->possibly_call_in_translation_unit_p ()
 /* Also stream in jump functions to builtins in hope that they
    will get fnspecs.  */
 || fndecl_built_in_p (e->callee->decl, BUILT_IN_NORMAL)))
  {
    ipa_edge_args *args = ipa_edge_args_sum->get_create (e);
    vec_safe_grow_cleared (args->jump_functions, count, true);
    if (contexts_computed)
vec_safe_grow_cleared (args->polymorphic_call_contexts, count, true);
    for (int k = 0; k < count; k++)
{
 ipa_read_jump_function (ib, ipa_get_ith_jump_func (args, k), e,
		  data_in, prevails);
 if (contexts_computed)
   ipa_get_ith_polymorhic_call_context (args, k)->stream_in
					     (ib, data_in);
}
  }
else
  {
    for (int k = 0; k < count; k++)
{
 struct ipa_jump_func dummy;
 ipa_read_jump_function (ib, &dummy, e,
		  data_in, prevails);
 if (contexts_computed)
   {
     class ipa_polymorphic_call_context ctx;
     ctx.stream_in (ib, data_in);
   }
}
  }
5116}

5118/* Stream in NODE info from IB.  */

5120static void
5121ipa_read_node_info (class lto_input_block *ib, struct cgraph_node *node,
    class data_in *data_in)
5123{
int k;
struct cgraph_edge *e;
struct bitpack_d bp;
bool prevails = node->prevailing_p ();
ipa_node_params *info
  = prevails ? ipa_node_params_sum->get_create (node) : NULLnullptr;

int param_count = streamer_read_uhwi (ib);
if (prevails)
  {
    ipa_alloc_node_params (node, param_count);
    for (k = 0; k < param_count; k++)
      (*info->descriptors)[k].move_cost = streamer_read_uhwi (ib);
    if (ipa_get_param_count (info) != 0)
info->analysis_done = true;
    info->node_enqueued = false;
  }
else
  for (k = 0; k < param_count; k++)
    streamer_read_uhwi (ib);

bp = streamer_read_bitpack (ib);
for (k = 0; k < param_count; k++)
  {
    bool load_dereferenced = bp_unpack_value (&bp, 1);
    bool used = bp_unpack_value (&bp, 1);

    if (prevails)
{
 ipa_set_param_load_dereferenced (info, k, load_dereferenced);
 ipa_set_param_used (info, k, used);
}
  }
for (k = 0; k < param_count; k++)
  {
    int nuses = streamer_read_hwi (ib);
    tree type = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);

    if (prevails)
{
 ipa_set_controlled_uses (info, k, nuses);
 (*info->descriptors)[k].decl_or_type = type;
}
  }
for (e = node->callees; e; e = e->next_callee)
  ipa_read_edge_info (ib, data_in, e, prevails);
for (e = node->indirect_calls; e; e = e->next_callee)
  {
    ipa_read_edge_info (ib, data_in, e, prevails);
    ipa_read_indirect_edge_info (ib, data_in, e, info);
  }
5175}

5177/* Write jump functions for nodes in SET.  */

5179void
5180ipa_prop_write_jump_functions (void)
5181{
struct output_block *ob;
unsigned int count = 0;
lto_symtab_encoder_iterator lsei;
lto_symtab_encoder_t encoder;

if (!ipa_node_params_sum || !ipa_edge_args_sum)
  return;

ob = create_output_block (LTO_section_jump_functions);
encoder = ob->decl_state->symtab_node_encoder;
ob->symbol = NULLnullptr;
for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
     lsei_next_function_in_partition (&lsei))
  {
    cgraph_node *node = lsei_cgraph_node (lsei);
    if (node->has_gimple_body_p ()
 && ipa_node_params_sum->get (node) != NULLnullptr)
count++;
  }

streamer_write_uhwi (ob, count);

/* Process all of the functions.  */
for (lsei = lsei_start_function_in_partition (encoder); !lsei_end_p (lsei);
     lsei_next_function_in_partition (&lsei))
  {
    cgraph_node *node = lsei_cgraph_node (lsei);
    if (node->has_gimple_body_p ()
 && ipa_node_params_sum->get (node) != NULLnullptr)
      ipa_write_node_info (ob, node);
  }
streamer_write_char_stream (ob->main_stream, 0);
produce_asm (ob, NULLnullptr);
destroy_output_block (ob);
5216}

5218/* Read section in file FILE_DATA of length LEN with data DATA.  */

5220static void
5221ipa_prop_read_section (struct lto_file_decl_data *file_data, const char *data,
       size_t len)
5223{
const struct lto_function_header *header =
  (const struct lto_function_header *) data;
const int cfg_offset = sizeof (struct lto_function_header);
const int main_offset = cfg_offset + header->cfg_size;
const int string_offset = main_offset + header->main_size;
class data_in *data_in;
unsigned int i;
unsigned int count;

lto_input_block ib_main ((const char *) data + main_offset,
	   header->main_size, file_data->mode_table);

data_in =
  lto_data_in_create (file_data, (const char *) data + string_offset,
	header->string_size, vNULL);
count = streamer_read_uhwi (&ib_main);

for (i = 0; i < count; i++)
  {
    unsigned int index;
    struct cgraph_node *node;
    lto_symtab_encoder_t encoder;

    index = streamer_read_uhwi (&ib_main);
    encoder = file_data->symtab_node_encoder;
    node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
						index));
    gcc_assert (node->definition)((void)(!(node->definition) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5251, __FUNCTION__), 0 : 0));
    ipa_read_node_info (&ib_main, node, data_in);
  }
lto_free_section_data (file_data, LTO_section_jump_functions, NULLnullptr, data,
	 len);
lto_data_in_delete (data_in);
5257}

5259/* Read ipcp jump functions.  */

5261void
5262ipa_prop_read_jump_functions (void)
5263{
struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
struct lto_file_decl_data *file_data;
unsigned int j = 0;

ipa_check_create_node_params ();
ipa_check_create_edge_args ();
ipa_register_cgraph_hooks ();

while ((file_data = file_data_vec[j++]))
  {
    size_t len;
    const char *data
= lto_get_summary_section_data (file_data, LTO_section_jump_functions,
			&len);
    if (data)
      ipa_prop_read_section (file_data, data, len);
  }
5281}

5283/* Return true if the IPA-CP transformation summary TS is non-NULL and contains
 useful info.  */
5285static bool
5286useful_ipcp_transformation_info_p (ipcp_transformation *ts)
5287{
if (!ts)
  return false;
if (!vec_safe_is_empty (ts->m_agg_values)
    || !vec_safe_is_empty (ts->bits)
    || !vec_safe_is_empty (ts->m_vr))
  return true;
return false;
5295}

5297/* Write into OB IPA-CP transfromation summary TS describing NODE.  */

5299void
5300write_ipcp_transformation_info (output_block *ob, cgraph_node *node,
		ipcp_transformation *ts)
5302{
lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder;
int node_ref = lto_symtab_encoder_encode (encoder, node);
streamer_write_uhwi (ob, node_ref);

streamer_write_uhwi (ob, vec_safe_length (ts->m_agg_values));
for (const ipa_argagg_value &av : ts->m_agg_values)
  {
    struct bitpack_d bp;

    stream_write_tree (ob, av.value, true)streamer_hooks.write_tree (ob, av.value, true, true);
    streamer_write_uhwi (ob, av.unit_offset);
    streamer_write_uhwi (ob, av.index);

    bp = bitpack_create (ob->main_stream);
    bp_pack_value (&bp, av.by_ref, 1);
    streamer_write_bitpack (&bp);
  }

streamer_write_uhwi (ob, vec_safe_length (ts->m_vr));
for (const ipa_vr &parm_vr : ts->m_vr)
  {
    struct bitpack_d bp;
    bp = bitpack_create (ob->main_stream);
    bp_pack_value (&bp, parm_vr.known, 1);
    streamer_write_bitpack (&bp);
    if (parm_vr.known)
{
 streamer_write_enum (ob->main_stream, value_rang_type,streamer_write_hwi_in_range ((ob->main_stream), 0, (int)(VR_LAST
) - 1, (int)(parm_vr.type))
	       VR_LAST, parm_vr.type)streamer_write_hwi_in_range ((ob->main_stream), 0, (int)(VR_LAST
) - 1, (int)(parm_vr.type));
 streamer_write_wide_int (ob, parm_vr.min);
 streamer_write_wide_int (ob, parm_vr.max);
}
  }

streamer_write_uhwi (ob, vec_safe_length (ts->bits));
for (const ipa_bits *bits_jfunc : ts->bits)
  {
    struct bitpack_d bp = bitpack_create (ob->main_stream);
    bp_pack_value (&bp, !!bits_jfunc, 1);
    streamer_write_bitpack (&bp);
    if (bits_jfunc)
{
 streamer_write_widest_int (ob, bits_jfunc->value);
 streamer_write_widest_int (ob, bits_jfunc->mask);
}
  }
5349}

5351/* Stream in the aggregate value replacement chain for NODE from IB.  */

5353static void
5354read_ipcp_transformation_info (lto_input_block *ib, cgraph_node *node,
	       data_in *data_in)
5356{
unsigned int count, i;
ipcp_transformation_initialize ();
ipcp_transformation *ts = ipcp_transformation_sum->get_create (node);

count = streamer_read_uhwi (ib);
if (count > 0)
  {
    vec_safe_grow_cleared (ts->m_agg_values, count, true);
    for (i = 0; i <count; i++)
{
 ipa_argagg_value *av = &(*ts->m_agg_values)[i];;

 av->value = stream_read_tree (ib, data_in)streamer_hooks.read_tree (ib, data_in);
 av->unit_offset = streamer_read_uhwi (ib);
 av->index = streamer_read_uhwi (ib);

 bitpack_d bp = streamer_read_bitpack (ib);
 av->by_ref = bp_unpack_value (&bp, 1);
}
  }

count = streamer_read_uhwi (ib);
if (count > 0)
  {
    vec_safe_grow_cleared (ts->m_vr, count, true);
    for (i = 0; i < count; i++)
{
 ipa_vr *parm_vr;
 parm_vr = &(*ts->m_vr)[i];
 struct bitpack_d bp;
 bp = streamer_read_bitpack (ib);
 parm_vr->known = bp_unpack_value (&bp, 1);
 if (parm_vr->known)
   {
     parm_vr->type = streamer_read_enum (ib, value_range_kind,(enum value_range_kind)streamer_read_hwi_in_range ((ib), "value_range_kind"
, 0, (int)(VR_LAST) - 1)
				  VR_LAST)(enum value_range_kind)streamer_read_hwi_in_range ((ib), "value_range_kind"
, 0, (int)(VR_LAST) - 1);
     parm_vr->min = streamer_read_wide_int (ib);
     parm_vr->max = streamer_read_wide_int (ib);
   }
}
  }
count = streamer_read_uhwi (ib);
if (count > 0)
  {
    vec_safe_grow_cleared (ts->bits, count, true);
    for (i = 0; i < count; i++)
{
 struct bitpack_d bp = streamer_read_bitpack (ib);
 bool known = bp_unpack_value (&bp, 1);
 if (known)
   {
     const widest_int value = streamer_read_widest_int (ib);
     const widest_int mask = streamer_read_widest_int (ib);
     ipa_bits *bits
= ipa_get_ipa_bits_for_value (value, mask);
     (*ts->bits)[i] = bits;
   }
}
  }
5416}

5418/* Write all aggregate replacement for nodes in set.  */

5420void
5421ipcp_write_transformation_summaries (void)
5422{
struct output_block *ob;
unsigned int count = 0;
lto_symtab_encoder_t encoder;

ob = create_output_block (LTO_section_ipcp_transform);
encoder = ob->decl_state->symtab_node_encoder;
ob->symbol = NULLnullptr;

for (int i = 0; i < lto_symtab_encoder_size (encoder); i++)
  {
    symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
    cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
    if (!cnode)
continue;
    ipcp_transformation *ts = ipcp_get_transformation_summary (cnode);
    if (useful_ipcp_transformation_info_p (ts)
 && lto_symtab_encoder_encode_body_p (encoder, cnode))
count++;
  }

streamer_write_uhwi (ob, count);

for (int i = 0; i < lto_symtab_encoder_size (encoder); i++)
  {
    symtab_node *snode = lto_symtab_encoder_deref (encoder, i);
    cgraph_node *cnode = dyn_cast <cgraph_node *> (snode);
    if (!cnode)
continue;
    ipcp_transformation *ts = ipcp_get_transformation_summary (cnode);
    if (useful_ipcp_transformation_info_p (ts)
 && lto_symtab_encoder_encode_body_p (encoder, cnode))
write_ipcp_transformation_info (ob, cnode, ts);
  }
streamer_write_char_stream (ob->main_stream, 0);
produce_asm (ob, NULLnullptr);
destroy_output_block (ob);
5459}

5461/* Read replacements section in file FILE_DATA of length LEN with data
 DATA.  */

5464static void
5465read_replacements_section (struct lto_file_decl_data *file_data,
	   const char *data,
	   size_t len)
5468{
const struct lto_function_header *header =
  (const struct lto_function_header *) data;
const int cfg_offset = sizeof (struct lto_function_header);
const int main_offset = cfg_offset + header->cfg_size;
const int string_offset = main_offset + header->main_size;
class data_in *data_in;
unsigned int i;
unsigned int count;

lto_input_block ib_main ((const char *) data + main_offset,
	   header->main_size, file_data->mode_table);

data_in = lto_data_in_create (file_data, (const char *) data + string_offset,
		header->string_size, vNULL);
count = streamer_read_uhwi (&ib_main);

for (i = 0; i < count; i++)
  {
    unsigned int index;
    struct cgraph_node *node;
    lto_symtab_encoder_t encoder;

    index = streamer_read_uhwi (&ib_main);
    encoder = file_data->symtab_node_encoder;
    node = dyn_cast<cgraph_node *> (lto_symtab_encoder_deref (encoder,
						index));
    read_ipcp_transformation_info (&ib_main, node, data_in);
  }
lto_free_section_data (file_data, LTO_section_jump_functions, NULLnullptr, data,
	 len);
lto_data_in_delete (data_in);
5500}

5502/* Read IPA-CP aggregate replacements.  */

5504void
5505ipcp_read_transformation_summaries (void)
5506{
struct lto_file_decl_data **file_data_vec = lto_get_file_decl_data ();
struct lto_file_decl_data *file_data;
unsigned int j = 0;

while ((file_data = file_data_vec[j++]))
  {
    size_t len;
    const char *data
= lto_get_summary_section_data (file_data, LTO_section_ipcp_transform,
			&len);
    if (data)
      read_replacements_section (file_data, data, len);
  }
5520}

5522/* Adjust the aggregate replacements in TS to reflect any parameter removals
 which might have already taken place.  If after adjustments there are no
 aggregate replacements left, the m_agg_values will be set to NULL.  In other
 cases, it may be shrunk.  */

5527static void
5528adjust_agg_replacement_values (cgraph_node *node, ipcp_transformation *ts)
5529{
clone_info *cinfo = clone_info::get (node);
if (!cinfo || !cinfo->param_adjustments)
  return;

auto_vec<int, 16> new_indices;
cinfo->param_adjustments->get_updated_indices (&new_indices);
bool removed_item = false;
unsigned dst_index = 0;
unsigned count = ts->m_agg_values->length ();
for (unsigned i = 0; i < count; i++)
  {
    ipa_argagg_value *v = &(*ts->m_agg_values)[i];
    gcc_checking_assert (v->index >= 0)((void)(!(v->index >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5542, __FUNCTION__), 0 : 0));

    int new_idx = -1;
    if ((unsigned) v->index < new_indices.length ())
new_idx = new_indices[v->index];

    if (new_idx >= 0)
{
 v->index = new_idx;
 if (removed_item)
   (*ts->m_agg_values)[dst_index] = *v;
 dst_index++;
}
    else
removed_item = true;
  }

if (dst_index == 0)
  {
    ggc_free (ts->m_agg_values);
    ts->m_agg_values = NULLnullptr;
  }
else if (removed_item)
  ts->m_agg_values->truncate (dst_index);

return;
5568}

5570/* Dominator walker driving the ipcp modification phase.  */

5572class ipcp_modif_dom_walker : public dom_walker
5573{
5574public:
ipcp_modif_dom_walker (struct ipa_func_body_info *fbi,
	 vec<ipa_param_descriptor, va_gc> *descs,
	 ipcp_transformation *ts, bool *sc)
  : dom_walker (CDI_DOMINATORS), m_fbi (fbi), m_descriptors (descs),
    m_ts (ts), m_something_changed (sc) {}

edge before_dom_children (basic_block) final override;
bool cleanup_eh ()
  { return gimple_purge_all_dead_eh_edges (m_need_eh_cleanup); }

5585private:
struct ipa_func_body_info *m_fbi;
vec<ipa_param_descriptor, va_gc> *m_descriptors;
ipcp_transformation *m_ts;
bool *m_something_changed;
auto_bitmap m_need_eh_cleanup;
5591};

5593edge
5594ipcp_modif_dom_walker::before_dom_children (basic_block bb)
5595{
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
  {
    gimple *stmt = gsi_stmt (gsi);
    tree rhs, val, t;
    HOST_WIDE_INTlong bit_offset;
    poly_int64 size;
    int index;
    bool by_ref, vce;

    if (!gimple_assign_load_p (stmt))
continue;
    rhs = gimple_assign_rhs1 (stmt);
    if (!is_gimple_reg_type (TREE_TYPE (rhs)((contains_struct_check ((rhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5609, __FUNCTION__))->typed.type)))
continue;

    vce = false;
    t = rhs;
    while (handled_component_p (t))
{
 /* V_C_E can do things like convert an array of integers to one
    bigger integer and similar things we do not handle below.  */
 if (TREE_CODE (t)((enum tree_code) (t)->base.code) == VIEW_CONVERT_EXPR)
   {
     vce = true;
     break;
   }
 t = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5623, __FUNCTION__)))));
}
    if (vce)
continue;

    if (!ipa_load_from_parm_agg (m_fbi, m_descriptors, stmt, rhs, &index,
		   &bit_offset, &size, &by_ref))
continue;
    unsigned unit_offset = bit_offset / BITS_PER_UNIT(8);
    ipa_argagg_value_list avl (m_ts);
    tree v = avl.get_value (index, unit_offset, by_ref);

    if (!v
 || maybe_ne (tree_to_poly_int64 (TYPE_SIZE (TREE_TYPE (v))((tree_class_check ((((contains_struct_check ((v), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5636, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/ipa-prop.cc"
, 5636, __FUNCTION__))->type_common.size)), size))
continue;